fix: always use base workflow and add user message to it

Previously when a user message was provided, cmd_continue would only
use the user message without the base agent workflow. Now both cases
build the full workflow and append the user message.

Changes:
- cmd_continue now always calls build_dev_agent_message even when
  message is provided
- User message is appended at the end with 'Delegator's message:'
- Both with/without message cases now use the same workflow structure

Fixes #229

.pre-commit-config.yaml

@@ -0,0 +1,18 @@
+repos:
+  - repo: https://github.com/shellcheck-py/shellcheck-py
+    rev: v0.9.0.6
+    hooks:
+      - id: shellcheck
+
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.1.8
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format
+
+  - repo: https://github.com/commitizen-tools/commitizen
+    rev: v3.2.0
+    hooks:
+      - id: commitizen
+        stages: [commit-msg]

CONTRIBUTING.md

@@ -16,6 +16,38 @@
 - Test changes before submitting
 - See [VERSIONING.md](VERSIONING.md) for backport compatibility rules
 
+## Pre-commit Hooks
+
+This repository uses [pre-commit](https://pre-commit.com/) for linting and commit message enforcement.
+
+### Setup
+
+```bash
+pip install pre-commit
+pre-commit install
+```
+
+### Hooks
+
+- **shellcheck** — Lints bash scripts
+- **ruff** — Lints and formats Python
+- **commitizen** — Enforces [Conventional Commits](https://www.conventionalcommits.org/) format
+
+### Commit Message Format
+
+Use Conventional Commits format:
+
+```
+type(scope): message
+
+# Examples
+fix(session): handle missing session gracefully
+feat(pm): add queue daemon for task delegation
+docs: update contributing guide
+```
+
+Types: `fix`, `feat`, `docs`, `refactor`, `chore`, `test`
+
 ## Branches
 
 ### Primary Branches

skills/kugetsu/scripts/kugetsu-log.sh

@@ -1,6 +1,40 @@
 #!/bin/bash
 set -euo pipefail
 
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+source "$SCRIPT_DIR/kugetsu-config.sh"
+
+log() {
+    local level="${1:-}"
+    local component="${2:-}"
+    local message="${3:-}"
+    local timestamp
+    timestamp=$(date -Iseconds)
+
+    case "$level" in
+        info|warn|error|debug) ;;
+        *)
+            echo "Error: log level must be info|warn|error|debug" >&2
+            return 1
+            ;;
+    esac
+
+    if [ -z "$message" ]; then
+        message="$component"
+        component="${level}"
+        level="info"
+    fi
+
+    local masked
+    masked=$(mask_sensitive_vars "$message")
+    echo "[$timestamp] $level $component $masked"
+}
+
+log_debug() { log "debug" "$1" "${2:-}"; }
+log_info()  { log "info"  "$1" "${2:-}"; }
+log_warn()  { log "warn"  "$1" "${2:-}"; }
+log_error() { log "error" "$1" "${2:-}"; }
+
 cmd_logs() {
     local count="${1:-10}"
     

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

@@ -109,28 +109,15 @@ process_task() {
 
     source "$SCRIPT_DIR/kugetsu-session.sh"
 
-    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"
-        log_file="$LOGS_DIR/delegate-$(date +%s).log"
+    if cmd_continue "$issue_ref" "$message" >> "$log_file" 2>&1; then
-        if cmd_continue "$issue_ref" "$message" >> "$log_file" 2>&1; then
+        sleep 1
-            sleep 1
+        local session_id=$(get_session_id_for_issue "$issue_ref")
-            local session_id=$(get_session_id_for_issue "$issue_ref")
+        update_queue_item_state "$queue_id" "notified" "$session_id" ""
-            update_queue_item_state "$queue_id" "notified" "$session_id" ""
+        echo "Task $queue_id continued for $issue_ref"
-            echo "Task $queue_id continued for $issue_ref"
-        else
-            update_queue_item_state "$queue_id" "error"
-            echo "Task $queue_id ($issue_ref) failed to continue"
-        fi
     else
-        log_file="$LOGS_DIR/delegate-$(date +%s).log"
+        update_queue_item_state "$queue_id" "error"
-        if cmd_start "$issue_ref" "$message" >> "$log_file" 2>&1; then
+        echo "Task $queue_id ($issue_ref) failed to continue"
-            sleep 1
-            local session_id=$(get_session_id_for_issue "$issue_ref")
-            update_queue_item_state "$queue_id" "notified" "$session_id" ""
-            echo "Task $queue_id started for $issue_ref"
-        else
-            update_queue_item_state "$queue_id" "error"
-            echo "Task $queue_id ($issue_ref) failed to start"
-        fi
     fi
 
     release_lock "$issue_ref"

skills/kugetsu/scripts/kugetsu-session.sh

@@ -270,7 +270,11 @@ build_dev_agent_message() {
     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.
+    if [ -n "$user_message" ]; then
+        cat <<EOF
+You are assigned to work on $issue_ref.
+
+IMPORTANT: Follow the workflow below as your guideline, but prioritize the delegator's message.
 
 Workflow:
 1. Read the issue at $instance/$owner/$repo/issues/$number AND all comments on that issue
@@ -285,60 +289,99 @@ Workflow:
 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
+9. Create a PR when the implementation is complete using: tea pr create --repo $owner/$repo --title "Your PR title" --body "PR description"
+   - Make sure you are logged in with: tea login add --name gitea --token \$GITEA_TOKEN --url https://$instance
+   - If tea is not available, use: curl -X POST "https://$instance/api/v1/repos/$owner/$repo/pulls" -H "Authorization: Bearer \$GITEA_TOKEN" -H "Content-Type: application/json" -d '{"title":"PR Title","head":"branch-name","base":"main","body":"PR description"}'
 
-### Creating PRs
+Tools for PR interaction:
-When creating a PR, use the Gitea API directly with curl:
+- Post issue/PR comment: curl -X POST "https://$instance/api/v1/repos/$owner/$repo/issues/$number/comments" -H "Authorization: Bearer \$GITEA_TOKEN" -H "Content-Type: application/json" -d '{"body":"Your comment"}'
+- List PR comments: curl -s "https://$instance/api/v1/repos/$owner/$repo/issues/$number/comments" -H "Authorization: Bearer \$GITEA_TOKEN"
+- List PR reviews: curl -s "https://$instance/api/v1/repos/$owner/$repo/pulls/$number/reviews" -H "Authorization: Bearer \$GITEA_TOKEN"
+- Merge PR (only with approval): tea pr merge --repo $owner/$repo $number --style merge
+  - MERGING requires approval first! Check for: approval in reviews, OR "lgtm"/"approved" in comments
+  - If no approval, ask reviewer to approve first before merging
 
-```bash
+Delegator's message:
-curl -X POST "https://$instance/api/v1/repos/$owner/$repo/pulls" \
+$user_message
-  -H "Authorization: Bearer \$GITEA_TOKEN" \
-  -H "Content-Type: application/json" \
-  -d '{
-    "title": "Fix issue #$number",
-    "head": "fix/issue-$number",
-    "base": "main",
-    "body": "Closes #$number"
-  }'
-```
 
-Environment variable \$GITEA_TOKEN is available in your environment.
+Work directory: $worktree_path
-
+EOF
-Work directory: $worktree_path"
-    
-    if [ -n "$user_message" ]; then
-        echo "$base_message
-
-Additional instructions from delegator:
-$user_message"
     else
-        echo "$base_message"
+        cat <<EOF
+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 using: tea pr create --repo $owner/$repo --title "Your PR title" --body "PR description"
+   - Make sure you are logged in with: tea login add --name gitea --token \$GITEA_TOKEN --url https://$instance
+   - If tea is not available, use: curl -X POST "https://$instance/api/v1/repos/$owner/$repo/pulls" -H "Authorization: Bearer \$GITEA_TOKEN" -H "Content-Type: application/json" -d '{"title":"PR Title","head":"branch-name","base":"main","body":"PR description"}'
+
+Tools for PR interaction:
+- Post issue/PR comment: curl -X POST "https://$instance/api/v1/repos/$owner/$repo/issues/$number/comments" -H "Authorization: Bearer \$GITEA_TOKEN" -H "Content-Type: application/json" -d '{"body":"Your comment"}'
+- List PR comments: curl -s "https://$instance/api/v1/repos/$owner/$repo/issues/$number/comments" -H "Authorization: Bearer \$GITEA_TOKEN"
+- List PR reviews: curl -s "https://$instance/api/v1/repos/$owner/$repo/pulls/$number/reviews" -H "Authorization: Bearer \$GITEA_TOKEN"
+- Merge PR (only with approval): tea pr merge --repo $owner/$repo $number --style merge
+  - MERGING requires approval first! Check for: approval in reviews, OR "lgtm"/"approved" in comments
+  - If no approval, ask reviewer to approve first before merging
+
+Work directory: $worktree_path
+EOF
     fi
 }
 
-cmd_start() {
+ensure_worktree() {
-    local issue_ref="${1:-}"
+    local issue_ref="$1"
-    local message="${2:-}"
     
-    if [ -z "$issue_ref" ]; then
+    if worktree_exists "$issue_ref" "$WORKTREES_DIR"; then
-        echo "Error: issue ref is required" >&2
+        log "info" "ensure_worktree" "Worktree already exists for $issue_ref"
-        echo "Usage: kugetsu start <issue-ref> [message]" >&2
+        echo "existed"
-        exit 1
+        return 0
     fi
     
-    validate_issue_ref "$issue_ref"
-    
     local base_session_id=$(get_base_session_id)
     if [ -z "$base_session_id" ] || [ "$base_session_id" = "null" ]; then
-        echo "Error: Base session not found. Run 'kugetsu init' first." >&2
+        log "error" "ensure_worktree" "Base session not found for $issue_ref"
-        exit 1
+        echo "error"
+        return 1
     fi
     
+    local active_count=$(count_active_dev_sessions)
+    if [ "$active_count" -ge "${MAX_CONCURRENT_AGENTS:-3}" ]; then
+        log "error" "ensure_worktree" "Max concurrent agents reached for $issue_ref"
+        echo "error"
+        return 1
+    fi
+    
+    if create_worktree "$issue_ref" "$WORKTREES_DIR" 2>&1 | tee >(cat >&2); then
+        log "info" "ensure_worktree" "Created worktree for $issue_ref"
+        echo "created"
+        return 0
+    else
+        log "error" "ensure_worktree" "Failed to create worktree for $issue_ref"
+        echo "error"
+        return 1
+    fi
+}
+
+ensure_session() {
+    local issue_ref="$1"
+    
     local session_file=$(issue_ref_to_filename "$issue_ref")
     local session_path="$SESSIONS_DIR/$session_file"
-    local worktree_exists=false
     
-    if worktree_exists "$issue_ref"; then
+    local worktree_exists=false
+    if worktree_exists "$issue_ref" "$WORKTREES_DIR"; then
         worktree_exists=true
     fi
     
@@ -348,38 +391,40 @@ cmd_start() {
     fi
     
     if $worktree_exists && $session_exists; then
-        echo "Issue '$issue_ref' already has a worktree and session." >&2
+        log "info" "ensure_session" "Session already exists for $issue_ref"
-        echo "Use 'kugetsu continue $issue_ref' to continue work." >&2
+        echo "continued"
-        exit 1
+        return 0
-    fi
-    
-    if $worktree_exists && ! $session_exists; then
-        echo "Warning: Worktree exists but session is missing. Removing worktree to recreate both..." >&2
-        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
+        log "warn" "ensure_session" "Session exists but worktree is missing. Removing stale session..."
         rm -f "$session_path"
         remove_issue_from_index "$issue_ref"
         session_exists=false
     fi
     
-    local active_count=$(count_active_dev_sessions)
+    if ! $worktree_exists; then
-    if [ "$active_count" -ge "${MAX_CONCURRENT_AGENTS:-3}" ]; then
+        local wt_status=$(ensure_worktree "$issue_ref")
-        echo "Error: Max concurrent agents (${MAX_CONCURRENT_AGENTS:-3}) reached. Use 'kugetsu continue' or wait for an agent to finish." >&2
+        if [ "$wt_status" != "created" ] && [ "$wt_status" != "existed" ]; then
-        exit 1
+            log "error" "ensure_session" "Failed to ensure worktree for $issue_ref"
+            echo "error"
+            return 1
+        fi
     fi
     
-    create_worktree "$issue_ref" "$WORKTREES_DIR"
+    local base_session_id=$(get_base_session_id)
+    if [ -z "$base_session_id" ] || [ "$base_session_id" = "null" ]; then
+        log "error" "ensure_session" "Base session not found for $issue_ref"
+        echo "error"
+        return 1
+    fi
     
     local new_session_id=$(create_session "$base_session_id")
     
     if [ -z "$new_session_id" ]; then
-        echo "Error: Could not create session" >&2
+        log "error" "ensure_session" "Could not create session for $issue_ref"
-        remove_worktree_for_issue "$issue_ref"
+        echo "error"
-        exit 1
+        return 1
     fi
     
     local worktree_path=$(issue_ref_to_worktree_path "$issue_ref")
@@ -389,81 +434,90 @@ cmd_start() {
     
     add_issue_to_index "$issue_ref" "$session_file"
     
-    local dev_message=$(build_dev_agent_message "$issue_ref" "$message")
+    log "info" "ensure_session" "Created session for $issue_ref: $new_session_id"
+    echo "created"
+    return 0
+}
+
+fork_agent() {
+    local session_id="$1"
+    local worktree_path="$2"
+    local message="$3"
+    
+    if [ -z "$worktree_path" ] || [ ! -d "$worktree_path" ]; then
+        log "error" "fork_agent" "Invalid worktree path: $worktree_path"
+        echo "error"
+        return 1
+    fi
     
     load_agent_env "dev"
     
     cd "$worktree_path"
-    local sanitized_id=$(echo "$new_session_id" | sed 's/[^a-zA-Z0-9_-]/_/g')
+    local sanitized_id=$(echo "$session_id" | sed 's/[^a-zA-Z0-9_-]/_/g')
-    local msg_file="$worktree_path/.kugetsu-msg.txt"
+    mkdir -p "$worktree_path/.kugetsu"
-    printf '%s' "$dev_message" > "$msg_file"
+    if [ ! -f "$worktree_path/.gitignore" ] || ! grep -q "^.kugetsu/" "$worktree_path/.gitignore"; then
-    nohup sh -c "GITEA_TOKEN='${GITEA_TOKEN:-}' opencode run '@$msg_file' --session '$new_session_id'" >> "$LOGS_DIR/dev-$sanitized_id.log" 2>&1 &
+        echo ".kugetsu/" >> "$worktree_path/.gitignore" 2>/dev/null || true
+    fi
+    local msg_file="$worktree_path/.kugetsu/msg.txt"
+    printf '%s' "$message" > "$msg_file"
+    nohup sh -c "GITEA_TOKEN='${GITEA_TOKEN:-}' opencode run '@$msg_file' --session '$session_id'" >> "$LOGS_DIR/dev-$sanitized_id.log" 2>&1 &
     
-    echo "Session started for '$issue_ref': $new_session_id"
+    log "info" "fork_agent" "Forked agent for session $session_id in $worktree_path"
-    echo "Worktree: $worktree_path"
+    echo "forked"
+    return 0
+}
+
+cmd_start() {
+    cmd_continue "$@"
 }
 
 cmd_continue() {
-    local session_name=""
+    local issue_ref="${1:-}"
-    local message=""
+    local message="${2:-}"
-    local args=("$@")
-
-    args=$(set_debug_mode "${args[@]}")
-
-    for arg in $args; do
-        if [ -z "$session_name" ]; then
-            session_name="$arg"
-        else
-            message="$arg"
-        fi
-    done
     
-    if [ -z "$session_name" ]; then
+    if [ -z "$issue_ref" ]; then
         echo "Error: issue ref is required" >&2
         echo "Usage: kugetsu continue <issue-ref> [message]" >&2
         exit 1
     fi
     
-    validate_issue_ref "$session_name"
+    validate_issue_ref "$issue_ref"
-    
-    local session_file=$(get_session_for_issue "$session_name")
-    if [ -z "$session_file" ] || [ "$session_file" = "null" ]; then
-        echo "Error: No session found for '$session_name'" >&2
-        echo "Use 'kugetsu start $session_name' to create a new session." >&2
-        exit 1
-    fi
-    
-    local session_path="$SESSIONS_DIR/$session_file"
-    
-    if [ ! -f "$session_path" ]; then
-        echo "Error: Session file not found: $session_path" >&2
-        exit 1
-    fi
-    
-    load_agent_env "dev"
-    
-    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 [ -z "$worktree_path" ] || [ ! -d "$worktree_path" ]; then
-        echo "Warning: Worktree is missing for '$session_name'. Recovering..." >&2
-        rm -f "$session_path"
-        remove_issue_from_index "$session_name"
-        echo "Calling cmd_start to create new session and worktree..." >&2
-        cmd_start "$session_name" "$message"
-        return $?
-    fi
     
     if [ -z "$message" ]; then
         message=$(build_dev_agent_message "$issue_ref" "")
+    else
+        message=$(build_dev_agent_message "$issue_ref" "$message")
+    fi
     fi
     
-    cd "$worktree_path"
+    local worktree_status=$(ensure_worktree "$issue_ref")
-    local sanitized_id=$(echo "$opencode_session_id" | sed 's/[^a-zA-Z0-9_-]/_/g')
+    if [ "$worktree_status" = "error" ]; then
-    local msg_file="$worktree_path/.kugetsu-msg.txt"
+        echo "Error: Failed to ensure worktree for '$issue_ref'" >&2
-    printf '%s' "$message" > "$msg_file"
+        exit 1
-    nohup sh -c "GITEA_TOKEN='${GITEA_TOKEN:-}' opencode run '@$msg_file' --session '$opencode_session_id'" >> "$LOGS_DIR/dev-$sanitized_id.log" 2>&1 &
+    fi
+    
+    local session_status=$(ensure_session "$issue_ref")
+    if [ "$session_status" = "error" ]; then
+        echo "Error: Failed to ensure session for '$issue_ref'" >&2
+        exit 1
+    fi
+    
+    local session_file=$(issue_ref_to_filename "$issue_ref")
+    local session_path="$SESSIONS_DIR/$session_file"
+    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 fork_status=$(fork_agent "$opencode_session_id" "$worktree_path" "$message")
+    if [ "$fork_status" = "error" ]; then
+        echo "Error: Failed to fork agent for '$issue_ref'" >&2
+        exit 1
+    fi
+    
+    log "info" "cmd_continue" "Result for $issue_ref: worktree=$worktree_status session=$session_status fork=$fork_status"
+    
+    echo "Session continued for '$issue_ref': $opencode_session_id"
+    echo "Worktree: $worktree_path"
+    echo "${worktree_status}-${session_status}-${fork_status}"
 }
 
 cmd_list() {