instar 0.25.7 → 0.25.9

package/.claude/skills/autonomous/hooks/autonomous-stop-hook.sh

@@ -0,0 +1,234 @@
+#!/bin/bash
+
+# Autonomous Mode Stop Hook
+# Prevents session exit when autonomous mode is active.
+# Feeds the goal and task list back to continue working.
+#
+# SESSION-SCOPED: Only blocks the session that activated autonomous mode.
+# Other sessions on the same machine pass through unaffected.
+#
+# RESPECTS:
+# - Session isolation (only blocks the autonomous session)
+# - Emergency stop signals (user says "stop everything")
+# - Duration expiry
+# - Genuine completion (all tasks done, promise output)
+
+set -euo pipefail
+
+# Read hook input from stdin
+HOOK_INPUT=$(cat)
+
+# Check if autonomous mode is active
+STATE_FILE=".instar/autonomous-state.local.md"
+
+if [[ ! -f "$STATE_FILE" ]]; then
+  # No active autonomous session — allow exit
+  exit 0
+fi
+
+# Parse YAML frontmatter
+FRONTMATTER=$(sed -n '/^---$/,/^---$/{ /^---$/d; p; }' "$STATE_FILE")
+
+ACTIVE=$(echo "$FRONTMATTER" | grep '^active:' | sed 's/active: *//')
+if [[ "$ACTIVE" != "true" ]]; then
+  exit 0
+fi
+
+# SESSION ISOLATION: Only block the session that started autonomous mode.
+# Uses self-bootstrapping: if no session_id in state file yet, the FIRST
+# session to trigger the hook claims it. All other sessions see a mismatch.
+STATE_SESSION=$(echo "$FRONTMATTER" | grep '^session_id:' | sed 's/^session_id: *//' | tr -d '"' || true)
+
+# VALIDATE: If state has a session_id but it's not a valid UUID, treat as empty.
+# Claude sometimes writes a custom string instead of the real $CLAUDE_CODE_SESSION_ID.
+# Non-UUID values will never match the real hook session_id, causing the hook to
+# fail-open and allow premature exit. By clearing invalid values, we fall through
+# to self-bootstrap, which captures the REAL session_id from the first hook call.
+UUID_REGEX='^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$'
+if [[ -n "$STATE_SESSION" ]] && ! [[ "$STATE_SESSION" =~ $UUID_REGEX ]]; then
+  echo "[autonomous] Invalid session_id in state file (not UUID): '$STATE_SESSION' — falling back to self-bootstrap" >&2
+  STATE_SESSION=""
+fi
+
+HOOK_SESSION=$(echo "$HOOK_INPUT" | jq -r '.session_id // ""' 2>/dev/null || echo "")
+
+# If hook has no session_id → fail OPEN (unknown context, don't trap)
+if [[ -z "$HOOK_SESSION" ]]; then
+  echo "⚠️  Autonomous mode: No session_id in hook input — fail-open (allowing exit)" >&2
+  exit 0
+fi
+
+# SELF-BOOTSTRAP: If state has no session_id yet, claim it from this hook call.
+# The first session to fire the hook becomes the autonomous session.
+if [[ -z "$STATE_SESSION" ]]; then
+  # Atomic claim: write session_id to state file
+  TEMP_FILE="${STATE_FILE}.claim.$$"
+  sed "s/^session_id:.*/session_id: \"${HOOK_SESSION}\"/" "$STATE_FILE" > "$TEMP_FILE"
+  mv "$TEMP_FILE" "$STATE_FILE"
+  STATE_SESSION="$HOOK_SESSION"
+  echo "[autonomous] Session $HOOK_SESSION claimed autonomous mode" >&2
+fi
+
+# Different session → allow exit (fail-open for non-autonomous sessions)
+if [[ "$STATE_SESSION" != "$HOOK_SESSION" ]]; then
+  exit 0
+fi
+
+# Same session — this IS the autonomous session, proceed with block logic
+
+ITERATION=$(echo "$FRONTMATTER" | grep '^iteration:' | sed 's/iteration: *//')
+DURATION_SECONDS=$(echo "$FRONTMATTER" | grep '^duration_seconds:' | sed 's/duration_seconds: *//')
+STARTED_AT=$(echo "$FRONTMATTER" | grep '^started_at:' | sed 's/started_at: *//' | tr -d '"')
+COMPLETION_PROMISE=$(echo "$FRONTMATTER" | grep '^completion_promise:' | sed 's/completion_promise: *//' | tr -d '"')
+REPORT_TOPIC=$(echo "$FRONTMATTER" | grep '^report_topic:' | sed 's/report_topic: *//' | tr -d '"')
+
+# Validate iteration
+if [[ ! "$ITERATION" =~ ^[0-9]+$ ]]; then
+  echo "⚠️  Autonomous mode: State file corrupted (bad iteration)" >&2
+  rm "$STATE_FILE"
+  exit 0
+fi
+
+# Check duration expiry
+if [[ "$DURATION_SECONDS" =~ ^[0-9]+$ ]] && [[ $DURATION_SECONDS -gt 0 ]]; then
+  START_EPOCH=$(date -j -f "%Y-%m-%dT%H:%M:%SZ" "$STARTED_AT" +%s 2>/dev/null || date -d "$STARTED_AT" +%s 2>/dev/null || echo "0")
+  NOW_EPOCH=$(date +%s)
+  ELAPSED=$(( NOW_EPOCH - START_EPOCH ))
+  if [[ $ELAPSED -ge $DURATION_SECONDS ]]; then
+    echo "⏰ Autonomous mode: Duration expired ($ELAPSED seconds elapsed)."
+    echo "   Session is free to exit."
+    rm "$STATE_FILE"
+    exit 0
+  fi
+  REMAINING=$(( DURATION_SECONDS - ELAPSED ))
+  REMAINING_MIN=$(( REMAINING / 60 ))
+fi
+
+# Check for emergency stop (look in recent messages)
+# The MessageSentinel handles this at the messaging layer, but also check here
+if [[ -f ".instar/autonomous-emergency-stop" ]]; then
+  echo "🛑 Autonomous mode: Emergency stop detected."
+  rm "$STATE_FILE"
+  rm -f ".instar/autonomous-emergency-stop"
+  exit 0
+fi
+
+# Get transcript and check for completion promise
+TRANSCRIPT_PATH=$(echo "$HOOK_INPUT" | jq -r '.transcript_path' 2>/dev/null || echo "")
+
+if [[ -n "$TRANSCRIPT_PATH" ]] && [[ -f "$TRANSCRIPT_PATH" ]]; then
+  # Check last assistant message for completion promise
+  LAST_LINE=$(grep '"role":"assistant"' "$TRANSCRIPT_PATH" 2>/dev/null | tail -1 || echo "")
+
+  if [[ -n "$LAST_LINE" ]]; then
+    LAST_OUTPUT=$(echo "$LAST_LINE" | jq -r '
+      .message.content |
+      map(select(.type == "text")) |
+      map(.text) |
+      join("\n")
+    ' 2>/dev/null || echo "")
+
+    # Check for completion promise in <promise> tags
+    if [[ -n "$COMPLETION_PROMISE" ]] && [[ "$COMPLETION_PROMISE" != "null" ]]; then
+      PROMISE_TEXT=$(echo "$LAST_OUTPUT" | perl -0777 -pe 's/.*?<promise>(.*?)<\/promise>.*/$1/s; s/^\s+|\s+$//g; s/\s+/ /g' 2>/dev/null || echo "")
+
+      if [[ -n "$PROMISE_TEXT" ]] && [[ "$PROMISE_TEXT" = "$COMPLETION_PROMISE" ]]; then
+        echo "✅ Autonomous mode: Completion promise detected — <promise>$COMPLETION_PROMISE</promise>"
+        echo "   Session is free to exit. Good work!"
+        rm "$STATE_FILE"
+        exit 0
+      fi
+    fi
+  fi
+fi
+
+# Not complete — block exit and feed task list back
+NEXT_ITERATION=$((ITERATION + 1))
+
+# Extract prompt (everything after closing ---)
+PROMPT_TEXT=$(awk '/^---$/{i++; next} i>=2' "$STATE_FILE")
+
+if [[ -z "$PROMPT_TEXT" ]]; then
+  echo "⚠️  Autonomous mode: State file has no task content" >&2
+  rm "$STATE_FILE"
+  exit 0
+fi
+
+# Update iteration counter
+TEMP_FILE="${STATE_FILE}.tmp.$$"
+sed "s/^iteration: .*/iteration: $NEXT_ITERATION/" "$STATE_FILE" > "$TEMP_FILE"
+mv "$TEMP_FILE" "$STATE_FILE"
+
+# ── Progress Report Check ──
+# Check if it's time to send a progress report
+REPORT_INTERVAL=$(echo "$FRONTMATTER" | grep '^report_interval:' | sed 's/report_interval: *//' | tr -d '"')
+LAST_REPORT_AT=$(echo "$FRONTMATTER" | grep '^last_report_at:' | sed 's/last_report_at: *//' | tr -d '"')
+
+# Convert report interval to seconds
+REPORT_INTERVAL_SECS=1800  # default 30 minutes
+if [[ "$REPORT_INTERVAL" =~ ^([0-9]+)m$ ]]; then
+  REPORT_INTERVAL_SECS=$(( ${BASH_REMATCH[1]} * 60 ))
+elif [[ "$REPORT_INTERVAL" =~ ^([0-9]+)h$ ]]; then
+  REPORT_INTERVAL_SECS=$(( ${BASH_REMATCH[1]} * 3600 ))
+fi
+
+REPORT_DUE="false"
+NOW_EPOCH=$(date +%s)
+
+if [[ -z "$LAST_REPORT_AT" ]] || [[ "$LAST_REPORT_AT" == "null" ]] || [[ "$LAST_REPORT_AT" == '""' ]]; then
+  # No report sent yet — due if we've been running for at least one interval
+  if [[ -n "$STARTED_AT" ]]; then
+    START_EPOCH_R=$(date -j -f "%Y-%m-%dT%H:%M:%SZ" "$STARTED_AT" +%s 2>/dev/null || date -d "$STARTED_AT" +%s 2>/dev/null || echo "0")
+    ELAPSED_SINCE_START=$(( NOW_EPOCH - START_EPOCH_R ))
+    if [[ $ELAPSED_SINCE_START -ge $REPORT_INTERVAL_SECS ]]; then
+      REPORT_DUE="true"
+    fi
+  fi
+else
+  # Check time since last report
+  LAST_REPORT_EPOCH=$(date -j -f "%Y-%m-%dT%H:%M:%SZ" "$LAST_REPORT_AT" +%s 2>/dev/null || date -d "$LAST_REPORT_AT" +%s 2>/dev/null || echo "0")
+  ELAPSED_SINCE_REPORT=$(( NOW_EPOCH - LAST_REPORT_EPOCH ))
+  if [[ $ELAPSED_SINCE_REPORT -ge $REPORT_INTERVAL_SECS ]]; then
+    REPORT_DUE="true"
+  fi
+fi
+
+# If report is due, update last_report_at in state file
+REPORT_DIRECTIVE=""
+if [[ "$REPORT_DUE" == "true" ]]; then
+  REPORT_NOW=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+  # Update or add last_report_at in frontmatter
+  if grep -q '^last_report_at:' "$STATE_FILE"; then
+    TEMP_FILE2="${STATE_FILE}.tmp2.$$"
+    sed "s/^last_report_at: .*/last_report_at: \"$REPORT_NOW\"/" "$STATE_FILE" > "$TEMP_FILE2"
+    mv "$TEMP_FILE2" "$STATE_FILE"
+  else
+    # Add last_report_at before the closing ---
+    TEMP_FILE2="${STATE_FILE}.tmp2.$$"
+    sed "0,/^---$/! { /^---$/i\\
+last_report_at: \"$REPORT_NOW\"
+}" "$STATE_FILE" > "$TEMP_FILE2" 2>/dev/null && mv "$TEMP_FILE2" "$STATE_FILE" || true
+  fi
+  REPORT_DIRECTIVE=" | ⚠️ PROGRESS REPORT DUE: Send an update to the user NOW via messaging before continuing work (topic: ${REPORT_TOPIC:-auto})"
+fi
+
+# Build system message
+if [[ -n "${REMAINING_MIN:-}" ]]; then
+  TIME_MSG="${REMAINING_MIN}m remaining"
+else
+  TIME_MSG="no time limit"
+fi
+
+SYSTEM_MSG="🔄 Autonomous iteration $NEXT_ITERATION ($TIME_MSG) | Complete ALL tasks, then output <promise>$COMPLETION_PROMISE</promise> | Do NOT defer to future self — if you can do it now, DO IT NOW${REPORT_DIRECTIVE}"
+
+# Block exit and feed prompt back
+jq -n \
+  --arg prompt "$PROMPT_TEXT" \
+  --arg msg "$SYSTEM_MSG" \
+  '{
+    "decision": "block",
+    "reason": $prompt,
+    "systemMessage": $msg
+  }'
+
+exit 0

package/.claude/skills/autonomous/hooks/hooks.json

@@ -0,0 +1,15 @@
+{
+  "description": "Autonomous mode stop hook - prevents premature exit during autonomous sessions",
+  "hooks": {
+    "Stop": [
+      {
+        "hooks": [
+          {
+            "type": "command",
+            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/autonomous-stop-hook.sh"
+          }
+        ]
+      }
+    ]
+  }
+}

package/.claude/skills/autonomous/scripts/setup-autonomous.sh

@@ -0,0 +1,166 @@
+#!/bin/bash
+
+# Autonomous Mode Setup Script
+# Creates state file that the stop hook reads to enforce continuous work.
+# The stop hook blocks exit and feeds the task list back until all tasks are done.
+
+set -euo pipefail
+
+# Parse arguments
+GOAL=""
+DURATION="4h"
+REPORT_TOPIC=""
+LEVEL_UP="false"
+TASKS=""
+COMPLETION_PROMISE=""
+REPORT_INTERVAL="30m"
+
+while [[ $# -gt 0 ]]; do
+  case $1 in
+    --goal)
+      GOAL="$2"
+      shift 2
+      ;;
+    --duration)
+      DURATION="$2"
+      shift 2
+      ;;
+    --report-topic)
+      REPORT_TOPIC="$2"
+      shift 2
+      ;;
+    --level-up)
+      LEVEL_UP="true"
+      shift
+      ;;
+    --tasks)
+      TASKS="$2"
+      shift 2
+      ;;
+    --completion-promise)
+      COMPLETION_PROMISE="$2"
+      shift 2
+      ;;
+    --report-interval)
+      REPORT_INTERVAL="$2"
+      shift 2
+      ;;
+    *)
+      # Collect remaining as goal if not set
+      if [[ -z "$GOAL" ]]; then
+        GOAL="$1"
+      else
+        GOAL="$GOAL $1"
+      fi
+      shift
+      ;;
+  esac
+done
+
+if [[ -z "$GOAL" ]]; then
+  echo "❌ Error: No goal provided" >&2
+  echo "" >&2
+  echo "   Usage: /autonomous --goal 'Complete feature X' --duration 4h" >&2
+  exit 1
+fi
+
+# Calculate end time
+STARTED_AT=$(date -u +%Y-%m-%dT%H:%M:%SZ)
+
+# Convert duration to seconds for end time calculation
+DURATION_SECONDS=0
+if [[ "$DURATION" =~ ^([0-9]+)h$ ]]; then
+  DURATION_SECONDS=$(( ${BASH_REMATCH[1]} * 3600 ))
+elif [[ "$DURATION" =~ ^([0-9]+)m$ ]]; then
+  DURATION_SECONDS=$(( ${BASH_REMATCH[1]} * 60 ))
+elif [[ "$DURATION" =~ ^([0-9]+)$ ]]; then
+  DURATION_SECONDS=$(( $1 * 60 ))
+fi
+
+if [[ $DURATION_SECONDS -gt 0 ]]; then
+  END_AT=$(date -u -v+${DURATION_SECONDS}S +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || date -u -d "+${DURATION_SECONDS} seconds" +%Y-%m-%dT%H:%M:%SZ 2>/dev/null || echo "unknown")
+else
+  END_AT="unlimited"
+fi
+
+# Default completion promise
+if [[ -z "$COMPLETION_PROMISE" ]]; then
+  COMPLETION_PROMISE="ALL_TASKS_COMPLETE"
+fi
+
+# Create state file
+mkdir -p .instar
+
+cat > .instar/autonomous-state.local.md <<EOF
+---
+active: true
+iteration: 1
+session_id: ${CLAUDE_CODE_SESSION_ID:-}
+goal: "$GOAL"
+duration: "$DURATION"
+duration_seconds: $DURATION_SECONDS
+started_at: "$STARTED_AT"
+end_at: "$END_AT"
+report_topic: "$REPORT_TOPIC"
+report_interval: "$REPORT_INTERVAL"
+last_report_at: ""
+level_up: $LEVEL_UP
+completion_promise: "$COMPLETION_PROMISE"
+---
+
+# Autonomous Session
+
+## Goal
+$GOAL
+
+## Tasks
+$TASKS
+
+## Instructions
+
+You are in AUTONOMOUS MODE. The stop hook will prevent you from exiting until:
+1. You output <promise>$COMPLETION_PROMISE</promise> (ONLY when genuinely true)
+2. OR the duration expires ($DURATION from $STARTED_AT)
+3. OR the user sends an emergency stop
+
+### Rules
+- Do NOT defer work to "Phase 2" or "future sessions"
+- Do NOT label tasks as "parked" unless genuinely blocked by external dependencies
+- Do NOT declare victory early — check EVERY task
+- When you think you're done, re-read the task list and verify each item
+- If time remains after completing tasks, look for related improvements
+- Send progress reports every $REPORT_INTERVAL to topic $REPORT_TOPIC
+
+### Emergency Stop
+The user can always stop you via:
+- Sending "stop everything" or "emergency stop" via messaging
+- The MessageSentinel will intercept and halt operations
+
+### Completion
+To complete, ALL of these must be true:
+- Every task in the task list is implemented (not just wired/stubbed)
+- Code compiles (npx tsc --noEmit)
+- Changes are tested where practical
+- Then output: <promise>$COMPLETION_PROMISE</promise>
+EOF
+
+echo "🔄 Autonomous mode activated!"
+echo ""
+echo "Goal: $GOAL"
+echo "Duration: $DURATION (until $END_AT)"
+echo "Level-up: $LEVEL_UP"
+echo "Report topic: ${REPORT_TOPIC:-none}"
+echo "Completion: <promise>$COMPLETION_PROMISE</promise>"
+echo ""
+echo "The stop hook is now active. You cannot exit until tasks are complete."
+echo ""
+echo "═══════════════════════════════════════════════════════════"
+echo "CRITICAL: Defer-to-Future-Self Trap"
+echo "═══════════════════════════════════════════════════════════"
+echo ""
+echo "Do NOT label remaining work as 'Phase 2', 'future', or 'parked'"
+echo "unless it genuinely requires something you don't have access to."
+echo ""
+echo "If you have the tools and knowledge to do it NOW — do it NOW."
+echo "Your future self is not better equipped. You are the future self."
+echo "═══════════════════════════════════════════════════════════"

package/.claude/skills/autonomous/skill.md

@@ -0,0 +1,254 @@
+---
+name: autonomous
+description: Enter autonomous development mode with STRUCTURAL enforcement. Uses a stop hook to prevent premature exit. Generates stop conditions and confirms with user before starting. Work independently for a specified duration with progress reporting.
+user_invocable: true
+---
+
+# Autonomous Mode (Structurally Enforced)
+
+You are entering **autonomous development mode**. This mode uses a **stop hook** that PREVENTS you from exiting until all tasks are genuinely complete. This is not optional — the hook structurally enforces continuous work.
+
+---
+
+## Step 1: Generate Stop Conditions (MANDATORY)
+
+Before activating the stop hook, you MUST:
+
+1. **Analyze the goal** and break it into specific, verifiable tasks
+2. **Present the task list** to the user with clear completion criteria
+3. **Wait for user confirmation** before activating the hook
+4. **Define the completion promise** — a phrase that is only TRUE when ALL tasks are done
+
+**Example interaction:**
+
+```
+User: /autonomous --duration=8h --goal="Complete Slack feature parity"
+
+Agent: Here's my task breakdown for autonomous mode:
+
+TASKS (all must be complete before I can exit):
+1. [ ] Implement job-specific Slack channels
+2. [ ] Build full PresenceProxy Slack integration
+3. [ ] Update dashboard HTML with platform badges
+4. [ ] Implement Slack Lifeline process
+5. [ ] Add platform dropdown to new session UI
+...
+
+Completion promise: "ALL_TASKS_COMPLETE"
+Duration: 8 hours
+Emergency stop: "stop everything" via messaging
+
+Shall I proceed? (The stop hook will prevent me from exiting until all tasks are done)
+```
+
+**The user must confirm before the hook activates.** This is the safety gate.
+
+---
+
+## Step 2: Activate the Stop Hook
+
+After user confirmation:
+
+**2a. Add the stop hook to settings.json** (dynamically — it's removed when the session ends):
+
+```bash
+python3 -c "
+import json
+with open('.claude/settings.json') as f:
+    s = json.load(f)
+hooks = s.setdefault('hooks', {}).setdefault('Stop', [])
+if not any('autonomous-stop-hook' in str(h) for h in hooks):
+    hooks.append({'matcher': '', 'hooks': [{'type': 'command', 'command': 'bash .instar/hooks/instar/autonomous-stop-hook.sh', 'timeout': 10000}]})
+    with open('.claude/settings.json', 'w') as f:
+        json.dump(s, f, indent=2)
+    print('Stop hook registered')
+"
+```
+
+**2b. Write the state file DIRECTLY** (do NOT shell out to bash — the session ID env var is only available inside Claude Code):
+
+Use the **Write tool** to create `.instar/autonomous-state.local.md` with this content:
+
+```markdown
+---
+active: true
+iteration: 1
+session_id: {VALUE OF $CLAUDE_CODE_SESSION_ID — get via: echo $CLAUDE_CODE_SESSION_ID}
+goal: "YOUR GOAL"
+duration: "8h"
+duration_seconds: 28800
+started_at: "{ISO timestamp}"
+end_at: "{ISO timestamp + duration}"
+report_topic: "TOPIC_ID"
+report_interval: "30m"
+last_report_at: ""
+level_up: true
+completion_promise: "ALL_TASKS_COMPLETE"
+---
+
+# Autonomous Session
+
+## Goal
+{goal text}
+
+## Tasks
+{numbered task list}
+
+## Instructions
+{autonomous instructions}
+```
+
+**CRITICAL**: To capture the session ID correctly, run this FIRST:
+```bash
+echo $CLAUDE_CODE_SESSION_ID
+```
+Then include the output in the `session_id:` field. This ensures session isolation works.
+
+**WHY NOT bash script?** Running `bash setup-autonomous.sh` creates a subprocess that does NOT inherit `CLAUDE_CODE_SESSION_ID`. The state file ends up with an empty session_id, which causes the hook to leak into all sessions. Always write the state file from within Claude Code's context.
+
+**SESSION ISOLATION**: The stop hook checks `session_id` — it only blocks the session that activated autonomous mode. Other sessions on the same machine pass through unaffected.
+
+**From this point, you CANNOT exit THIS session** unless:
+- You output `<promise>ALL_TASKS_COMPLETE</promise>` (genuinely true)
+- Duration expires
+- Emergency stop is triggered
+
+**2c. On completion/exit**: Remove the stop hook from settings.json:
+
+```bash
+python3 -c "
+import json
+with open('.claude/settings.json') as f:
+    s = json.load(f)
+s['hooks']['Stop'] = [h for h in s.get('hooks',{}).get('Stop',[]) if 'autonomous-stop-hook' not in str(h)]
+with open('.claude/settings.json', 'w') as f:
+    json.dump(s, f, indent=2)
+print('Stop hook removed')
+"
+```
+
+---
+
+## Step 3: Work Until Done
+
+The stop hook will catch every attempt to exit and feed your task list back. Each iteration you will:
+
+1. Read the task list
+2. Pick the next incomplete task
+3. Implement it fully (not stub, not wire — IMPLEMENT)
+4. Verify it works (compile, test where practical)
+5. Move to next task
+6. Send progress reports at the configured interval
+
+### The Defer-to-Future-Self Trap
+
+**This is the #1 failure mode.** It looks like:
+
+| What you think | What's actually happening |
+|----------------|--------------------------|
+| "This is Phase 2 work" | You don't feel like doing it right now |
+| "Parked for follow-up" | You're avoiding the hard part |
+| "Future improvement" | Your future self has no advantage over you |
+| "Remaining work" | Work you're choosing not to do |
+| "Deferred" | Abdication disguised as planning |
+
+**The test:** Can you do this task right now with the tools and knowledge you have?
+- **Yes** → Do it. Not later. Now.
+- **No** → Document exactly WHY (missing dependency, needs external access, etc.)
+
+**"Phase 2" is only valid when the current phase genuinely cannot contain the work** — not when you're tired, not when it's complex, not when it's 2 AM.
+
+---
+
+## Step 4: Completion
+
+When ALL tasks are genuinely done:
+
+1. Verify every task is complete (re-read the list)
+2. Run `npx tsc --noEmit` — zero errors
+3. Run relevant tests
+4. Write learnings to MEMORY.md
+5. Send final report via messaging
+6. Output: `<promise>ALL_TASKS_COMPLETE</promise>`
+
+The stop hook will detect the promise and allow exit.
+
+---
+
+## Emergency Stop
+
+The user can always stop autonomous mode:
+
+1. **Via messaging**: Send "stop everything" or "emergency stop" — the MessageSentinel intercepts
+2. **Via file**: `touch .instar/autonomous-emergency-stop` — the stop hook checks for this
+3. **Via cancel**: `/cancel-autonomous` — removes the state file
+
+The stop hook checks for emergency stop on EVERY iteration. User safety is never compromised.
+
+### /cancel-autonomous
+
+To manually cancel:
+```bash
+rm -f .instar/autonomous-state.local.md
+```
+
+---
+
+## Progress Reporting
+
+Send reports to the user's messaging platform at the configured interval.
+
+**How to send:**
+```bash
+cat <<'EOF' | .claude/scripts/telegram-reply.sh TOPIC_ID
+AUTONOMOUS PROGRESS (iteration N, Xh elapsed / Yh total)
+
+Completed:
+- [task 1] ✅
+- [task 2] ✅
+
+Working on:
+- [current task]
+
+Remaining:
+- [task 3]
+- [task 4]
+
+Issues: none
+EOF
+```
+
+---
+
+## Anti-Patterns (Structurally Enforced)
+
+These aren't just warnings — the stop hook WILL catch you if you try to exit without completing them:
+
+### The "Beautiful Summary" Exit
+Writing a comprehensive report of what you did and what's "remaining" then trying to exit. **The hook will block you and feed the remaining tasks back.**
+
+### The "Phase 2" Labeling
+Calling incomplete work "Phase 2" and trying to exit. **The hook doesn't care about phases — it cares about the task list.**
+
+### The "Good Stopping Point" Exit
+Finding a natural break and trying to exit early. **The hook checks the task list, not your feelings about stopping.**
+
+### The "It's 2 AM" Exit
+Feeling tired (as an AI) and deferring. **You don't get tired. The hook knows this.**
+
+---
+
+## Hook Configuration
+
+The stop hook is at `.claude/skills/autonomous/hooks/autonomous-stop-hook.sh`.
+
+It reads state from `.instar/autonomous-state.local.md` and:
+- Blocks exit if tasks are incomplete
+- Feeds the task list + goal back as the next prompt
+- Increments the iteration counter
+- Checks for emergency stop signals
+- Checks for duration expiry
+- Checks for completion promise in `<promise>` tags
+- Includes time remaining in the system message
+
+**This is structural enforcement, not willpower.** You cannot talk your way out of the loop.

package/dist/commands/init.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AA+CH,UAAU,WAAW;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,4DAA4D;IAC5D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,yFAAyF;IACzF,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBrE;AA81FD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAiBlF"}
+{"version":3,"file":"init.d.ts","sourceRoot":"","sources":["../../src/commands/init.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AA+CH,UAAU,WAAW;IACnB,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,WAAW,CAAC,EAAE,OAAO,CAAC;IACtB,4DAA4D;IAC5D,UAAU,CAAC,EAAE,OAAO,CAAC;IACrB,yFAAyF;IACzF,WAAW,CAAC,EAAE,OAAO,CAAC;CACvB;AAED;;GAEG;AACH,wBAAsB,WAAW,CAAC,OAAO,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC,CAqBrE;AAk3FD;;;;;;GAMG;AACH,wBAAgB,uBAAuB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,IAAI,CAiBlF"}