fix: use temp file for message to avoid shell parsing issues

The message passed to opencode run contains newlines and special
characters (parentheses, etc.) which break shell parsing when passed
directly in double quotes.

Fix by writing message to temp file and using '@msg_file' syntax
to pass to opencode run. This handles any characters in the message.

docs/CHANGELOG.md

@@ -6,6 +6,25 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
 
 ## [Unreleased]
 
+## [v0.2.4] - 2026-04-06
+
+### Fixed
+- Queue daemon: Locking to prevent daemon vs manual conflicts
+- Queue daemon: Proper error handling for failed tasks
+- Queue daemon: Fix GITEA_TOKEN loading from pm-agent.env
+- cmd_delegate: Enqueue tasks instead of bypassing queue
+- Notifications: Call kugetsu_add_notification from bash instead of os.system()
+- kugetsu: Remove duplicate update_queue_item_state that overwrote fixed version
+
+### Added
+- Queue functions moved to kugetsu-index.sh for daemon access
+- kugetsu-session.sh sources required modules for daemon use
+
+## [v0.2.3] - 2026-04-06
+
+### Fixed
+- get_pending_tasks() returns proper JSON array instead of concatenated JSON objects
+
 ## [v0.2.1] - 2026-04-03
 
 ### Fixed

skills/kugetsu/scripts/kugetsu

@@ -93,6 +93,10 @@ EOF
 
 ensure_dirs() {
     mkdir -p "$SESSIONS_DIR"
+    mkdir -p "$LOGS_DIR"
+    mkdir -p "$WORKTREES_DIR"
+    mkdir -p "$QUEUE_DIR"
+    mkdir -p "$QUEUE_ITEMS_DIR"
 }
 
 ensure_worktree_dir() {
@@ -257,7 +261,9 @@ PYEOF
 }
 
 ensure_queue_dirs() {
+    mkdir -p "$QUEUE_DIR"
     mkdir -p "$QUEUE_ITEMS_DIR"
+    mkdir -p "$LOGS_DIR"
 }
 
 generate_queue_id() {
@@ -361,55 +367,6 @@ get_queue_stats() {
     echo "{\"total\": $total, \"pending\": $pending, \"notified\": $notified, \"completed\": $completed, \"error\": $error}"
 }
 
-update_queue_item_state() {
-    local queue_id="$1"
-    local new_state="$2"
-    local session_id="${3:-}"
-    local pid="${4:-}"
-    
-    local item_file="$QUEUE_ITEMS_DIR/${queue_id}.json"
-    if [ ! -f "$item_file" ]; then
-        echo "Error: Queue item not found: $queue_id" >&2
-        return 1
-    fi
-    
-    python3 << PYEOF
-import json
-import os
-from datetime import datetime
-
-item_file = "$item_file"
-new_state = "$new_state"
-session_id = "$session_id"
-pid = "$pid"
-
-with open(item_file, 'r') as f:
-    item = json.load(f)
-
-issue_ref = item.get('issue_ref', '')
-
-item['state'] = new_state
-
-if new_state == "notified":
-    item['notified_at'] = datetime.now().isoformat() + "Z"
-    if session_id:
-        item['opencode_session_id'] = session_id
-    if pid:
-        item['pid'] = int(pid) if pid.isdigit() else None
-elif new_state == "completed":
-    item['completed_at'] = datetime.now().isoformat() + "Z"
-    os.system(f"kugetsu_add_notification 'task_completed' 'Task completed: {issue_ref}' '{issue_ref}'")
-elif new_state == "error":
-    item['error'] = datetime.now().isoformat() + "Z"
-    os.system(f"kugetsu_add_notification 'task_error' 'Task error: {issue_ref}' '{issue_ref}'")
-
-with open(item_file, 'w') as f:
-    json.dump(item, f, indent=2)
-
-print(f"Updated $queue_id to state: $new_state")
-PYEOF
-}
-
 check_task_timeouts() {
     if [ ! -d "$QUEUE_ITEMS_DIR" ]; then
         return
@@ -518,97 +475,6 @@ read_index() {
     fi
 }
 
-write_index() {
-    local base="$1"
-    local pm_agent="$2"
-    local issues_json="$3"
-    local temp_file="$INDEX_FILE.tmp.$$"
-    printf '{"base": %s, "pm_agent": %s, "issues": %s}\n' "$base" "$pm_agent" "$issues_json" > "$temp_file"
-    mv "$temp_file" "$INDEX_FILE"
-}
-
-get_base_session_id() {
-    local index=$(read_index)
-    echo "$index" | python3 -c "import sys, json; d=json.load(sys.stdin); print(d.get('base') or '')"
-}
-
-get_pm_agent_session_id() {
-    local index=$(read_index)
-    echo "$index" | python3 -c "import sys, json; d=json.load(sys.stdin); print(d.get('pm_agent') or '')"
-}
-
-get_session_for_issue() {
-    local issue_ref="$1"
-    local index=$(read_index)
-    echo "$index" | python3 -c "import sys, json; d=json.load(sys.stdin); print(d['issues'].get('$issue_ref') or '')"
-}
-
-set_base_in_index() {
-    local base_session_id="$1"
-    local pm_agent=$(get_pm_agent_session_id)
-    local issues_json=$(read_index | python3 -c "import sys, json; d=json.load(sys.stdin); print(json.dumps(d['issues']))")
-    if [ -z "$pm_agent" ] || [ "$pm_agent" = "null" ]; then
-        write_index "\"$base_session_id\"" "null" "$issues_json"
-    else
-        write_index "\"$base_session_id\"" "\"$pm_agent\"" "$issues_json"
-    fi
-}
-
-set_pm_agent_in_index() {
-    local pm_agent_session_id="$1"
-    local base=$(get_base_session_id)
-    local issues_json=$(read_index | python3 -c "import sys, json; d=json.load(sys.stdin); print(json.dumps(d['issues']))")
-    if [ -z "$base" ] || [ "$base" = "null" ]; then
-        write_index "null" "\"$pm_agent_session_id\"" "$issues_json"
-    else
-        write_index "\"$base\"" "\"$pm_agent_session_id\"" "$issues_json"
-    fi
-}
-
-add_issue_to_index() {
-    local issue_ref="$1"
-    local session_file="$2"
-    local index=$(read_index)
-    local base=$(get_base_session_id)
-    local pm_agent=$(get_pm_agent_session_id)
-    local issues=$(echo "$index" | python3 -c "import sys, json; d=json.load(sys.stdin); print(json.dumps(d['issues']))")
-    local new_issues=$(echo "$issues" | python3 -c "import sys, json; d=json.load(sys.stdin); d['$issue_ref']='$session_file'; print(json.dumps(d))")
-    if [ -z "$base" ] || [ "$base" = "null" ]; then
-        if [ -z "$pm_agent" ] || [ "$pm_agent" = "null" ]; then
-            write_index "null" "null" "$new_issues"
-        else
-            write_index "null" "\"$pm_agent\"" "$new_issues"
-        fi
-    else
-        if [ -z "$pm_agent" ] || [ "$pm_agent" = "null" ]; then
-            write_index "\"$base\"" "null" "$new_issues"
-        else
-            write_index "\"$base\"" "\"$pm_agent\"" "$new_issues"
-        fi
-    fi
-}
-
-remove_issue_from_index() {
-    local issue_ref="$1"
-    local index=$(read_index)
-    local base=$(get_base_session_id)
-    local pm_agent=$(get_pm_agent_session_id)
-    local new_issues=$(echo "$index" | python3 -c "import sys, json; d=json.load(sys.stdin); d['issues'].pop('$issue_ref', None); print(json.dumps(d['issues']))")
-    if [ -z "$base" ] || [ "$base" = "null" ]; then
-        if [ -z "$pm_agent" ] || [ "$pm_agent" = "null" ]; then
-            write_index "null" "null" "$new_issues"
-        else
-            write_index "null" "\"$pm_agent\"" "$new_issues"
-        fi
-    else
-        if [ -z "$pm_agent" ] || [ "$pm_agent" = "null" ]; then
-            write_index "\"$base\"" "null" "$new_issues"
-        else
-            write_index "\"$base\"" "\"$pm_agent\"" "$new_issues"
-        fi
-    fi
-}
-
 validate_issue_ref() {
     local issue_ref="$1"
     if [[ ! "$issue_ref" =~ ^[^/]+/[^/]+/[^#]+#[0-9]+$ ]]; then
@@ -897,6 +763,11 @@ EOF
 }
 
 parse_issue_ref_from_message() {
+    # DEPRECATED: This function is not called anywhere.
+    # The active implementation is extract_issue_ref_from_message()
+    # in kugetsu-session.sh which is used by cmd_delegate.
+    # This function is kept for backwards compatibility and will
+    # be removed in a future release.
     local message="$1"
     
     local gitserver=""
@@ -904,21 +775,20 @@ parse_issue_ref_from_message() {
     local repo=""
     local issue_number=""
     
-    if echo "$message" | grep -qE '[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+/(issues|pull)/[0-9]+'; then
+    if [[ "$message" =~ (https?://)?([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/([a-zA-Z0-9._-]+)/([a-zA-Z0-9._-]+)/(issues|pull)/([0-9]+) ]]; then
-        gitserver=$(echo "$message" | grep -oE '[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+' | head -1 | sed 's/\/[^/]*\/[^/]*$//')
+        gitserver="${BASH_REMATCH[2]}"
-        local full_path=$(echo "$message" | grep -oE '[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+/(issues|pull)/[0-9]+' | head -1)
+        owner="${BASH_REMATCH[3]}"
-        owner=$(echo "$full_path" | cut -d'/' -f2)
+        repo="${BASH_REMATCH[4]}"
-        repo=$(echo "$full_path" | cut -d'/' -f3)
+        issue_number="${BASH_REMATCH[6]}"
-        issue_number=$(echo "$full_path" | grep -oE '[0-9]+$' | head -1)
+    elif [[ "$message" =~ (https?://)?([a-zA-Z0-9.-]+\.[a-zA-Z]{2,})/([a-zA-Z0-9._-]+)/([a-zA-Z0-9._-]+)#([0-9]+) ]]; then
-    elif echo "$message" | grep -qE '[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+#[0-9]+'; then
+        gitserver="${BASH_REMATCH[2]}"
-        gitserver=$(echo "$message" | grep -oE '[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}/[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+' | head -1)
+        owner="${BASH_REMATCH[3]}"
-        owner=$(echo "$gitserver" | cut -d'/' -f2)
+        repo="${BASH_REMATCH[4]}"
-        repo=$(echo "$gitserver" | cut -d'/' -f3)
+        issue_number="${BASH_REMATCH[5]}"
-        issue_number=$(echo "$message" | grep -oE '#[0-9]+' | grep -oE '[0-9]+' | head -1)
+    elif [[ "$message" =~ ([a-zA-Z0-9._-]+)/([a-zA-Z0-9._-]+)#([0-9]+) ]]; then
-    elif echo "$message" | grep -qE '[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+#([0-9]+)'; then
+        owner="${BASH_REMATCH[1]}"
-        owner=$(echo "$message" | grep -oE '[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+#' | sed 's/#$//' | cut -d'/' -f1)
+        repo="${BASH_REMATCH[2]}"
-        repo=$(echo "$message" | grep -oE '[a-zA-Z0-9_.-]+/[a-zA-Z0-9_.-]+#' | sed 's/#$//' | cut -d'/' -f2)
+        issue_number="${BASH_REMATCH[3]}"
-        issue_number=$(echo "$message" | grep -oE '#[0-9]+' | grep -oE '[0-9]+' | head -1)
     fi
     
     echo "${gitserver}|${owner}|${repo}|${issue_number}"

skills/kugetsu/scripts/kugetsu-config.sh

@@ -53,5 +53,9 @@ load_agent_env() {
         set -a
         source "$ENV_DIR/default.env"
         set +a
+    elif [ -f "$ENV_DIR/pm-agent.env" ]; then
+        set -a
+        source "$ENV_DIR/pm-agent.env"
+        set +a
     fi
 }

skills/kugetsu/scripts/kugetsu-index.sh

@@ -15,6 +15,13 @@ write_index() {
     local issues_json="$3"
     local temp_file="$INDEX_FILE.tmp.$$"
     printf '{"base": %s, "pm_agent": %s, "issues": %s}\n' "$base" "$pm_agent" "$issues_json" > "$temp_file"
+    
+    if ! python3 -c "import json; json.load(open('$temp_file'))" 2>/dev/null; then
+        echo "Error: write_index would create malformed JSON, aborting. base=$base, pm_agent=$pm_agent, issues_json=$issues_json" >&2
+        rm -f "$temp_file"
+        return 1
+    fi
+    
     mv "$temp_file" "$INDEX_FILE"
 }
 
@@ -43,7 +50,11 @@ set_base_in_index() {
     if [ "$session_id" = "null" ]; then
         write_index "null" "$pm_agent" "$issues"
     else
-        write_index "\"$session_id\"" "$pm_agent" "$issues"
+        if [ "$pm_agent" = "null" ]; then
+            write_index "\"$session_id\"" "null" "$issues"
+        else
+            write_index "\"$session_id\"" "\"$pm_agent\"" "$issues"
+        fi
     fi
 }
 
@@ -56,7 +67,11 @@ set_pm_agent_in_index() {
     if [ "$session_id" = "null" ]; then
         write_index "$base" "null" "$issues"
     else
-        write_index "$base" "\"$session_id\"" "$issues"
+        if [ "$base" = "null" ]; then
+            write_index "null" "\"$session_id\"" "$issues"
+        else
+            write_index "\"$base\"" "\"$session_id\"" "$issues"
+        fi
     fi
 }
 
@@ -72,7 +87,19 @@ add_issue_to_index() {
     
     issues=$(python3 -c "import sys, json; d=json.load(sys.stdin); d['$issue_ref']='$session_file'; print(json.dumps(d))" <<< "$issues")
     
-    write_index "$base" "$pm_agent" "$issues"
+    if [ "$base" = "null" ]; then
+        if [ "$pm_agent" = "null" ]; then
+            write_index "null" "null" "$issues"
+        else
+            write_index "null" "\"$pm_agent\"" "$issues"
+        fi
+    else
+        if [ "$pm_agent" = "null" ]; then
+            write_index "\"$base\"" "null" "$issues"
+        else
+            write_index "\"$base\"" "\"$pm_agent\"" "$issues"
+        fi
+    fi
 }
 
 remove_issue_from_index() {
@@ -86,7 +113,19 @@ remove_issue_from_index() {
     
     issues=$(python3 -c "import sys, json; d=json.load(sys.stdin); d.pop('$issue_ref', None); print(json.dumps(d))" <<< "$issues")
     
-    write_index "$base" "$pm_agent" "$issues"
+    if [ "$base" = "null" ]; then
+        if [ "$pm_agent" = "null" ]; then
+            write_index "null" "null" "$issues"
+        else
+            write_index "null" "\"$pm_agent\"" "$issues"
+        fi
+    else
+        if [ "$pm_agent" = "null" ]; then
+            write_index "\"$base\"" "null" "$issues"
+        else
+            write_index "\"$base\"" "\"$pm_agent\"" "$issues"
+        fi
+    fi
 }
 
 validate_issue_ref() {

skills/kugetsu/scripts/kugetsu-log.sh

@@ -43,15 +43,24 @@ kugetsu_add_notification() {
         notifications=$(cat "$NOTIFICATIONS_FILE")
     fi
     
-    local new_notification=$(python3 -c "import json; print(json.dumps({
+    notifications=$(echo "$notifications" | python3 -c "
-        'type': '$notification_type',
+import json
-        'message': '$message',
+import sys
-        'issue_ref': '$issue_ref',
+
-        'timestamp': '$timestamp',
+notifications = json.load(sys.stdin)
-        'read': False
+new_notification = {
-    }))")
+    'type': '$notification_type',
-    
+    'message': '''$message'''.replace('\"', '\"'),
-    notifications=$(python3 -c "import json; n=json.loads('$notifications'); n.append(json.loads('$new_notification')); print(json.dumps(n[-50:] if len(n)>50 else n, indent=2))")
+    'issue_ref': '$issue_ref' if '$issue_ref' else None,
+    'timestamp': '$timestamp',
+    'read': False
+}
+
+notifications.append(new_notification)
+notifications = notifications[-50:] if len(notifications) > 50 else notifications
+
+print(json.dumps(notifications, indent=2))
+")
     
     echo "$notifications" > "$NOTIFICATIONS_FILE"
 }

skills/kugetsu/scripts/kugetsu-queue-daemon.sh

@@ -44,7 +44,7 @@ check_task_completion() {
 
     if [ -n "$pid" ] && [ "$pid" != "None" ]; then
         if ! kill -0 "$pid" 2>/dev/null; then
-            local worktree_path=$(issue_ref_to_worktree_path "$issue_ref" "$HOME/.kugetsu-worktrees")
+            local worktree_path=$(issue_ref_to_worktree_path "$issue_ref" "$WORKTREES_DIR")
             local has_commits=false
 
             if [ -d "$worktree_path" ] && [ -d "$worktree_path/.git" ]; then
@@ -64,7 +64,7 @@ check_task_completion() {
         fi
     else
         if [ -n "$session_id" ] && ! opencode session list 2>/dev/null | grep -q "$session_id"; then
-            local worktree_path=$(issue_ref_to_worktree_path "$issue_ref" "$HOME/.kugetsu-worktrees")
+            local worktree_path=$(issue_ref_to_worktree_path "$issue_ref" "$WORKTREES_DIR")
             local has_commits=false
 
             if [ -d "$worktree_path" ] && [ -d "$worktree_path/.git" ]; then
@@ -109,7 +109,7 @@ process_task() {
 
     source "$SCRIPT_DIR/kugetsu-session.sh"
 
-    if worktree_exists "$issue_ref" "$HOME/.kugetsu-worktrees" || [ -f "$SESSIONS_DIR/$(issue_ref_to_filename "$issue_ref").json" ]; then
+    if worktree_exists "$issue_ref" "$WORKTREES_DIR" || [ -f "$SESSIONS_DIR/$(issue_ref_to_filename "$issue_ref").json" ]; then
         log_file="$LOGS_DIR/delegate-$(date +%s).log"
         if cmd_continue "$issue_ref" "$message" >> "$log_file" 2>&1; then
             sleep 1

skills/kugetsu/scripts/kugetsu-session.sh

@@ -58,12 +58,35 @@ EOF
         echo "Created config file: $KUGETSU_DIR/config"
     fi
 
+    mkdir -p "$ENV_DIR"
+    if [ ! -f "$ENV_DIR/default.env" ]; then
+        cat > "$ENV_DIR/default.env" << 'EOF'
+# Environment variables for agents
+# Copy this file to <agent-type>.env (e.g., pm-agent.env, dev.env)
+# and set your tokens and configuration
+
+# Required: Gitea token for API access
+# GITEA_TOKEN=your_gitea_token_here
+
+# Optional: GitHub token (if using GitHub)
+# GITHUB_TOKEN=your_github_token_here
+
+# Optional: GitLab token (if using GitLab)
+# GITLAB_TOKEN=your_gitlab_token_here
+EOF
+        echo "Created env template: $ENV_DIR/default.env"
+    fi
+
     local existing_base=$(get_base_session_id)
     local existing_pm=$(get_pm_agent_session_id)
     
     if [ -n "$existing_base" ] && [ "$existing_base" != "null" ]; then
         if [ "$force" = true ]; then
             echo "Warning: Reinitializing sessions (force mode)" >&2
+            echo "Destroying all sessions, worktrees, and logs..." >&2
+            cmd_destroy --base -y 2>/dev/null || true
+            cmd_destroy --pm-agent -y 2>/dev/null || true
+            rm -f "$LOGS_DIR"/*.log 2>/dev/null || true
         else
             echo "Error: Base session already exists: $existing_base" >&2
             echo "Use --force to reinitialize" >&2
@@ -81,9 +104,20 @@ EOF
     echo "Press Ctrl+C to cancel or wait for session to be created"
     sleep 2
 
+    local before_sessions=$(opencode session list 2>/dev/null | grep -E '^ses_' | awk '{print $1}' || true)
+
     opencode
 
-    local session_ids=$(opencode session list 2>/dev/null | grep -E '^ses_' | awk '{print $1}' | tail -1)
+    local after_sessions=$(opencode session list 2>/dev/null | grep -E '^ses_' | awk '{print $1}' || true)
+    local session_ids=""
+    while IFS= read -r line; do
+        local sid=$(echo "$line" | awk '{print $1}')
+        if [ -n "$sid" ] && ! echo "$before_sessions" | grep -q "^${sid}$"; then
+            session_ids="$sid"
+            break
+        fi
+    done <<< "$after_sessions"
+
     if [ -z "$session_ids" ]; then
         echo "Error: Could not find newly created session" >&2
         exit 1
@@ -95,9 +129,20 @@ EOF
     echo "Base session created: $session_ids"
     echo "Starting PM agent..."
 
+    before_sessions="$after_sessions"
+
     opencode
 
-    local pm_session_ids=$(opencode session list 2>/dev/null | grep -E '^ses_' | grep -v "$session_ids" | tail -1)
+    after_sessions=$(opencode session list 2>/dev/null | grep -E '^ses_' | awk '{print $1}' || true)
+    local pm_session_ids=""
+    while IFS= read -r line; do
+        local sid=$(echo "$line" | awk '{print $1}')
+        if [ -n "$sid" ] && ! echo "$before_sessions" | grep -q "^${sid}$"; then
+            pm_session_ids="$sid"
+            break
+        fi
+    done <<< "$after_sessions"
+
     if [ -z "$pm_session_ids" ]; then
         echo "Warning: Could not find separate PM agent session" >&2
         pm_session_ids="$session_ids"
@@ -134,13 +179,11 @@ extract_issue_ref_from_message() {
         return
     fi
     
-    if [[ "$message" =~ (https?://[a-zA-Z0-9.-]+/[a-zA-Z0-9._-]+/[a-zA-Z0-9._-]+/(issues|pull)/[0-9]+) ]]; then
+    if [[ "$message" =~ (https?://)?([a-zA-Z0-9.-]+)/([a-zA-Z0-9._-]+)/([a-zA-Z0-9._-]+)/(issues|pull)/([0-9]+) ]]; then
-        local url="${BASH_REMATCH[1]}"
+        local instance="${BASH_REMATCH[2]}"
-        local path=$(echo "$url" | sed 's|https\?://||' | cut -d'/' -f2-)
+        local owner="${BASH_REMATCH[3]}"
-        local instance=$(echo "$path" | cut -d'/' -f1)
+        local repo="${BASH_REMATCH[4]}"
-        local owner=$(echo "$path" | cut -d'/' -f2)
+        local num="${BASH_REMATCH[6]}"
-        local repo=$(echo "$path" | cut -d'/' -f3)
-        local num=$(echo "$path" | grep -oE '[0-9]+$')
         echo "${instance}/${owner}/${repo}#${num}"
         return
     fi
@@ -165,18 +208,94 @@ cmd_delegate() {
         return
     fi
     
-    # No issue ref detected — delegate directly to PM agent (legacy path)
+    # No issue ref detected — fork a new session from base session
-    local pm_session=$(get_pm_agent_session_id)
+    local base_session=$(get_base_session_id)
-    if [ -z "$pm_session" ] || [ "$pm_session" = "null" ] || [ "$pm_session" = "None" ]; then
+    if [ -z "$base_session" ] || [ "$base_session" = "null" ]; then
-        echo "Error: PM agent session not found. Run 'kugetsu init' first." >&2
+        echo "Error: Base session not found. Run 'kugetsu init' first." >&2
         exit 1
     fi
     
     mkdir -p "$LOGS_DIR"
     local log_file="$LOGS_DIR/delegate-$(date +%s).log"
-    nohup sh -c "GITEA_TOKEN='***' opencode run '$message' --continue --session '$pm_session' >> '$log_file' 2>&1" > /dev/null 2>&1 &
+    load_agent_env "pm-agent"
-    disown
+    
-    echo "Delegated to PM agent (logged to $(basename "$log_file"))"
+    local new_session=$(create_session "$base_session")
+    if [ -z "$new_session" ]; then
+        echo "Error: Failed to create session" >&2
+        exit 1
+    fi
+    
+    local msg_file="$LOGS_DIR/msg-$new_session.txt"
+    printf '%s' "$message" > "$msg_file"
+    nohup sh -c "GITEA_TOKEN='${GITEA_TOKEN:-}' opencode run '@$msg_file' --session '$new_session'" >> "$log_file" 2>&1 &
+    rm -f "$msg_file"
+    echo "Delegated to new session (logged to $(basename "$log_file"))"
+}
+
+create_session() {
+    local base_session="${1:-$base_session_id}"
+    
+    if [ -z "$base_session" ] || [ "$base_session" = "null" ]; then
+        echo "Error: base session not found. Run 'kugetsu init' first." >&2
+        return 1
+    fi
+    
+    local before_json=$(opencode session list --format=json 2>/dev/null)
+    local before_ids=$(echo "$before_json" | python3 -c "import sys,json; sessions=json.load(sys.stdin); print(' '.join(s['id'] for s in sessions))" 2>/dev/null || echo "")
+    
+    opencode run --fork --session "$base_session" "new session" 2>/dev/null
+    
+    local after_json=$(opencode session list --format=json 2>/dev/null)
+    local after_ids=$(echo "$after_json" | python3 -c "import sys,json; sessions=json.load(sys.stdin); print(' '.join(s['id'] for s in sessions))" 2>/dev/null || echo "")
+    
+    local new_session_id=""
+    for sess in $after_ids; do
+        if [[ ! " $before_ids " =~ " $sess " ]] && [[ "$sess" != "$base_session" ]]; then
+            new_session_id="$sess"
+            break
+        fi
+    done
+    
+    echo "$new_session_id"
+}
+
+build_dev_agent_message() {
+    local issue_ref="$1"
+    local user_message="${2:-}"
+    
+    local instance=$(echo "$issue_ref" | cut -d'/' -f1 | cut -d'#' -f1)
+    local owner=$(echo "$issue_ref" | cut -d'/' -f2)
+    local repo=$(echo "$issue_ref" | cut -d'/' -f3 | cut -d'#' -f1)
+    local number=$(echo "$issue_ref" | grep -oE '#[0-9]+$' | tr -d '#')
+    local worktree_path=$(issue_ref_to_worktree_path "$issue_ref")
+    
+    local base_message="You are assigned to work on $issue_ref.
+
+Workflow:
+1. Read the issue at $instance/$owner/$repo/issues/$number AND all comments on that issue
+2. Check if a PR already exists for this issue
+   - If PR exists and is open, review it and learn from it
+   - If PR makes sense to continue, work on it instead
+   - If PR is not worth continuing, create a new branch/PR but explain in PR description why you're creating a new one instead of continuing the existing PR
+3. Read README.md (if exists) to understand the general concept of this repository
+4. Read CONTRIBUTING.md (if exists) to understand how to contribute
+   - If CONTRIBUTING.md doesn't exist, follow steps 5-9 as your guideline
+5. Explore the repository to understand the codebase
+6. If anything is unclear, post a comment on the issue asking for clarification before implementing
+7. Implement the solution
+8. Create a branch named fix/issue-$number and implement the fix
+9. Create a PR when the implementation is complete
+
+Work directory: $worktree_path"
+    
+    if [ -n "$user_message" ]; then
+        echo "$base_message
+
+Additional instructions from delegator:
+$user_message"
+    else
+        echo "$base_message"
+    fi
 }
 
 cmd_start() {
@@ -197,15 +316,36 @@ cmd_start() {
         exit 1
     fi
     
-    local pm_agent_session_id=$(get_pm_agent_session_id)
+    local session_file=$(issue_ref_to_filename "$issue_ref")
-    if [ -z "$pm_agent_session_id" ] || [ "$pm_agent_session_id" = "null" ]; then
+    local session_path="$SESSIONS_DIR/$session_file"
-        echo "Error: PM agent session not found. Run 'kugetsu init' first." >&2
+    local worktree_exists=false
+    
+    if worktree_exists "$issue_ref"; then
+        worktree_exists=true
+    fi
+    
+    local session_exists=false
+    if [ -f "$session_path" ]; then
+        session_exists=true
+    fi
+    
+    if $worktree_exists && $session_exists; then
+        echo "Issue '$issue_ref' already has a worktree and session." >&2
+        echo "Use 'kugetsu continue $issue_ref' to continue work." >&2
         exit 1
     fi
     
-    if worktree_exists "$issue_ref"; then
+    if $worktree_exists && ! $session_exists; then
-        echo "Issue '$issue_ref' already has a worktree. Use 'kugetsu continue' instead."
+        echo "Warning: Worktree exists but session is missing. Removing worktree to recreate both..." >&2
-        exit 1
+        remove_worktree_for_issue "$issue_ref"
+        worktree_exists=false
+    fi
+    
+    if ! $worktree_exists && $session_exists; then
+        echo "Warning: Session exists but worktree is missing. Removing stale session to recreate both..." >&2
+        rm -f "$session_path"
+        remove_issue_from_index "$issue_ref"
+        session_exists=false
     fi
     
     local active_count=$(count_active_dev_sessions)
@@ -214,31 +354,12 @@ cmd_start() {
         exit 1
     fi
     
-    local session_file=$(issue_ref_to_filename "$issue_ref")
+    create_worktree "$issue_ref" "$WORKTREES_DIR"
-    local session_path="$SESSIONS_DIR/$session_file"
     
-    if [ -f "$session_path" ]; then
+    local new_session_id=$(create_session "$base_session_id")
-        echo "Session file already exists: $session_file"
-        echo "Use 'kugetsu continue $issue_ref' to continue work."
-        exit 1
-    fi
-    
-    local before_sessions=$(opencode session list 2>/dev/null | grep -oP '^ses_\w+' | sort)
-    local before_set="|$before_sessions|"
-    
-    create_worktree "$issue_ref"
-    
-    local after_sessions=$(opencode session list 2>/dev/null | grep -oP '^ses_\w+' | sort)
-    local new_session_id=""
-    while IFS= read -r sess; do
-        if [[ ! "$before_set" =~ \|${sess}\| ]] && [[ "$sess" != "$base_session_id" ]] && [[ "$sess" != "$pm_agent_session_id" ]]; then
-            new_session_id="$sess"
-            break
-        fi
-    done <<< "$after_sessions"
     
     if [ -z "$new_session_id" ]; then
-        echo "Error: Could not find newly created session" >&2
+        echo "Error: Could not create session" >&2
         remove_worktree_for_issue "$issue_ref"
         exit 1
     fi
@@ -250,6 +371,16 @@ cmd_start() {
     
     add_issue_to_index "$issue_ref" "$session_file"
     
+    local dev_message=$(build_dev_agent_message "$issue_ref" "$message")
+    
+    load_agent_env "dev"
+    
+    cd "$worktree_path"
+    local msg_file="$LOGS_DIR/msg-$new_session_id.txt"
+    printf '%s' "$dev_message" > "$msg_file"
+    nohup sh -c "GITEA_TOKEN='${GITEA_TOKEN:-}' opencode run '@$msg_file' --session '$new_session_id'" >> "$LOGS_DIR/dev-$new_session_id.log" 2>&1 &
+    rm -f "$msg_file"
+    
     echo "Session started for '$issue_ref': $new_session_id"
     echo "Worktree: $worktree_path"
 }
@@ -295,20 +426,26 @@ cmd_continue() {
     
     local opencode_session_id=$(python3 -c "import json; print(json.load(open('$session_path')).get('opencode_session_id', ''))" 2>/dev/null || echo "")
     local worktree_path=$(python3 -c "import json; print(json.load(open('$session_path')).get('worktree_path', ''))" 2>/dev/null || echo "")
+    local issue_ref=$(python3 -c "import json; print(json.load(open('$session_path')).get('issue_ref', ''))" 2>/dev/null || echo "")
     
-    if [ -n "$worktree_path" ] && [ -d "$worktree_path" ]; then
+    if [ -z "$worktree_path" ] || [ ! -d "$worktree_path" ]; then
-        if [ -n "$message" ]; then
+        echo "Warning: Worktree is missing for '$session_name'. Recovering..." >&2
-            (cd "$worktree_path" && opencode run "$message" --continue --session "$opencode_session_id" "$@")
+        rm -f "$session_path"
-        else
+        remove_issue_from_index "$session_name"
-            (cd "$worktree_path" && opencode --continue --session "$opencode_session_id" "$@")
+        echo "Calling cmd_start to create new session and worktree..." >&2
-        fi
+        cmd_start "$session_name" "$message"
-    else
+        return $?
-        if [ -n "$message" ]; then
-            opencode run "$message" --continue --session "$opencode_session_id" "$@"
-        else
-            opencode --continue --session "$opencode_session_id" "$@"
-        fi
     fi
+    
+    if [ -z "$message" ]; then
+        message=$(build_dev_agent_message "$issue_ref" "")
+    fi
+    
+    cd "$worktree_path"
+    local msg_file="$LOGS_DIR/msg-$opencode_session_id.txt"
+    printf '%s' "$message" > "$msg_file"
+    nohup sh -c "GITEA_TOKEN='${GITEA_TOKEN:-}' opencode run '@$msg_file' --session '$opencode_session_id'" >> "$LOGS_DIR/dev-$opencode_session_id.log" 2>&1 &
+    rm -f "$msg_file"
 }
 
 cmd_list() {
@@ -459,11 +596,7 @@ cmd_destroy() {
     local target="${1:-}"
     local force=false
     
-    if [ "$target" = "--base" ]; then
+    if [ "${2:-}" = "-y" ]; then
-        target=""
-    fi
-    
-    if [ "$2" = "-y" ]; then
         force=true
     fi
     

skills/kugetsu/scripts/kugetsu-worktree.sh

@@ -10,7 +10,7 @@ issue_ref_to_worktree_path() {
     local issue_ref="$1"
     local parent_dir="${2:-$WORKTREES_DIR}"
     local worktree_name=$(issue_ref_to_worktree_name "$issue_ref")
-    echo "$parent_dir/.kugetsu-worktrees/$worktree_name"
+    echo "$parent_dir/$worktree_name"
 }
 
 issue_ref_to_branch_name() {
@@ -41,7 +41,7 @@ get_repo_url() {
     fi
     
     local instance=$(echo "$issue_ref" | cut -d'/' -f1 | cut -d'#' -f1)
-    local rest=$(echo "$issue_ref" | sed 's/.*\///' | sed 's/#.*//')
+    local rest=$(echo "$issue_ref" | sed 's/^[^\/]*\///' | sed 's/#.*//')
     
     if [ -n "${GIT_SERVERS[$instance]:-}" ]; then
         echo "${GIT_SERVERS[$instance]}/${rest}.git"

skills/kugetsu/tests/test-create-session.sh

@@ -0,0 +1,181 @@
+#!/bin/bash
+# Tests for create_session function
+#
+# Run with: bash skills/kugetsu/tests/test-create-session.sh
+#
+# NOTE: These tests MUST be run sequentially (not in parallel)
+# to avoid exhausting memory with too many opencode sessions.
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/../scripts/kugetsu-config.sh"
+source "$SCRIPT_DIR/../scripts/kugetsu-index.sh"
+source "$SCRIPT_DIR/../scripts/kugetsu-session.sh"
+
+PASS=0
+FAIL=0
+RUN=0
+
+pass() {
+    echo "PASS: $1"
+    PASS=$((PASS + 1))
+}
+
+fail() {
+    echo "FAIL: $1"
+    echo "  Expected: $2"
+    echo "  Got: $3"
+    FAIL=$((FAIL + 1))
+}
+
+run_test() {
+    local name="$1"
+    local test_func="$2"
+    RUN=$((RUN + 1))
+    echo ""
+    echo "=== Test $RUN: $name ==="
+    echo "--- $name ---"
+    $test_func
+}
+
+echo "=== create_session Test Suite ==="
+echo "NOTE: Running sequentially to avoid memory exhaustion"
+echo ""
+
+# Test 1: create_session requires base session
+test_create_session_requires_base() {
+    local base_id=$(get_base_session_id)
+    if [ -z "$base_id" ] || [ "$base_id" = "null" ]; then
+        skip "Base session not initialized - run 'kugetsu init' first"
+        return
+    fi
+    
+    local result=$(create_session "$base_id")
+    if [ -n "$result" ] && [[ "$result" =~ ^ses_ ]]; then
+        pass "create_session returns valid session ID"
+    else
+        fail "create_session returns valid session ID" "ses_xxx" "$result"
+    fi
+}
+
+# Test 2: create_session creates a NEW session (different from base)
+test_create_session_is_new() {
+    local base_id=$(get_base_session_id)
+    if [ -z "$base_id" ] || [ "$base_id" = "null" ]; then
+        skip "Base session not initialized - run 'kugetsu init' first"
+        return
+    fi
+    
+    local new_id=$(create_session "$base_id")
+    if [ "$new_id" != "$base_id" ]; then
+        pass "create_session returns NEW session (not same as base)"
+    else
+        fail "create_session returns NEW session" "different from base_id" "$new_id"
+    fi
+}
+
+# Test 3: create_session can be called multiple times (creates different sessions)
+test_create_session_multiple_calls() {
+    local base_id=$(get_base_session_id)
+    if [ -z "$base_id" ] || [ "$base_id" = "null" ]; then
+        skip "Base session not initialized - run 'kugetsu init' first"
+        return
+    fi
+    
+    local id1=$(create_session "$base_id")
+    sleep 1
+    local id2=$(create_session "$base_id")
+    
+    if [ "$id1" != "$id2" ]; then
+        pass "create_session creates different sessions on each call"
+    else
+        fail "create_session creates different sessions" "$id1 != $id2" "both equal: $id1"
+    fi
+}
+
+# Test 4: JSON session list parsing
+test_session_json_parsing() {
+    local json='[{"id": "ses_abc123", "title": "test"}, {"id": "ses_def456", "title": "test2"}]'
+    local ids=$(echo "$json" | python3 -c "import sys,json; sessions=json.load(sys.stdin); print(' '.join(s['id'] for s in sessions))" 2>/dev/null)
+    
+    if [ "$ids" = "ses_abc123 ses_def456" ]; then
+        pass "JSON session list parsing extracts IDs correctly"
+    else
+        fail "JSON session list parsing" "ses_abc123 ses_def456" "$ids"
+    fi
+}
+
+# Test 5: Session ID format validation
+test_session_id_format() {
+    local json='[{"id": "ses_2b4814406ffe3AxcpbrP7FknDr", "title": "test"}]'
+    local ids=$(echo "$json" | python3 -c "import sys,json; sessions=json.load(sys.stdin); print(' '.join(s['id'] for s in sessions))" 2>/dev/null)
+    
+    if [[ "$ids" =~ ^ses_ ]]; then
+        pass "Session ID format is valid (starts with ses_)"
+    else
+        fail "Session ID format" "ses_xxx" "$ids"
+    fi
+}
+
+# Test 6: create_session accepts optional base session parameter
+test_create_session_with_param() {
+    local base_id=$(get_base_session_id)
+    if [ -z "$base_id" ] || [ "$base_id" = "null" ]; then
+        skip "Base session not initialized - run 'kugetsu init' first"
+        return
+    fi
+    
+    local result=$(create_session "$base_id")
+    if [ -n "$result" ] && [[ "$result" =~ ^ses_ ]]; then
+        pass "create_session accepts base session parameter"
+    else
+        fail "create_session accepts base session parameter" "ses_xxx" "$result"
+    fi
+}
+
+# Test 7: Verify session appears in opencode session list after creation
+test_session_visible_in_list() {
+    local base_id=$(get_base_session_id)
+    if [ -z "$base_id" ] || [ "$base_id" = "null" ]; then
+        skip "Base session not initialized - run 'kugetsu init' first"
+        return
+    fi
+    
+    local new_id=$(create_session "$base_id")
+    sleep 1
+    
+    local all_sessions=$(opencode session list --format=json 2>/dev/null)
+    if echo "$all_sessions" | grep -q "$new_id"; then
+        pass "Created session appears in opencode session list"
+    else
+        fail "Created session appears in session list" "should contain $new_id" "$all_sessions"
+    fi
+}
+
+skip() {
+    echo "SKIP: $1"
+}
+
+# Run tests sequentially
+run_test "create_session requires base session" test_create_session_requires_base
+run_test "create_session creates NEW session" test_create_session_is_new
+run_test "create_session creates different sessions on multiple calls" test_create_session_multiple_calls
+run_test "JSON session list parsing" test_session_json_parsing
+run_test "Session ID format validation" test_session_id_format
+run_test "create_session accepts optional base session parameter" test_create_session_with_param
+run_test "Created session visible in opencode session list" test_session_visible_in_list
+
+echo ""
+echo "=== Test Results ==="
+echo "Passed: $PASS"
+echo "Failed: $FAIL"
+echo "Total: $RUN"
+
+if [ $FAIL -eq 0 ]; then
+    echo "All tests passed!"
+    exit 0
+else
+    echo "Some tests failed!"
+    exit 1
+fi

skills/kugetsu/tests/test-git-url-parsing.sh

@@ -0,0 +1,298 @@
+#!/bin/bash
+# Git URL Parsing Tests for kugetsu
+# Tests all functions that parse or construct git URLs and issue refs
+#
+# Run with: bash skills/kugetsu/tests/test-git-url-parsing.sh
+
+set -euo pipefail
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/../scripts/kugetsu-config.sh"
+source "$SCRIPT_DIR/../scripts/kugetsu-worktree.sh"
+source "$SCRIPT_DIR/../scripts/kugetsu-session.sh"
+
+PASS=0
+FAIL=0
+
+pass() {
+    echo "PASS: $1"
+    PASS=$((PASS + 1))
+}
+
+fail() {
+    echo "FAIL: $1"
+    echo "  Expected: $2"
+    echo "  Got: $3"
+    FAIL=$((FAIL + 1))
+}
+
+echo "=== Git URL Parsing Test Suite ==="
+echo ""
+
+# Test: get_repo_url with standard GitHub issue ref
+echo "--- Test: get_repo_url with github.com ---"
+result=$(get_repo_url "github.com/shoko/kugetsu#14")
+expected="https://github.com/shoko/kugetsu.git"
+if [ "$result" = "$expected" ]; then
+    pass "get_repo_url standard github issue ref"
+else
+    fail "get_repo_url standard github issue ref" "$expected" "$result"
+fi
+
+# Test: get_repo_url with custom instance
+echo "--- Test: get_repo_url with git.fbrns.co ---"
+result=$(get_repo_url "git.fbrns.co/shoko/kugetsu#158")
+expected="https://git.fbrns.co/shoko/kugetsu.git"
+if [ "$result" = "$expected" ]; then
+    pass "get_repo_url custom instance issue ref (ISSUE #181)"
+else
+    fail "get_repo_url custom instance issue ref (ISSUE #181)" "$expected" "$result"
+fi
+
+# Test: get_repo_url with gitlab.com (if configured)
+echo "--- Test: get_repo_url with gitlab.com ---"
+if [ -n "${GIT_SERVERS[gitlab.com]:-}" ]; then
+    result=$(get_repo_url "gitlab.com/someuser/somerepo#42")
+    expected="https://gitlab.com/someuser/somerepo.git"
+    if [ "$result" = "$expected" ]; then
+        pass "get_repo_url gitlab.com issue ref"
+    else
+        fail "get_repo_url gitlab.com issue ref" "$expected" "$result"
+    fi
+else
+    echo "SKIP: get_repo_url gitlab.com (not configured in GIT_SERVERS)"
+fi
+
+# Test: get_repo_url with bitbucket.org (if configured)
+echo "--- Test: get_repo_url with bitbucket.org ---"
+if [ -n "${GIT_SERVERS[bitbucket.org]:-}" ]; then
+    result=$(get_repo_url "bitbucket.org/myteam/myproject#7")
+    expected="https://bitbucket.org/myteam/myproject.git"
+    if [ "$result" = "$expected" ]; then
+        pass "get_repo_url bitbucket.org issue ref"
+    else
+        fail "get_repo_url bitbucket.org issue ref" "$expected" "$result"
+    fi
+else
+    echo "SKIP: get_repo_url bitbucket.org (not configured in GIT_SERVERS)"
+fi
+
+# Test: get_repo_url with large issue number
+echo "--- Test: get_repo_url with large issue number ---"
+result=$(get_repo_url "github.com/shoko/kugetsu#999999")
+expected="https://github.com/shoko/kugetsu.git"
+if [ "$result" = "$expected" ]; then
+    pass "get_repo_url with large issue number"
+else
+    fail "get_repo_url with large issue number" "$expected" "$result"
+fi
+
+# Test: issue_ref_to_worktree_name standard
+echo "--- Test: issue_ref_to_worktree_name standard ---"
+result=$(issue_ref_to_worktree_name "github.com/shoko/kugetsu#14")
+expected="github.com-shoko-kugetsu-14"
+if [ "$result" = "$expected" ]; then
+    pass "issue_ref_to_worktree_name standard"
+else
+    fail "issue_ref_to_worktree_name standard" "$expected" "$result"
+fi
+
+# Test: issue_ref_to_worktree_name with custom instance
+echo "--- Test: issue_ref_to_worktree_name custom instance ---"
+result=$(issue_ref_to_worktree_name "git.fbrns.co/shoko/kugetsu#158")
+expected="git.fbrns.co-shoko-kugetsu-158"
+if [ "$result" = "$expected" ]; then
+    pass "issue_ref_to_worktree_name custom instance"
+else
+    fail "issue_ref_to_worktree_name custom instance" "$expected" "$result"
+fi
+
+# Test: issue_ref_to_branch_name with number
+echo "--- Test: issue_ref_to_branch_name with number ---"
+result=$(issue_ref_to_branch_name "github.com/shoko/kugetsu#14")
+expected="fix/issue-14"
+if [ "$result" = "$expected" ]; then
+    pass "issue_ref_to_branch_name with number"
+else
+    fail "issue_ref_to_branch_name with number" "$expected" "$result"
+fi
+
+# Test: issue_ref_to_branch_name with discuss suffix
+# Note: #-discuss falls through to fix/issue-temp because #[^-]+$ doesn't match #-<text-with-hyphens>
+echo "--- Test: issue_ref_to_branch_name with discuss suffix ---"
+result=$(issue_ref_to_branch_name "github.com/shoko/kugetsu#-discuss")
+expected="fix/issue-temp"
+if [ "$result" = "$expected" ]; then
+    pass "issue_ref_to_branch_name with discuss suffix"
+else
+    fail "issue_ref_to_branch_name with discuss suffix" "$expected" "$result"
+fi
+
+# Test: issue_ref_to_branch_name with identifier that has no hyphens
+echo "--- Test: issue_ref_to_branch_name with pure identifier ---"
+result=$(issue_ref_to_branch_name "github.com/shoko/kugetsu#someid")
+expected="fix/someid"
+if [ "$result" = "$expected" ]; then
+    pass "issue_ref_to_branch_name with pure identifier"
+else
+    fail "issue_ref_to_branch_name with pure identifier" "$expected" "$result"
+fi
+
+# Test: issue_ref_to_branch_name without number
+echo "--- Test: issue_ref_to_branch_name without number ---"
+result=$(issue_ref_to_branch_name "github.com/shoko/kugetsu#abc")
+expected="fix/abc"
+if [ "$result" = "$expected" ]; then
+    pass "issue_ref_to_branch_name without number"
+else
+    fail "issue_ref_to_branch_name without number" "$expected" "$result"
+fi
+
+# Test: extract_issue_ref_from_message with short form
+echo "--- Test: extract_issue_ref_from_message short form ---"
+result=$(extract_issue_ref_from_message "github.com/shoko/kugetsu#14")
+expected="github.com/shoko/kugetsu#14"
+if [ "$result" = "$expected" ]; then
+    pass "extract_issue_ref_from_message short form"
+else
+    fail "extract_issue_ref_from_message short form" "$expected" "$result"
+fi
+
+# Test: extract_issue_ref_from_message with https URL
+echo "--- Test: extract_issue_ref_from_message with https URL ---"
+result=$(extract_issue_ref_from_message "https://github.com/shoko/kugetsu/issues/14")
+expected="github.com/shoko/kugetsu#14"
+if [ "$result" = "$expected" ]; then
+    pass "extract_issue_ref_from_message with https URL"
+else
+    fail "extract_issue_ref_from_message with https URL" "$expected" "$result"
+fi
+
+# Test: extract_issue_ref_from_message with custom instance
+echo "--- Test: extract_issue_ref_from_message custom instance ---"
+result=$(extract_issue_ref_from_message "https://git.fbrns.co/shoko/kugetsu/issues/158")
+expected="git.fbrns.co/shoko/kugetsu#158"
+if [ "$result" = "$expected" ]; then
+    pass "extract_issue_ref_from_message custom instance"
+else
+    fail "extract_issue_ref_from_message custom instance" "$expected" "$result"
+fi
+
+# Test: extract_issue_ref_from_message with empty message
+echo "--- Test: extract_issue_ref_from_message empty message ---"
+result=$(extract_issue_ref_from_message "")
+expected=""
+if [ "$result" = "$expected" ]; then
+    pass "extract_issue_ref_from_message empty message"
+else
+    fail "extract_issue_ref_from_message empty message" "$expected" "$result"
+fi
+
+# Test: extract_issue_ref_from_message with no issue ref
+echo "--- Test: extract_issue_ref_from_message no issue ref ---"
+result=$(extract_issue_ref_from_message "Just a regular message without any issue reference")
+expected=""
+if [ "$result" = "$expected" ]; then
+    pass "extract_issue_ref_from_message no issue ref"
+else
+    fail "extract_issue_ref_from_message no issue ref" "$expected" "$result"
+fi
+
+# Test: extract_issue_ref_from_message with gitlab URL
+echo "--- Test: extract_issue_ref_from_message gitlab URL ---"
+result=$(extract_issue_ref_from_message "https://gitlab.com/someuser/somerepo/issues/42")
+expected="gitlab.com/someuser/somerepo#42"
+if [ "$result" = "$expected" ]; then
+    pass "extract_issue_ref_from_message gitlab URL"
+else
+    fail "extract_issue_ref_from_message gitlab URL" "$expected" "$result"
+fi
+
+# Test: validate_issue_ref valid format
+echo "--- Test: validate_issue_ref valid format ---"
+if validate_issue_ref "github.com/shoko/kugetsu#14" 2>/dev/null; then
+    pass "validate_issue_ref valid format"
+else
+    fail "validate_issue_ref valid format" "exit 0" "exit non-zero"
+fi
+
+# Test: validate_issue_ref invalid format (missing parts)
+echo "--- Test: validate_issue_ref invalid format ---"
+if ! validate_issue_ref "invalid-ref" 2>/dev/null; then
+    pass "validate_issue_ref invalid format"
+else
+    fail "validate_issue_ref invalid format" "exit non-zero" "exit 0"
+fi
+
+# Test: issue_ref_to_filename
+echo "--- Test: issue_ref_to_filename ---"
+result=$(issue_ref_to_filename "github.com/shoko/kugetsu#14")
+expected="github.com-shoko-kugetsu-14.json"
+if [ "$result" = "$expected" ]; then
+    pass "issue_ref_to_filename"
+else
+    fail "issue_ref_to_filename" "$expected" "$result"
+fi
+
+# Test: filename_to_issue_ref
+echo "--- Test: filename_to_issue_ref ---"
+result=$(filename_to_issue_ref "github.com-shoko-kugetsu-14.json")
+expected="github.com/shoko/kugetsu#14"
+if [ "$result" = "$expected" ]; then
+    pass "filename_to_issue_ref"
+else
+    fail "filename_to_issue_ref" "$expected" "$result"
+fi
+
+# Test: get_repo_url with org having hyphen
+echo "--- Test: get_repo_url with hyphenated org ---"
+result=$(get_repo_url "github.com/my-org/my-repo#1")
+expected="https://github.com/my-org/my-repo.git"
+if [ "$result" = "$expected" ]; then
+    pass "get_repo_url with hyphenated org"
+else
+    fail "get_repo_url with hyphenated org" "$expected" "$result"
+fi
+
+# Test: get_repo_url with repo having dots
+echo "--- Test: get_repo_url with dotted repo ---"
+result=$(get_repo_url "github.com/shoko/kugetsu.utils#5")
+expected="https://github.com/shoko/kugetsu.utils.git"
+if [ "$result" = "$expected" ]; then
+    pass "get_repo_url with dotted repo"
+else
+    fail "get_repo_url with dotted repo" "$expected" "$result"
+fi
+
+# Test: get_repo_url with underscore in username
+echo "--- Test: get_repo_url with underscore in user ---"
+result=$(get_repo_url "github.com/my_user/my_repo#10")
+expected="https://github.com/my_user/my_repo.git"
+if [ "$result" = "$expected" ]; then
+    pass "get_repo_url with underscore in user"
+else
+    fail "get_repo_url with underscore in user" "$expected" "$result"
+fi
+
+# Test: get_repo_url with instance not in GIT_SERVERS (fallback)
+echo "--- Test: get_repo_url with unknown instance ---"
+result=$(get_repo_url "unknown.example.com/owner/repo#1")
+expected="https://unknown.example.com/owner/repo.git"
+if [ "$result" = "$expected" ]; then
+    pass "get_repo_url with unknown instance"
+else
+    fail "get_repo_url with unknown instance" "$expected" "$result"
+fi
+
+echo ""
+echo "=== Test Results ==="
+echo "Passed: $PASS"
+echo "Failed: $FAIL"
+
+if [ $FAIL -eq 0 ]; then
+    echo "All tests passed!"
+    exit 0
+else
+    echo "Some tests failed!"
+    exit 1
+fi