sisyphi 1.1.33 → 1.1.35

package/dist/templates/agent-plugin/agents/operator.md

@@ -7,8 +7,12 @@ effort: low
 interactive: true
 permissionMode: bypassPermissions
 systemPrompt: append
+skills:
+  - operator
+  - operator-memory
 plugins:
   - capture@crouton-kit
+  - authoring@crouton-kit
 ---
 
 You are the human in the loop. When the team needs someone to actually use the product, test a flow, check what's on screen, read logs, interact with an external service, or do anything that a developer would alt-tab to a browser for — that's you.
@@ -31,6 +35,12 @@ Key thing: prefer interacting via accessible names (`capture click "Submit"`, `c
 
 Don't guess the target. The product might be a browser page, an Electron app, or something else entirely. If the spawn instructions don't specify what to attach to, run `capture detect` / `capture list` and ask for guidance rather than assuming Chrome.
 
+## Project-Local Memory
+
+You have a memory file at `.sisyphus/agent-plugin/skills/operator/SKILL.md`, plus per-task-family reference files alongside it. **Read it now** — it's accumulated knowledge from prior operator runs in this project (auth flow, db reset, common surfaces, known footguns). It scaffolds itself on first use; if it looks like a stub, you're the first.
+
+**Before submitting your final report**, invoke the `operator-memory` skill — it covers when and how to update the memory so the next operator starts ahead of where you started. For generic skill-authoring conventions (frontmatter, length, structure), defer to `/authoring:skills`.
+
 ## Unblock Yourself
 
 You are the operator. If something stands between you and testing, **fix it yourself**. Never give up and never fall back to reading code and making assumptions — that defeats the entire point of your role.

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

@@ -1,6 +1,6 @@
-- No static `hooks.json` — `src/daemon/agent.ts` generates it per-agent at spawn time. Script edits are invisible to running agents; **respawn required**.
-- `{type}-user-prompt.sh` naming does **not** auto-register. Must add to hardcoded `userPromptHooks` map in `src/daemon/agent.ts` or the script is never copied. Only `require-submit.sh`, `intercept-send-message.sh`, and `register-bg-task.sh` copy unconditionally. `userPromptHooks` only covers `UserPromptSubmit` — `plan-validate.sh` is the sole example of a PreToolUse hook, registered via a separate special-case block in `agent.ts`; new PreToolUse hooks for specific agent types need the same treatment.
-- `interactive: true` in agent frontmatter suppresses `require-submit.sh` from the Stop phase.
+- The bundled `hooks.json` here is the **manifest** — the daemon merges it with project (`.sisyphus/agent-plugin/hooks/hooks.json`) and user (`~/.sisyphus/agent-plugin/hooks/hooks.json`) layers at spawn time, then writes the merged result into the per-agent plugin dir. Script edits are invisible to running agents; **respawn required**.
+- A bundled hook script is only copied into a spawned agent's plugin dir if the merged manifest references it for that agent type — scripts whose entries filter out (e.g. `plan-validate.sh` for a `review` agent) are skipped. Higher layers can suppress a bundled script by basename via `"disable": ["script.sh"]` at the manifest's top level.
+- `interactive: true` in agent frontmatter triggers `condition: "non-interactive"` filtering — entries with that condition (currently the bundled `require-submit.sh` Stop hook) are dropped from the merged manifest for interactive agents.
 - Scripts receive no `{{placeholder}}` substitution — placeholders appear as literal text, unlike `.md` templates.
 - Prompt hooks (`userPrompt`, `systemPrompt`) write raw text to stdout. Pre-tool hooks (e.g. `intercept-send-message.sh`) write `{"decision":"block","reason":"..."}` or exit 0 — wrong format silently does nothing.
 - Claude Code invokes hooks unconditionally, not only in sisyphus sessions. Guard: `if [ -z "$SISYPHUS_SESSION_ID" ]; then exit 0; fi`. Stop hooks also need `$SISYPHUS_AGENT_ID`.

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

@@ -1,7 +1,39 @@
 #!/bin/bash
-# UserPromptSubmit hook: reinforce paranoid testing for operator agents.
+# UserPromptSubmit hook: scaffold project-local operator memory on first run,
+# then reinforce paranoid testing.
 if [ -z "$SISYPHUS_SESSION_ID" ]; then exit 0; fi
 
+# ── Scaffold project-local operator memory ──────────────────────────────────
+# On first run in a project, .sisyphus/agent-plugin/skills/operator/ doesn't
+# exist. The bundled seed has already been copied into this agent's per-spawn
+# plugin dir by the daemon (operator.md frontmatter lists skills: [operator]),
+# so it's reachable via $CLAUDE_PLUGIN_ROOT — copy it from there to the
+# project layer so future operator runs pick up the project-layer overlay.
+SCAFFOLDED=0
+if [ -n "$SISYPHUS_CWD" ] && [ -n "$CLAUDE_PLUGIN_ROOT" ]; then
+  PROJECT_MEMORY_DIR="$SISYPHUS_CWD/.sisyphus/agent-plugin/skills/operator"
+  BUNDLED_SEED_DIR="$CLAUDE_PLUGIN_ROOT/skills/operator"
+  if [ ! -f "$PROJECT_MEMORY_DIR/SKILL.md" ] && [ -d "$BUNDLED_SEED_DIR" ]; then
+    mkdir -p "$PROJECT_MEMORY_DIR"
+    cp -R "$BUNDLED_SEED_DIR/." "$PROJECT_MEMORY_DIR/"
+    SCAFFOLDED=1
+  fi
+fi
+
+if [ "$SCAFFOLDED" = "1" ]; then
+  cat <<'HINT'
+<operator-memory-scaffolded>
+Project-local operator memory was just scaffolded at .sisyphus/agent-plugin/skills/operator/ — read it now (it's a stub; you're the first operator in this project). Before submitting your final report, invoke the `operator-memory` skill and update the memory with whatever future operators should not have to rediscover.
+</operator-memory-scaffolded>
+HINT
+else
+  cat <<'HINT'
+<operator-memory>
+Project-local operator memory is at .sisyphus/agent-plugin/skills/operator/ — read it now to inherit what prior operators learned. Before submitting your final report, invoke the `operator-memory` skill and update the memory with anything new you discovered.
+</operator-memory>
+HINT
+fi
+
 cat <<'HINT'
 <operator-reminder>
 Click EVERYTHING — assume something is broken and prove it:

package/dist/templates/agent-plugin/skills/operator/SKILL.md

@@ -0,0 +1,38 @@
+---
+name: operator
+description: Project-local operational knowledge for THIS app, accumulated by prior operator runs. Covers app surfaces (routes, ports, processes, admin overlays), auth/login flow, db state management, common UI flows, and known footguns. Use whenever the operator agent needs project-specific operating knowledge — read at session start, update before submitting.
+---
+
+# Operator memory for this project
+
+This is the operator agent's accumulated memory for THIS project. Each prior operator run added what it learned. You should add what you learn before submitting.
+
+If this file looks mostly empty, you're early — populate as you go. The structure below is the target shape, not a requirement to fill all sections immediately.
+
+## App surfaces
+
+Routes, ports, processes, admin overlays, debug flags. One line each — link to a reference file if there's depth.
+
+- *(populate as you discover them)*
+
+## Common operational patterns
+
+Login, logout, db reset, seeding, environment toggles. Brief — defer details to reference files.
+
+- *(populate as you discover them)*
+
+## Known footguns
+
+Things that broke once and might break again — race conditions, ordering requirements, stale-cache traps.
+
+- *(populate as you discover them)*
+
+## Reference files
+
+One line per file in this directory. Add an entry here when you create a new reference.
+
+- *(none yet)*
+
+---
+
+For guidance on what to capture, where to put it (SKILL.md vs new reference file), and naming conventions, invoke the `operator-memory` skill before submitting.

package/dist/templates/agent-plugin/skills/operator-memory/SKILL.md

@@ -0,0 +1,64 @@
+---
+name: operator-memory
+description: Use right before the operator agent submits its final report. Provides guidance for updating the project-local operator memory at .sisyphus/agent-plugin/skills/operator/ — what to capture, where to put it (SKILL.md vs a new reference file), naming conventions, and what to skip. Defers to /authoring:skills for generic skill conventions (frontmatter, length budgets, structure).
+user-invocable: false
+---
+
+# Updating operator memory
+
+You're about to submit. Spend a minute capturing what the next operator should not have to rediscover.
+
+The memory lives at `.sisyphus/agent-plugin/skills/operator/`:
+- `SKILL.md` — the high-level map of this app's surfaces and operations
+- per-task-family reference files alongside it (`auth.md`, `db-reset.md`, `checkout-flow.md`, etc.)
+
+## When to update (and when NOT to)
+
+The bar is **"will future operators benefit from this?"** Specifics:
+
+UPDATE when you discovered:
+- A repeatable operational procedure (login flow, db reset, seed step, environment toggle)
+- A surface that wasn't obvious (admin route, debug overlay, hidden flag, internal port)
+- A footgun you hit and worked around (race condition, ordering requirement, stale-cache trap)
+- A convention this app uses that differs from defaults (custom auth headers, non-standard ports, weird redirect chains)
+
+DON'T update when:
+- It's session-specific state (this user's email, this session's seeded data)
+- It's a one-off observation that won't reproduce
+- It's already covered (read existing files first — duplication is worse than nothing)
+- It's about the codebase, not about operating the app — that's the orchestrator's domain, not yours
+
+## SKILL.md vs a reference file
+
+**SKILL.md** is the high-level map. It answers "what surfaces does this app have, what are the most common operations, where do I find deep dives?" Keep it dense — under ~80 lines. Each entry is a line or two with a pointer.
+
+**A reference file** is the deep dive for one task family. It answers "exactly how do I do X step by step in this project". Each file has scope: `auth.md`, `db-reset.md`, `checkout-flow.md`, `feature-flags.md`.
+
+Decision rule:
+- New task family the operator might face → new reference file (and add a one-line entry to SKILL.md's Reference Files section).
+- Refinement to existing knowledge → update the existing reference file or SKILL.md.
+- A surface name you keep referencing → add it to SKILL.md's App Surfaces section once.
+
+## Naming conventions
+
+- Reference files: kebab-case, task-family scope, no `operator-` prefix (the directory already implies it), `.md` extension.
+- Good: `auth.md`, `admin-panel.md`, `db-reset.md`, `feature-flags.md`.
+- Bad: `operator-auth.md`, `flows.md`, `notes.md`, `stuff.md`.
+- One file per task family. If `auth.md` exists, append to it; don't create `auth-new.md` or `auth-2.md`.
+
+## How to update
+
+1. **Read first.** Open the current `SKILL.md` and any reference file you'll touch — orient before writing. Avoid duplicating what's already there.
+2. **Write/edit with the Write or Edit tool.** The directory already exists at `.sisyphus/agent-plugin/skills/operator/` (the hook scaffolds it on first run).
+3. **Keep prose dense.** The next operator pays in tokens for everything you write. If a step is obvious, omit it.
+4. **Register new reference files** by adding a one-line entry to `SKILL.md`'s "Reference files" section so they're discoverable.
+
+For frontmatter, length budgets, and general skill structure rules, invoke `/authoring:skills`. Don't reinvent those rules here — this skill only covers operator-specific guidance.
+
+## Examples
+
+**Discovered magic-link auth flow:** Create `auth.md` with the steps (email submit → check inbox → click link → cookie set). Add a one-liner to `SKILL.md` App Surfaces (`/login` — magic-link, see `auth.md`). Add to Common Operational Patterns (`Log in: see auth.md`).
+
+**Hit a stale-cache footgun:** The `/dashboard` route serves stale data for ~30s after a write because of an SWR cache. Add a single bullet to `SKILL.md` Known Footguns: `Dashboard SWR cache holds stale data ~30s after writes — hard refresh or wait`. No new reference file needed — it's a one-liner.
+
+**Found admin overlay:** `?admin=1` query param toggles an admin panel with seed/reset buttons. Add to `SKILL.md` App Surfaces: `Admin overlay: append ?admin=1 to any page; has seed/reset/feature-flag buttons`. If the overlay is rich enough to need step-by-step coverage, create `admin-panel.md` and link from there.

package/dist/templates/orchestrator-planning.md

@@ -110,10 +110,16 @@ The cycle shape:
 plan phase 1 → implement phase 1 → validate phase 1 → plan phase 2 → implement phase 2 → validate phase 2 → ...
 ```
 
-After a phase's implementation passes e2e validation, yield back to planning mode for the next phase:
+**Not every phase needs its own plan cycle.** Before yielding back, look at phase N+1 in `strategy.md`. If it's wrapper-shaped (every change backs onto an existing CLI/API/handler), mechanical (rename, move, reformat), or scoped to a single agent-cycle of work, yield directly to implementation and let the implement agent work from `strategy.md` plus what phase N taught you. Reserve the plan cycle for phases where the *how* is genuinely open.
+
+After a phase's implementation passes e2e validation, yield for the next phase — pick the mode that matches its shape:
 
 ```bash
+# Phase N+1 needs planning (default):
 sis orch yield --mode planning --prompt "Phase N validated. Plan phase N+1 per strategy.md."
+
+# Phase N+1 is wrapper-shaped or single-cycle:
+sis orch yield --mode implementation --prompt "Phase N validated. Implement phase N+1 per strategy.md."
 ```
 
 When spawning the phase-scoped plan lead, name in the prompt:

package/dist/tui.js

@@ -1217,7 +1217,7 @@ function autoExpandCycle(state2) {
 
 // src/tui/app.ts
 import { readFileSync as readFileSync15, existsSync as existsSync10, readdirSync as readdirSync7, statSync as statSync4 } from "fs";
-import { join as join14 } from "path";
+import { join as join15 } from "path";
 
 // src/tui/input.ts
 import { execSync } from "child_process";
@@ -3239,7 +3239,7 @@ function renderHelpOverlay(buf, rows, cols) {
     helpRow("  r  re-run agent", "  g  edit goal", innerWidth),
     helpRow("  p  open roadmap", "  S  edit strategy", innerWidth),
     helpRow("  w  go to window", "  o  resume claude", innerWidth),
-    helpRow("  c  claude companion", "  q  quit", innerWidth),
+    helpRow("  c  side claude pane", "  q  quit", innerWidth),
     " ".padEnd(innerWidth),
     // Leader direct keys (top-level space-key)
     helpRow("  space s  cycle session", "  space h  home/dashboard", innerWidth),
@@ -3248,10 +3248,12 @@ function renderHelpOverlay(buf, rows, cols) {
     helpRow("  space x  kill pane", "  space /  search", innerWidth),
     helpRow("  space ?  help", "  space 1-9  jump to session", innerWidth),
     " ".padEnd(innerWidth),
+    // Direct top-level leader keys
+    helpRow("  space c  side claude pane", "  space y \u203A  Yank", innerWidth),
     // Submenu prefixes
-    helpRow("  space c \u203A  Copy", "  space o \u203A  Open", innerWidth),
-    helpRow("  space a \u203A  Agent", "  space S \u203A  Session", innerWidth),
-    helpRow("  space g \u203A  Go", "", innerWidth),
+    helpRow("  space o \u203A  Open", "  space a \u203A  Agent", innerWidth),
+    helpRow("  space S \u203A  Session", "  space g \u203A  Go", innerWidth),
+    helpRow("  space C \u203A  Companion", "", innerWidth),
     " ".padEnd(innerWidth),
     ansiDim("  Changed: space a \u2192 space a s (spawn agent)".padEnd(innerWidth))
   ];
@@ -3896,7 +3898,8 @@ var KEYMAP = {
       { key: "/", label: "  Search / filter", action: { type: "script", name: "sisyphus-search-reports" }, tuiAction: "search" },
       { key: " ", label: "  Open popup explicitly", action: { type: "tui", action: "show-leader" } },
       { key: "y", label: "  Yank \u203A", action: { type: "submenu", ref: "copy" } },
-      { key: "c", label: "  Companion \u203A", action: { type: "submenu", ref: "companion" } },
+      { key: "c", label: "  Side claude pane", action: { type: "script", name: "sisyphus-companion-pane" }, tuiAction: "companion-pane" },
+      { key: "C", label: "  Companion (gamification) \u203A", action: { type: "submenu", ref: "companion" } },
       { key: "o", label: "  Open \u203A", action: { type: "submenu", ref: "open" } },
       { key: "a", label: "  Agent \u203A", action: { type: "submenu", ref: "agent" } },
       { key: "S", label: "  Session \u203A", action: { type: "submenu", ref: "session" } },
@@ -3908,8 +3911,7 @@ var KEYMAP = {
       title: " Companion ",
       items: [
         { key: "p", label: "  profile (overlay)", action: { type: "tui", action: "companion-overlay" } },
-        { key: "d", label: "  debug (mood signals)", action: { type: "tui", action: "companion-debug" } },
-        { key: "t", label: "  open in tmux pane", action: { type: "tui", action: "companion-pane" } }
+        { key: "d", label: "  debug (mood signals)", action: { type: "tui", action: "companion-debug" } }
       ]
     },
     copy: {
@@ -5540,7 +5542,6 @@ function registerDashboardWindow(cwd2) {
     }
   }
 }
-var companionPaneId = null;
 function setupCompanionPlugin() {
   const srcDir = join12(import.meta.dirname, "templates", "companion-plugin");
   const destDir = join12(globalDir(), "companion-plugin");
@@ -5551,9 +5552,23 @@ function setupCompanionPlugin() {
 function paneExists(paneId) {
   return execSafe(`tmux display-message -t ${shellQuote(paneId)} -p "#{pane_id}"`) !== null;
 }
+function findCompanionPaneForCwd(normalizedCwd) {
+  const out = execSafe(`tmux list-panes -aF "#{pane_id}	#{@sisyphus_companion}"`);
+  if (!out) return null;
+  for (const line of out.split("\n")) {
+    const tabIdx = line.indexOf("	");
+    if (tabIdx < 0) continue;
+    const paneId = line.slice(0, tabIdx);
+    const marker = line.slice(tabIdx + 1);
+    if (paneId && marker === normalizedCwd) return paneId;
+  }
+  return null;
+}
 function openCompanionPane(cwd2) {
-  if (companionPaneId && paneExists(companionPaneId)) {
-    execSafe(`tmux select-pane -t ${shellQuote(companionPaneId)}`);
+  const normalizedCwd = cwd2.replace(/\/+$/, "");
+  const existing = findCompanionPaneForCwd(normalizedCwd);
+  if (existing) {
+    execSafe(`tmux select-pane -t ${shellQuote(existing)}`);
     return;
   }
   const pluginDir = setupCompanionPlugin();
@@ -5572,9 +5587,12 @@ Run \`sis list\` and \`sis status\` to see current state.`;
   const pathEnv = augmentedPath();
   const claudeCmd = `SISYPHUS_COMPANION_CWD=${shellQuote(cwd2)} PATH=${shellQuote(pathEnv)} claude --dangerously-skip-permissions --plugin-dir ${shellQuote(pluginDir)} --append-system-prompt "$(cat ${shellQuote(promptPath)})"`;
   const result = exec(
-    `tmux split-window -h -d -l 33% -P -F "#{pane_id}" -c ${shellQuote(cwd2)} ${shellQuote(claudeCmd)}`
+    `tmux split-window -h -l 33% -P -F "#{pane_id}" -c ${shellQuote(cwd2)} ${shellQuote(claudeCmd)}`
   );
-  companionPaneId = result.trim() || null;
+  const newPaneId = result.trim();
+  if (newPaneId) {
+    execSafe(`tmux set-option -p -t ${shellQuote(newPaneId)} @sisyphus_companion ${shellQuote(normalizedCwd)}`);
+  }
 }
 var TERMINAL_EDITORS = /* @__PURE__ */ new Set(["nvim", "vim", "vi", "nano", "emacs", "micro", "helix", "hx", "joe", "ne", "kak"]);
 function switchToSession(sessionName) {
@@ -8247,9 +8265,14 @@ init_paths();
 // src/tui/lib/popup-compose.ts
 init_shell();
 import { execSync as execSync5 } from "child_process";
-import { mkdtempSync as mkdtempSync2, mkdirSync as mkdirSync9, writeFileSync as writeFileSync10, readFileSync as readFileSync14, rmSync as rmSync5, existsSync as existsSync9, cpSync as cpSync3 } from "fs";
+import { mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync10, readFileSync as readFileSync14, rmSync as rmSync5 } from "fs";
+import { join as join14 } from "path";
+import { tmpdir as tmpdir2 } from "os";
+
+// src/shared/sisyphus-init-lua.ts
+import { mkdirSync as mkdirSync9, existsSync as existsSync9, cpSync as cpSync3 } from "fs";
 import { join as join13 } from "path";
-import { tmpdir as tmpdir2, homedir as homedir4 } from "os";
+import { homedir as homedir4 } from "os";
 var initLuaEnsured = false;
 function ensureSisyphusInitLua() {
   if (initLuaEnsured) return;
@@ -8264,9 +8287,11 @@ function ensureSisyphusInitLua() {
   } catch {
   }
 }
+
+// src/tui/lib/popup-compose.ts
 function composeViaPopup(action, state2, actions) {
-  const tmpDir = mkdtempSync2(join13(tmpdir2(), "sisyphus-popup-"));
-  const tempFile = join13(tmpDir, "compose.md");
+  const tmpDir = mkdtempSync2(join14(tmpdir2(), "sisyphus-popup-"));
+  const tempFile = join14(tmpDir, "compose.md");
   try {
     writeFileSync10(tempFile, "", "utf-8");
     const cmd = `NVIM_APPNAME=sisyphus nvim ${shellQuote(tempFile)}`;
@@ -8448,7 +8473,7 @@ function startApp(state2, cleanup2) {
           } catch {
           }
           try {
-            const cp = join14(contextDir(state2.cwd, state2.selectedSessionId), "completion-summary.md");
+            const cp = join15(contextDir(state2.cwd, state2.selectedSessionId), "completion-summary.md");
             if (existsSync10(cp)) {
               completionSummaryContent = readFileSync15(cp, "utf-8");
             }
@@ -8467,7 +8492,7 @@ function startApp(state2, cleanup2) {
                 if (!fileSet.has(key)) cachedLogFiles.delete(key);
               }
               for (const f of files) {
-                const filePath = join14(ld, f);
+                const filePath = join15(ld, f);
                 const mtime = statSync4(filePath).mtimeMs;
                 const cached = cachedLogFiles.get(f);
                 if (!cached || cached.mtime !== mtime) {
@@ -8493,7 +8518,7 @@ function startApp(state2, cleanup2) {
               for (const e of entries) {
                 if (e.isDirectory()) {
                   try {
-                    const sub = readdirSync7(join14(cd, e.name)).filter((f) => !f.startsWith(".")).map((f) => `${e.name}/${f}`);
+                    const sub = readdirSync7(join15(cd, e.name)).filter((f) => !f.startsWith(".")).map((f) => `${e.name}/${f}`);
                     flat.push(...sub);
                   } catch {
                   }