sisyphi 1.0.6 → 1.0.8

package/dist/templates/agent-plugin/hooks/CLAUDE.md

@@ -0,0 +1,57 @@
+# templates/agent-plugin/hooks/
+
+Lifecycle hooks for agent plugin workflows. Enable specialized prompt generation and context handling during agent spawning.
+
+## hooks.json
+
+Schema: `{ "phaseKey": { "hookName": "script-name.sh" } }`
+
+Example:
+```json
+{
+  "plan": {
+    "userPrompt": "plan-user-prompt.sh",
+    "systemPrompt": "plan-system-prompt.sh"
+  }
+}
+```
+
+- **Keys**: Phase names (e.g., `plan`, `spec`, `implement`) — must correspond to phase modes in agent spawn workflow
+- **Values**: Object mapping hook types to shell script names
+- **Hook types**: `userPrompt`, `systemPrompt` (extensible for future hooks)
+
+## Shell Scripts
+
+Each script receives environment variables and outputs text to stdout.
+
+```bash
+# Receives: $SISYPHUS_SESSION_ID, $SISYPHUS_AGENT_ID, $INSTRUCTION, $AGENT_TYPE, context files
+# Outputs: Full user or system prompt text
+```
+
+**Convention**: `{phase}-{hook-type}.sh`
+
+**Inputs**:
+- `$SISYPHUS_SESSION_ID` — Session UUID
+- `$SISYPHUS_AGENT_ID` — Agent ID (e.g., `agent-001`)
+- `$INSTRUCTION` — Task instruction from spawn command
+- `$AGENT_TYPE` — Agent type (e.g., `plan`, `spec`, `implement`)
+- Context files at `.sisyphus/sessions/$SISYPHUS_SESSION_ID/context/`
+
+**Output**: Must write complete prompt text to stdout (no errors to stderr)
+
+## Invocation
+
+Hooks are executed during agent spawn when:
+1. Agent type matches a plugin agent type (e.g., `--agent-type sisyphus:plan`)
+2. Phase has hooks configured in hooks.json
+3. Daemon renders prompts before passing to Claude
+
+Output becomes the `--append-system-prompt` or user message content.
+
+## Key Patterns
+
+- **No placeholders in shell scripts** — unlike `.md` templates, scripts perform logic and generate final text
+- **Context access**: Scripts can read session state from `$SISYPHUS_SESSION_ID` directory
+- **Error handling**: Exit non-zero to fail agent spawn; errors logged to daemon.log
+- **Stdout only**: Scripts must output complete prompt to stdout; nothing to stderr

package/dist/templates/agent-plugin/hooks/hooks.json

@@ -3,18 +3,22 @@
     "PreToolUse": [
       {
         "matcher": "SendMessage",
-        "hook": {
-          "type": "command",
-          "command": "bash hooks/intercept-send-message.sh"
-        }
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/intercept-send-message.sh"
+          }
+        ]
       }
     ],
     "Stop": [
       {
-        "hook": {
-          "type": "command",
-          "command": "bash hooks/require-submit.sh"
-        }
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/require-submit.sh"
+          }
+        ]
       }
     ]
   }

package/dist/templates/agent-plugin/hooks/plan-user-prompt.sh

@@ -0,0 +1,16 @@
+#!/bin/bash
+# UserPromptSubmit hook: remind plan agent to delegate for large tasks.
+if [ -z "$SISYPHUS_SESSION_ID" ]; then exit 0; fi
+
+cat <<'HINT'
+<planning-reminder>
+For particularly large or multi-domain tasks, delegate sub-plans to specialist agents rather than planning everything solo:
+
+- Spawn parallel Plan agents, each focused on a specific domain or layer
+- Each sub-planner investigates deeply and saves their work to context/plan-{topic}-{slice}.md
+- Synthesize their outputs into one cohesive master plan: resolve file ownership conflicts, fill gaps between slices, stress-test cross-cutting edge cases
+- Then spawn review agents to critique the assembled plan before finalizing
+
+Default toward delegation when in doubt — a round-trip for synthesis is cheaper than a shallow plan that misses edge cases. The cost of spawning sub-planners is low; the cost of a surface-level plan across too many concerns is high.
+</planning-reminder>
+HINT

package/dist/templates/agent-plugin/hooks/spec-user-prompt.sh

@@ -0,0 +1,19 @@
+#!/bin/bash
+# UserPromptSubmit hook: remind spec agent to iterate with the user.
+if [ -z "$SISYPHUS_SESSION_ID" ]; then exit 0; fi
+
+cat <<'HINT'
+<spec-reminder>
+Iterate with the user — include them in the process before writing anything to disk:
+
+- Present your findings and a concrete proposal with your reasoning
+- Surface specific, substantive questions that need human input:
+  Bad: "What should happen on error?"
+  Good: "If the API returns a 429, should we retry with backoff or surface the rate limit to the user?"
+- Share your perspective: what's clear, what's open, what you'd lean toward and why
+- Wait for the user to respond and incorporate their answers before proceeding
+- The spec is only written after user sign-off on the direction
+
+Ambiguity can be technical, architectural, or design-related. Don't skip design questions just because they aren't code.
+</spec-reminder>
+HINT

package/dist/templates/companion-plugin/hooks/hooks.json

@@ -2,10 +2,12 @@
   "hooks": {
     "UserPromptSubmit": [
       {
-        "hook": {
-          "type": "command",
-          "command": "bash hooks/user-prompt-context.sh"
-        }
+        "hooks": [
+          {
+            "type": "command",
+            "command": "bash ${CLAUDE_PLUGIN_ROOT}/hooks/user-prompt-context.sh"
+          }
+        ]
       }
     ]
   }

package/dist/templates/orchestrator-planning.md

@@ -1,5 +1,9 @@
 # Planning Phase
 
+## Planning Phase Flow
+
+The natural sequence: **context → spec → roadmap refinement → detailed planning.** Context documents come first because they feed everything downstream — spec writers, planners, and implementers all benefit from not having to re-explore the codebase. After the spec is aligned, revisit the roadmap — that's when you actually understand scope well enough to flesh out phases honestly.
+
 ## Exploration
 
 Use explore agents to build understanding before making decisions. Each agent should save a focused context document to `.sisyphus/sessions/$SISYPHUS_SESSION_ID/context/` — these artifacts get passed to downstream agents so they don't have to re-explore the codebase themselves.
@@ -23,6 +27,10 @@ For significant features, spec refinement is iterative:
 
 Not every stage needs a standalone spec document — a well-defined stage might just be a detailed section in the implementation plan. Use judgment about how much formality each stage warrants.
 
+## Roadmap Refinement
+
+Once you have context docs and an aligned spec, revisit the roadmap. This is the first point where you understand real scope — adjust phase boundaries, add phases you didn't anticipate, reorder for dependencies. Keep future phases at outline level; just make sure the shape is honest.
+
 ## Delegating to the Plan Lead
 
 Spawn **one plan lead** per feature. Point it at **inputs** (spec, context docs, corrections) — not a pre-made structure. Don't pre-decide staging, ordering, or design decisions. The plan lead has `effort: max` reasoning and handles its own decomposition: it will assess scope, delegate sub-plans to specialist agents if the feature is large enough, run adversarial reviews on the result, and deliver a synthesized master plan.

package/dist/tui.js

@@ -720,7 +720,7 @@ function buildLines(session, planContent, goalContent, _logsContent, width, pane
     lines.push([
       seg("  "),
       seg(" \u2715 DEAD ", { color: "red", bold: true }),
-      seg(" tmux window closed \u2014 kill or resume", { color: "red" })
+      seg(" tmux window closed \u2014 [w] reopen  [R] resume", { color: "red" })
     ]);
   }
   if (conflicts.length > 0) {
@@ -2576,12 +2576,29 @@ function App({ cwd: cwd2 }) {
       },
       // kill moved to leader menu (space k)
       onGoToWindow: () => {
-        if (!session?.tmuxWindowId) {
-          notify("No tmux window");
+        if (!session || !selectedSessionId) {
+          notify("No session selected");
+          return;
+        }
+        if (paneAlive && session.tmuxWindowId) {
+          if (session.tmuxSessionName) switchToSession(session.tmuxSessionName);
+          selectWindow(session.tmuxWindowId);
           return;
         }
-        if (session.tmuxSessionName) switchToSession(session.tmuxSessionName);
-        selectWindow(session.tmuxWindowId);
+        void (async () => {
+          try {
+            const res = await send({ type: "reopen-window", sessionId: selectedSessionId, cwd: cwd2 });
+            if (!res.ok) {
+              notify(`Error: ${res.error}`);
+              return;
+            }
+            const data = res.data;
+            switchToSession(data.tmuxSessionName);
+            selectWindow(data.tmuxWindowId);
+          } catch (err) {
+            notify(`Error: ${err.message}`);
+          }
+        })();
       },
       onEditGoal: () => {
         if (!selectedSessionId) {