otacon 0.1.0

package/dist/cli/commands/wait.js

@@ -0,0 +1,66 @@
+// otacon wait [--timeout 540] [--session id] — the parked wait (DESIGN.md §6):
+// long-poll the session's queue and print exactly one event as JSON, exit 0
+// ({"event":"timeout"} included — re-parking is the agent's normal loop).
+//
+// The deadline is fixed once at entry; each iteration re-ensures the daemon
+// (a cheap health probe when it is up, a respawn + handshake after a crash)
+// and parks for min(remaining, 240s). A connection failure mid-park therefore
+// re-parks transparently until the overall deadline — a daemon restart is
+// invisible to the agent. The 240s slice stays under undici's 300s
+// response-headers timeout (DECISIONS.md "wait parks in slices").
+import { parseArgs } from "node:util";
+import { api, ensureDaemon, sleep } from "../client.js";
+import { CliError, fail, printJson, usageError } from "../output.js";
+import { listSessions, realpathOr, resolveSession } from "../session.js";
+const MAX_PARK_SECONDS = 240;
+const RESPONSE_GRACE_MS = 10_000;
+const RETRY_DELAY_MS = 250;
+export async function waitCommand(argv) {
+    const { values } = parseArgs({
+        args: argv,
+        options: { timeout: { type: "string", default: "540" }, session: { type: "string" } },
+    });
+    const timeoutSeconds = Number(values.timeout);
+    if (!Number.isFinite(timeoutSeconds) || timeoutSeconds <= 0) {
+        usageError("--timeout must be a positive number of seconds");
+    }
+    await ensureDaemon();
+    const session = resolveSession(await listSessions(), values.session, realpathOr(process.cwd()));
+    const deadline = Date.now() + timeoutSeconds * 1000;
+    for (;;) {
+        const remainingMs = deadline - Date.now();
+        if (remainingMs <= 0)
+            break;
+        try {
+            await ensureDaemon();
+            const parkSeconds = Math.min(Math.ceil(remainingMs / 1000), MAX_PARK_SECONDS);
+            const response = await api("GET", `/api/sessions/${session.id}/events?wait=${parkSeconds}`, undefined, 
+            // Guard a wedged connection; generous because the daemon owns the clock.
+            AbortSignal.timeout(Math.min(remainingMs, parkSeconds * 1000) + RESPONSE_GRACE_MS));
+            if (response.status === 404) {
+                fail("E_UNKNOWN_SESSION", `daemon no longer knows session ${session.id}: ${JSON.stringify(response.body)}`);
+            }
+            if (response.status !== 200) {
+                // A daemon 500 is not "unknown session" — surface it as what it is.
+                fail("E_INTERNAL", `wait failed: ${JSON.stringify(response.body)}`, undefined, 2);
+            }
+            if (response.body.event === "timeout")
+                continue; // re-park
+            printJson(response.body);
+            return 0;
+        }
+        catch (error) {
+            // Only a dead/wedged connection (daemon killed or restarting) is
+            // retryable: back off, then the loop re-ensures the daemon and re-parks
+            // (queued events survive on disk). Everything else — ensureDaemon
+            // refusals, 404s, programming errors — propagates instead of being
+            // silently retried until the deadline.
+            if (!(error instanceof CliError) || error.code !== "E_DAEMON_DOWN")
+                throw error;
+            await sleep(RETRY_DELAY_MS);
+        }
+    }
+    printJson({ event: "timeout" });
+    return 0;
+}
+//# sourceMappingURL=wait.js.map

package/dist/cli/commands/wait.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"wait.js","sourceRoot":"","sources":["../../../src/cli/commands/wait.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,4EAA4E;AAC5E,0EAA0E;AAC1E,EAAE;AACF,4EAA4E;AAC5E,4EAA4E;AAC5E,8EAA8E;AAC9E,0EAA0E;AAC1E,mEAAmE;AACnE,kEAAkE;AAElE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAC;AACtC,OAAO,EAAE,GAAG,EAAE,YAAY,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACxD,OAAO,EAAE,QAAQ,EAAE,IAAI,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AACrE,OAAO,EAAE,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AAEzE,MAAM,gBAAgB,GAAG,GAAG,CAAC;AAC7B,MAAM,iBAAiB,GAAG,MAAM,CAAC;AACjC,MAAM,cAAc,GAAG,GAAG,CAAC;AAE3B,MAAM,CAAC,KAAK,UAAU,WAAW,CAAC,IAAc;IAC9C,MAAM,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;QAC3B,IAAI,EAAE,IAAI;QACV,OAAO,EAAE,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,KAAK,EAAE,EAAE,OAAO,EAAE,EAAE,IAAI,EAAE,QAAQ,EAAE,EAAE;KACtF,CAAC,CAAC;IACH,MAAM,cAAc,GAAG,MAAM,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC;IAC9C,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,cAAc,CAAC,IAAI,cAAc,IAAI,CAAC,EAAE,CAAC;QAC5D,UAAU,CAAC,gDAAgD,CAAC,CAAC;IAC/D,CAAC;IAED,MAAM,YAAY,EAAE,CAAC;IACrB,MAAM,OAAO,GAAG,cAAc,CAAC,MAAM,YAAY,EAAE,EAAE,MAAM,CAAC,OAAO,EAAE,UAAU,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC;IAEhG,MAAM,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,GAAG,cAAc,GAAG,IAAI,CAAC;IACpD,SAAS,CAAC;QACR,MAAM,WAAW,GAAG,QAAQ,GAAG,IAAI,CAAC,GAAG,EAAE,CAAC;QAC1C,IAAI,WAAW,IAAI,CAAC;YAAE,MAAM;QAC5B,IAAI,CAAC;YACH,MAAM,YAAY,EAAE,CAAC;YACrB,MAAM,WAAW,GAAG,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,WAAW,GAAG,IAAI,CAAC,EAAE,gBAAgB,CAAC,CAAC;YAC9E,MAAM,QAAQ,GAAG,MAAM,GAAG,CACxB,KAAK,EACL,iBAAiB,OAAO,CAAC,EAAE,gBAAgB,WAAW,EAAE,EACxD,SAAS;YACT,yEAAyE;YACzE,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,WAAW,EAAE,WAAW,GAAG,IAAI,CAAC,GAAG,iBAAiB,CAAC,CACnF,CAAC;YACF,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;gBAC5B,IAAI,CACF,mBAAmB,EACnB,kCAAkC,OAAO,CAAC,EAAE,KAAK,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,CACjF,CAAC;YACJ,CAAC;YACD,IAAI,QAAQ,CAAC,MAAM,KAAK,GAAG,EAAE,CAAC;gBAC5B,oEAAoE;gBACpE,IAAI,CAAC,YAAY,EAAE,gBAAgB,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC;YACpF,CAAC;YACD,IAAK,QAAQ,CAAC,IAA2B,CAAC,KAAK,KAAK,SAAS;gBAAE,SAAS,CAAC,UAAU;YACnF,SAAS,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;YACzB,OAAO,CAAC,CAAC;QACX,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,iEAAiE;YACjE,wEAAwE;YACxE,kEAAkE;YAClE,mEAAmE;YACnE,uCAAuC;YACvC,IAAI,CAAC,CAAC,KAAK,YAAY,QAAQ,CAAC,IAAI,KAAK,CAAC,IAAI,KAAK,eAAe;gBAAE,MAAM,KAAK,CAAC;YAChF,MAAM,KAAK,CAAC,cAAc,CAAC,CAAC;QAC9B,CAAC;IACH,CAAC;IACD,SAAS,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,CAAC,CAAC;IAChC,OAAO,CAAC,CAAC;AACX,CAAC"}

package/dist/cli/install/assets.js

@@ -0,0 +1,285 @@
+// The wrapper content `otacon install` writes (DESIGN.md §16) — this is the
+// product-critical text that teaches an agent the whole protocol: the §6 full
+// loop, §8 grill discipline, and §13 "never end your turn". One protocol card,
+// three destinations: Claude Code and OpenCode get it as a SKILL.md; Codex gets
+// it as a marker-delimited block inside its shared ~/.codex/AGENTS.md. Plus the
+// Stop hook shell script (§13). Wrappers are managed files: reinstall
+// overwrites them wholesale (DECISIONS.md "Wrappers are managed files").
+/** Present in every wrapper this tool owns; doctor greps for it. */
+export const MANAGED_MARKER = 'managed by `otacon install`';
+export const CODEX_BEGIN = '<!-- BEGIN OTACON — managed by `otacon install`; content inside these markers is overwritten on reinstall -->';
+export const CODEX_END = '<!-- END OTACON -->';
+/**
+ * The protocol card — §6 full loop (start-first) + §8 grill discipline + §13
+ * failure habits — parametrized by the command prefix so one source feeds both
+ * wrappers (D7): `otacon` for what `otacon install` writes into any repo,
+ * `./bin/otacon` for this repo's dogfood (run-from-source). The only thing that
+ * varies between the two is `cmd`; the protocol text is identical, so a change
+ * here lands in both at once.
+ */
+function protocolCard(cmd) {
+    return `Run plan reviews through the otacon CLI instead of your native plan mode. The
+user reviews in a browser. Every \`${cmd}\`
+command prints exactly one JSON line on stdout. Exit 0 = proceed; exit 1 = a
+machine-readable error you can fix (read the JSON); exit 2 = you invoked it wrong.
+
+## The loop
+
+1. \`${cmd} start --title <kebab-title>\` **first, before you research** — it mints
+   the session and prints the review URL. Tell the user to open it (\`${cmd} open\`
+   prints it again) so they can watch the whole thing from the first second.
+   \`--quick\` skips the interview — only when the user explicitly asks.
+2. **Research the codebase**, narrating as you go with
+   \`${cmd} progress "<what you're doing>"\` — call it whenever you start a chunk of
+   work the user can't otherwise see (reading a module, drafting, revising). It is
+   a non-blocking one-liner that feeds the live activity log and the draft chip; no
+   answer comes back, so never park on it. Read enough to propose answers, not
+   collect questions.
+3. **Grill** (mandatory unless --quick): Interview me relentlessly about every
+   aspect of this plan until we reach a shared understanding. Walk down each branch
+   of the design tree, resolving dependencies between decisions one-by-one. For
+   each question, provide your recommended answer. Explore the code before asking.
+   Never ask what the code can answer.
+   - \`${cmd} ask --question "..." --options "A|B|C" --recommend A\` — always lead
+     with your recommended answer. \`--multi\` for multi-select; omit \`--options\`
+     for free text. The user can always answer with free-form custom text instead
+     of (or alongside) the chips, so frame options as a starting point, not a cage.
+   - Independent questions whose answers don't shape each other? Post them in one
+     call: \`${cmd} ask --batch questions.json\` (or \`--batch -\` for stdin) — a JSON
+     array of the same specs (\`{question, options?, recommend?, multi?}\`). They land
+     as ordinary cards; loop \`wait\` to collect each answer. Dependent questions
+     still go one at a time.
+   - Park for the answer: \`${cmd} wait --timeout 540\` (set the Bash tool timeout
+     to 600000 ms). The answer arrives as \`{"event":"answer","question":"q<n>",...}\`.
+4. **Draft** the plan at \`.otacon/<session>/plan.md\` in the schema below, then
+   \`${cmd} submit\`. On exit 1, fix every reported lint issue and resubmit until
+   accepted.
+5. **Review loop** — park in \`${cmd} wait --timeout 540\` (Bash timeout 600000 ms)
+   and handle the one event it prints:
+   - \`comments\` → revise plan.md; write \`resolutions.json\` as
+     \`{"changelog":"what changed","threads":{"t1":"how you resolved it"}}\` with
+     one reply per comment thread; \`${cmd} submit --resolutions resolutions.json\`
+     (loop on lint errors); park again.
+   - \`question\` → \`${cmd} answer <q-id> --body "..."\` (or \`--file\`); park again. A
+     \`question\` may carry \`replyTo\` (a follow-up on an earlier question) — skim that
+     thread's prior turns for context, but still answer the new \`q<n>\`.
+   - \`answer\` → use it and continue; park again whenever you are waiting.
+   - \`timeout\` → park again immediately. A timeout is NEVER completion.
+   - \`approved\` → \`git add\` + commit the plan file at the printed \`path\`. Plain
+     \`approved\` (no \`implement\`) → print a one-line summary and STOP. \`approved\`
+     **with \`implement:true\`** → after committing, enter the **Implement loop**
+     (below) — do NOT stop; the session is now \`implementing\`.
+   - \`deleted\` → the user deleted this session in the review UI. It is over:
+     STOP. There is no approved plan and nothing to commit.
+6. **Never end your turn while the session is open.** Nothing to do = park in
+   \`${cmd} wait\` again. Confused, crashed, or compacted? \`${cmd} status\` returns
+   the open session, revision, and pending events — resume the loop from it.
+
+## CLI quick reference
+
+- \`${cmd} start --title <t> [--quick]\` · \`${cmd} progress "<note>"\` ·
+  \`${cmd} ask ...\` · \`${cmd} wait --timeout 540\` · \`${cmd} submit [--resolutions f]\` ·
+  \`${cmd} answer <q> --body "..."\` · \`${cmd} implement-done [--pr <url>] [--failed]\` ·
+  \`${cmd} status\` · \`${cmd} open\`
+
+## Implement loop (on \`approved\` with \`implement:true\`)
+
+You are the **orchestrator**: you only coordinate and narrate
+(\`${cmd} progress\` at each checkpoint) — every phase's real work runs in a fresh
+native subagent (Task tool) so your own context stays lean.
+
+1. **Setup.** Commit the plan file at the event \`path\` (exactly as plain Approve),
+   then \`git worktree add .otacon/worktrees/<slug> -b otacon/impl-<slug>\` off that
+   commit (\`.otacon/\` is gitignored). \`${cmd} progress\` each checkpoint throughout.
+2. **Per phase, in order** (read the phases from the committed plan):
+   - \`${cmd} progress "phase N — implementing"\`; spawn an **implement+test**
+     subagent (Task tool) scoped to that phase's Goal/Files/Verification — it
+     implements and runs the phase Verification plus the repo gates.
+   - spawn a **separate** \`/code-review --fix\` subagent on the phase's working
+     diff; it applies findings; re-review. (\`/code-review\` effort is config — start
+     moderate so false positives don't become needless pauses.)
+   - **clean + green** → commit the phase and continue. **Blocked** (tests stay red,
+     review still flags, or a subagent is stuck) → on the FIRST blocker,
+     \`${cmd} ask\` with options \`retry|skip|abort|guidance\`, park in \`${cmd} wait\`,
+     and act on the answer. No auto-retry.
+3. **Finish.** On success, \`git mv\` the committed plan (the \`approved\` event's
+   \`path\`) into \`docs/plans/archive/\` and commit it on the impl branch, so the
+   archived plan rides along in the PR (it only takes effect on the default branch
+   when the PR merges). Then \`gh pr create\` against the default branch (PR body =
+   the plan summary + the per-phase log; fall back to the local branch + path when
+   there is no remote), then \`${cmd} implement-done --pr <url>\`. On abort, skip the
+   archive move (leave the plan in \`docs/plans/\` so it stays active) and run
+   \`${cmd} implement-done --failed\`.
+
+While \`implementing\` the Stop hook still keeps you on the line — never end the turn
+until \`implement-done\`.
+
+## Plan schema (linted on submit)
+
+Frontmatter (\`title\`, \`session\`, \`revision\`, \`status\`, \`created\`), then these
+H2 sections in order — the five required ones plus optional review-altitude
+sections slotted in place (include them when the change warrants; skip them on
+trivial plans): \`## Summary\` (≤5 lines, lead with a diagram — see below) ·
+*(optional)* \`## Contract\` (≤12 lines —
+the interface surface the reviewer signs off instead of reading code: inputs,
+outputs, types, errors; one signature fence is fine under the 1-fence rule) ·
+\`## Decisions\` (entries ≤3 lines, \`- D<n>: ... ← q<n>\` citing the grill answer
+that produced it, or \`[assumed]\`) · *(optional)* \`## Impact\` (≤10 lines — blast
+radius: the upstream modules this plan leans on and the downstream modules it can
+break; a dependency mermaid is fine under the 1-fence rule) · \`## Phases\`
+(\`### Phase <n> — <name>\`, each with \`Goal:\` ≤3 lines, \`Files:\` list,
+\`Verification:\` ≤3 lines plus an optional \`\`\`gwt scenario block — see below,
+optional collapsible \`#### Details\` block) ·
+\`## Risks\` (≤5 items, ≤2 lines each) ·
+\`## Open Questions\`. Mermaid / code / \`before\`+\`after\` fences are budget-exempt,
+max one per read-path section; the markdown-native review visuals below share a
+separate per-section cap. Details may elaborate on the read path, never
+introduce new scope.
+
+**Lead with a diagram.** Put a \`\`\`mermaid state / sequence / flow diagram right
+under the \`## Summary\` headline — strongly recommended on ~90% of plans, so the
+reviewer grasps the change's shape before reading prose. Keep the headline as the ≤5-line
+Summary.
+
+## Visuals — prefer them over prose where they carry the information
+
+Four markdown-native primitives the review UI styles. They degrade to readable
+markdown if rendering fails, and a comment can anchor to one specific risk, row,
+or callout.
+
+- **Callouts** — a blockquote whose first line is a type marker
+  (\`[!risk]\`, \`[!note]\`, \`[!decision]\`, \`[!assumption]\`). Risks and
+  assumptions SHOULD be callouts, not bullets buried in prose:
+  > [!risk]
+  > The JWT cutover locks out sessions issued before it.
+- **Decision matrix** — a GFM table comparing options, the chosen row led by a
+  \`✓\`. A Decisions section weighing 2+ options SHOULD use a matrix:
+  | Pick | Option | Tradeoff                        |
+  | ---- | ------ | ------------------------------- |
+  | ✓    | RS256  | rotate keys without redeploy    |
+  |      | HS256  | shared secret on every verifier |
+- **Scope pills** — inline tags \`[new]\` \`[breaking]\` \`[risky]\` \`[deletes]\`
+  for flagging scope mid-sentence ("adds a [new] issuer; [breaking] cookie removal").
+- **Behavioral assertions** — a \`\`\`gwt fence inside a phase's \`Verification\`
+  holding one or more Given/When/Then scenarios (blank line between scenarios;
+  \`And\`/\`But\` continue a clause). They render as scenario cards that double as
+  the human's approve checklist (Test-Driven Review), so write the observable
+  behavior the reviewer signs off, not the test code:
+  \`\`\`gwt
+  Given a plan with no Contract section
+  When the agent submits it
+  Then the lint passes and review opens
+  \`\`\`
+  Capped at 6 scenarios per block; must sit under \`Verification\`.
+
+Callouts and matrices are budget-exempt but capped (default 2 per read-path
+section); pills are free. Reach for a visual when it carries the point better
+than a sentence — never as decoration.
+
+## Rules
+
+- Never use native plan mode, AskUserQuestion, or any built-in question UI while
+  the session is open — every question goes through \`${cmd} ask\`.
+- Long review or build ahead? Remind the user to keep the Mac awake: \`caffeinate -i\`
+  while the session runs.
+`;
+}
+/** ~/.claude/skills/otacon/SKILL.md and the OpenCode equivalent (same format). */
+export function skillMd() {
+    return `---
+name: otacon
+description: Plan a feature through an otacon review session — grill interview, schema'd plan, phone review with anchored comments, approved committed artifact. Use when the user asks to plan something with otacon, types /otacon, or wants a reviewed implementation plan before coding. Replaces native plan mode.
+---
+
+<!-- ${MANAGED_MARKER} — reinstall overwrites this file; the spec lives in otacon's DESIGN.md -->
+
+# Otacon plan session protocol
+
+${protocolCard('otacon')}`;
+}
+/** The marker-delimited block upserted into ~/.codex/AGENTS.md. */
+export function codexBlock() {
+    return `${CODEX_BEGIN}
+
+# Otacon plan sessions
+
+When the user asks you to plan a feature "with otacon" (or to run a plan
+review), follow this protocol exactly.
+
+${protocolCard('otacon')}
+${CODEX_END}`;
+}
+/**
+ * THIS repo's dogfood wrapper — the committed \`.claude/skills/otacon/SKILL.md\`
+ * (DESIGN.md §16). It is the same protocol card as \`skillMd()\`, but with the
+ * \`./bin/otacon\` run-from-source command prefix and a repo preamble (run from
+ * source, restart after daemon edits). Generated from this function and never
+ * hand-edited; \`assets.test.ts\` asserts the committed file equals this output,
+ * so a protocol change that updates the card but forgets to regenerate the
+ * dogfood file fails CI (D7).
+ */
+export function dogfoodSkillMd() {
+    return `---
+name: otacon
+description: Plan a feature for THIS repo through an otacon review session — grill interview, schema'd plan, browser/phone review with anchored comments, approved committed artifact. Use when the user asks to plan something with otacon, types /otacon, or wants a reviewed implementation plan before coding. Replaces native plan mode. Dogfoods otacon on its own development.
+---
+
+<!-- Generated from src/cli/install/assets.ts (dogfoodSkillMd) — do NOT hand-edit;
+     assets.test.ts guards that this file equals that output. Regenerate after any
+     protocol change. -->
+
+# Otacon plan session protocol (dogfooding this repo)
+
+This repo **is** otacon. You plan features for it by running otacon's own CLI from
+source via the \`./bin/otacon\` shim, so every command below exercises the code in
+this checkout. That shim runs the CLI from \`src/\` via bun — no build needed; it
+always reflects current source. The daemon auto-spawns from source on the first
+command. Working state lives in the gitignored \`.otacon/\`; the approved plan is
+committed to \`docs/plans/\`.
+
+After editing **daemon** source (\`src/daemon/**\`) mid-session, restart the running
+daemon so your change loads: \`./bin/otacon restart\` (the next command respawns it
+from current source). Use \`./bin/otacon restart\`, not a raw curl to a fixed port —
+in a git worktree the shim runs the daemon on a derived port, and \`restart\` always
+targets the one this checkout talks to. CLI/linter/parser edits need no restart.
+
+The spec these commands implement is otacon's own DESIGN.md (§6 loop, §8 grill, §13
+failure habits); the canonical wrapper text lives in \`src/cli/install/assets.ts\`.
+
+---
+
+${protocolCard('./bin/otacon')}`;
+}
+/**
+ * The Claude Code Stop hook (DESIGN.md §13): blocks ending the turn while an
+ * open otacon session exists in the cwd's repo. Plain sh, fast, fail-open —
+ * any failure (daemon down, curl missing, no match) allows the stop. With no
+ * local pointer, the open session is found by scanning the daemon registry for
+ * a non-terminal session whose repo equals the cwd's git root (DESIGN.md §7) —
+ * `implementing` still blocks (the build is live); only the terminal states
+ * (approved/implemented/implement_failed) let the agent end its turn.
+ */
+export const STOP_HOOK_SCRIPT = `#!/bin/sh
+# otacon Stop hook — ${MANAGED_MARKER}; reinstall overwrites this file.
+# Blocks Claude Code from ending its turn while the cwd's repo has an open
+# otacon plan session (DESIGN.md §13). Fail-open by design: when anything here
+# fails (daemon unreachable, curl missing, no match), the stop is allowed.
+input=$(cat 2>/dev/null) || input=""
+cwd=$(printf '%s' "$input" | sed -n 's/.*"cwd"[[:space:]]*:[[:space:]]*"\\([^"]*\\)".*/\\1/p')
+[ -n "$cwd" ] || cwd=$PWD
+root=$(git -C "$cwd" rev-parse --show-toplevel 2>/dev/null) || root=$cwd
+root=$(cd "$root" 2>/dev/null && pwd -P) || exit 0
+port=\${OTACON_PORT:-4747}
+list=$(curl -fsS --max-time 2 "http://127.0.0.1:$port/api/sessions" 2>/dev/null) || exit 0
+# Split the compact registry array one session-object per line, keep this repo's
+# open (non-terminal) sessions, take the first id. The repo match is exact: the
+# pattern includes the closing quote of the JSON value. Terminal statuses
+# (approved/implemented/implement_failed) are over -- drop them so a finished
+# build no longer traps the agent, while an in-flight implementing still blocks.
+sid=$(printf '%s' "$list" | sed 's/},{/}\\
+{/g' | grep -F "\\"repo\\":\\"$root\\"" | grep -vE '"status":"(approved|implemented|implement_failed)"' | sed -n '1s/.*"id":"\\([^"]*\\)".*/\\1/p')
+[ -n "$sid" ] || exit 0
+printf '{"decision":"block","reason":"otacon plan session %s is still open — run otacon wait --timeout 540 (Bash timeout 600000 ms) and keep handling events until the plan is approved; run otacon status to re-orient."}\\n' "$sid"
+exit 0
+`;
+//# sourceMappingURL=assets.js.map

package/dist/cli/install/assets.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"assets.js","sourceRoot":"","sources":["../../../src/cli/install/assets.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,8EAA8E;AAC9E,+EAA+E;AAC/E,gFAAgF;AAChF,gFAAgF;AAChF,sEAAsE;AACtE,yEAAyE;AAEzE,oEAAoE;AACpE,MAAM,CAAC,MAAM,cAAc,GAAG,6BAA6B,CAAC;AAE5D,MAAM,CAAC,MAAM,WAAW,GACtB,+GAA+G,CAAC;AAClH,MAAM,CAAC,MAAM,SAAS,GAAG,qBAAqB,CAAC;AAE/C;;;;;;;GAOG;AACH,SAAS,YAAY,CAAC,GAAW;IAC/B,OAAO;qCAC4B,GAAG;;;;;;OAMjC,GAAG;wEAC8D,GAAG;;;;OAIpE,GAAG;;;;;;;;;;SAUD,GAAG;;;;;eAKG,GAAG;;;;8BAIY,GAAG;;;OAG1B,GAAG;;iCAEuB,GAAG;;;;uCAIG,GAAG;;wBAElB,GAAG;;;;;;;;;;;;OAYpB,GAAG,qDAAqD,GAAG;;;;;MAK5D,GAAG,sCAAsC,GAAG;MAC5C,GAAG,kBAAkB,GAAG,6BAA6B,GAAG;MACxD,GAAG,kCAAkC,GAAG;MACxC,GAAG,iBAAiB,GAAG;;;;;KAKxB,GAAG;;;;;4CAKoC,GAAG;;SAEtC,GAAG;;;;;;;;SAQH,GAAG,gEAAgE,GAAG;;;;;;;iCAO9C,GAAG;;OAE7B,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;wDAsE8C,GAAG;;;CAG1D,CAAC;AACF,CAAC;AAED,kFAAkF;AAClF,MAAM,UAAU,OAAO;IACrB,OAAO;;;;;OAKF,cAAc;;;;EAInB,YAAY,CAAC,QAAQ,CAAC,EAAE,CAAC;AAC3B,CAAC;AAED,mEAAmE;AACnE,MAAM,UAAU,UAAU;IACxB,OAAO,GAAG,WAAW;;;;;;;EAOrB,YAAY,CAAC,QAAQ,CAAC;EACtB,SAAS,EAAE,CAAC;AACd,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,cAAc;IAC5B,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA6BP,YAAY,CAAC,cAAc,CAAC,EAAE,CAAC;AACjC,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,CAAC,MAAM,gBAAgB,GAAG;uBACT,cAAc;;;;;;;;;;;;;;;;;;;;;CAqBpC,CAAC"}

package/dist/cli/install/locations.js

@@ -0,0 +1,92 @@
+// Where each agent reads its wrapper from (DESIGN.md §16; DECISIONS.md
+// "Wrapper destinations per agent"), plus the merge/registration helpers
+// install and doctor share. homedir() honors $HOME, which is what keeps the
+// install e2e hermetic under a temp HOME.
+import { readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export function claudeSkillPath() {
+    return join(homedir(), ".claude", "skills", "otacon", "SKILL.md");
+}
+/** The Stop hook script install writes; settings.json references it by this path. */
+export function claudeHookScriptPath() {
+    return join(homedir(), ".claude", "hooks", "otacon-stop.sh");
+}
+export function claudeSettingsPath() {
+    return join(homedir(), ".claude", "settings.json");
+}
+/** Codex's global instructions file ($CODEX_HOME, default ~/.codex). */
+export function codexAgentsPath() {
+    return join(process.env.CODEX_HOME ?? join(homedir(), ".codex"), "AGENTS.md");
+}
+/** OpenCode's global skills dir ($XDG_CONFIG_HOME, default ~/.config). */
+export function opencodeSkillPath() {
+    return join(process.env.XDG_CONFIG_HOME ?? join(homedir(), ".config"), "opencode", "skills", "otacon", "SKILL.md");
+}
+/**
+ * Replace the marker-delimited block in `existing` with `block` (which carries
+ * its own begin/end lines), or append it when no markers are present. User
+ * content outside the markers survives byte-for-byte; re-running with the same
+ * block is a fixpoint (the idempotent-reinstall contract).
+ */
+export function upsertMarkedBlock(existing, block, begin, end) {
+    const from = existing.indexOf(begin);
+    const to = existing.indexOf(end);
+    if (from !== -1 && to !== -1 && to > from) {
+        return existing.slice(0, from) + block + existing.slice(to + end.length);
+    }
+    if (existing.trim() === "")
+        return `${block}\n`;
+    const separator = existing.endsWith("\n") ? "\n" : "\n\n";
+    return `${existing}${separator}${block}\n`;
+}
+/**
+ * Whether ~/.claude/settings.json currently registers the otacon Stop hook
+ * (install's offer path and doctor's check). Missing or unparseable settings
+ * read as "not registered" — only --hooks treats unparseable as an error.
+ */
+export function settingsRegisterStopHook() {
+    try {
+        const raw = JSON.parse(readFileSync(claudeSettingsPath(), "utf8"));
+        return stopHookRegistered(raw?.hooks?.Stop, claudeHookScriptPath());
+    }
+    catch {
+        return false;
+    }
+}
+/** True when some Stop matcher entry already runs `command`. */
+export function stopHookRegistered(stop, command) {
+    if (!Array.isArray(stop))
+        return false;
+    return stop.some((entry) => {
+        const hooks = entry?.hooks;
+        return (Array.isArray(hooks) &&
+            hooks.some((h) => h?.command === command));
+    });
+}
+/**
+ * Additively merge the Stop hook entry into a parsed settings.json: every
+ * existing key (and every existing Stop matcher) is preserved; an entry already
+ * running `command` makes this a no-op. Returns undefined when the existing
+ * structure has a shape we refuse to rewrite (hooks or hooks.Stop not
+ * object/array) — never clobber what we cannot faithfully merge.
+ */
+export function mergeStopHook(raw, command) {
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+        return undefined;
+    const settings = raw;
+    const hooks = settings.hooks ?? {};
+    if (hooks === null || typeof hooks !== "object" || Array.isArray(hooks))
+        return undefined;
+    const stop = hooks.Stop ?? [];
+    if (!Array.isArray(stop))
+        return undefined;
+    if (stopHookRegistered(stop, command))
+        return { settings, changed: false };
+    const entry = { matcher: "", hooks: [{ type: "command", command }] };
+    return {
+        settings: { ...settings, hooks: { ...hooks, Stop: [...stop, entry] } },
+        changed: true,
+    };
+}
+//# sourceMappingURL=locations.js.map

package/dist/cli/install/locations.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"locations.js","sourceRoot":"","sources":["../../../src/cli/install/locations.ts"],"names":[],"mappings":"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"}

package/dist/cli/install/tailscale.js

@@ -0,0 +1,39 @@
+// Best-effort Tailscale discovery shared by doctor and expose (DESIGN.md §11,
+// §16). OTACON_TAILSCALE pins the binary (hermetic tests; nonstandard
+// installs) and is authoritative when set; otherwise PATH, then the macOS app
+// bundle's embedded CLI (DECISIONS.md "doctor/expose automation boundary").
+import { execFileSync } from "node:child_process";
+const MAC_APP_BIN = "/Applications/Tailscale.app/Contents/MacOS/Tailscale";
+export function findTailscale() {
+    const override = process.env.OTACON_TAILSCALE;
+    const candidates = override !== undefined && override !== "" ? [override] : ["tailscale", MAC_APP_BIN];
+    for (const bin of candidates) {
+        try {
+            execFileSync(bin, ["version"], { stdio: ["ignore", "pipe", "ignore"] });
+            return bin;
+        }
+        catch {
+            // not this one
+        }
+    }
+    return undefined;
+}
+export function tailscaleStatus(bin) {
+    try {
+        const raw = JSON.parse(execFileSync(bin, ["status", "--json"], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "pipe"],
+        }));
+        const dns = raw?.Self?.DNSName;
+        return {
+            backendState: typeof raw?.BackendState === "string" ? raw.BackendState : "unknown",
+            ...(typeof dns === "string" && dns !== ""
+                ? { dnsName: dns.replace(/\.$/, "") }
+                : {}),
+        };
+    }
+    catch {
+        return undefined;
+    }
+}
+//# sourceMappingURL=tailscale.js.map

package/dist/cli/install/tailscale.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tailscale.js","sourceRoot":"","sources":["../../../src/cli/install/tailscale.ts"],"names":[],"mappings":"AAAA,8EAA8E;AAC9E,sEAAsE;AACtE,8EAA8E;AAC9E,4EAA4E;AAE5E,OAAO,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAElD,MAAM,WAAW,GAAG,sDAAsD,CAAC;AAE3E,MAAM,UAAU,aAAa;IAC3B,MAAM,QAAQ,GAAG,OAAO,CAAC,GAAG,CAAC,gBAAgB,CAAC;IAC9C,MAAM,UAAU,GAAG,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,EAAE,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,WAAW,CAAC,CAAC;IACvG,KAAK,MAAM,GAAG,IAAI,UAAU,EAAE,CAAC;QAC7B,IAAI,CAAC;YACH,YAAY,CAAC,GAAG,EAAE,CAAC,SAAS,CAAC,EAAE,EAAE,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,CAAC,CAAC;YACxE,OAAO,GAAG,CAAC;QACb,CAAC;QAAC,MAAM,CAAC;YACP,eAAe;QACjB,CAAC;IACH,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AASD,MAAM,UAAU,eAAe,CAAC,GAAW;IACzC,IAAI,CAAC;QACH,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CACpB,YAAY,CAAC,GAAG,EAAE,CAAC,QAAQ,EAAE,QAAQ,CAAC,EAAE;YACtC,QAAQ,EAAE,MAAM;YAChB,KAAK,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,CAAC;SAClC,CAAC,CACyD,CAAC;QAC9D,MAAM,GAAG,GAAG,GAAG,EAAE,IAAI,EAAE,OAAO,CAAC;QAC/B,OAAO;YACL,YAAY,EAAE,OAAO,GAAG,EAAE,YAAY,KAAK,QAAQ,CAAC,CAAC,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC,CAAC,SAAS;YAClF,GAAG,CAAC,OAAO,GAAG,KAAK,QAAQ,IAAI,GAAG,KAAK,EAAE;gBACvC,CAAC,CAAC,EAAE,OAAO,EAAE,GAAG,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,EAAE;gBACrC,CAAC,CAAC,EAAE,CAAC;SACR,CAAC;IACJ,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,SAAS,CAAC;IACnB,CAAC;AACH,CAAC"}

package/dist/cli/main.js

@@ -0,0 +1,73 @@
+#!/usr/bin/env node
+// otacon CLI dispatch (DESIGN.md §6). stdout carries exactly one JSON line per
+// invocation; notices go to stderr; exit 0 success / 1 expected failure /
+// 2 usage or internal error (src/cli/output.ts).
+import { answerCommand } from "./commands/answer.js";
+import { askCommand } from "./commands/ask.js";
+import { cleanCommand } from "./commands/clean.js";
+import { doctorCommand } from "./commands/doctor.js";
+import { exposeCommand } from "./commands/expose.js";
+import { implementDoneCommand } from "./commands/implement-done.js";
+import { installCommand } from "./commands/install.js";
+import { openCommand } from "./commands/open.js";
+import { progressCommand } from "./commands/progress.js";
+import { startCommand } from "./commands/start.js";
+import { statusCommand } from "./commands/status.js";
+import { submitCommand } from "./commands/submit.js";
+import { waitCommand } from "./commands/wait.js";
+import { CliError, printJson } from "./output.js";
+const USAGE = "usage: otacon <start|submit|wait|ask|answer|progress|implement-done|status|open|clean|install|doctor|expose> [options]";
+async function dispatch(command, argv) {
+    switch (command) {
+        case "start":
+            return startCommand(argv);
+        case "submit":
+            return submitCommand(argv);
+        case "wait":
+            return waitCommand(argv);
+        case "ask":
+            return askCommand(argv);
+        case "answer":
+            return answerCommand(argv);
+        case "progress":
+            return progressCommand(argv);
+        case "implement-done":
+            return implementDoneCommand(argv);
+        case "status":
+            return statusCommand(argv);
+        case "open":
+            return openCommand(argv);
+        case "clean":
+            return cleanCommand(argv);
+        case "install":
+            return installCommand(argv);
+        case "doctor":
+            return doctorCommand(argv);
+        case "expose":
+            return exposeCommand(argv);
+        default:
+            throw new CliError("E_USAGE", USAGE, 2);
+    }
+}
+const isParseArgsError = (error) => error instanceof Error &&
+    (error.code?.startsWith("ERR_PARSE_ARGS") ?? false);
+/** Exit only after queued stdout writes flush (stdout may be a pipe). */
+function exit(code) {
+    process.stdout.write("", () => process.exit(code));
+}
+dispatch(process.argv[2], process.argv.slice(3)).then((code) => exit(code), (error) => {
+    if (error instanceof CliError) {
+        printJson(error.toPayload());
+        exit(error.exitCode);
+    }
+    else if (isParseArgsError(error)) {
+        printJson({ ok: false, error: { code: "E_USAGE", message: `${error.message}; ${USAGE}` } });
+        exit(2);
+    }
+    else {
+        const message = error instanceof Error ? error.message : String(error);
+        printJson({ ok: false, error: { code: "E_INTERNAL", message } });
+        exit(2);
+    }
+});
+//# sourceMappingURL=main.js.map

package/dist/cli/main.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"main.js","sourceRoot":"","sources":["../../src/cli/main.ts"],"names":[],"mappings":"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"}

package/dist/cli/output.js

@@ -0,0 +1,39 @@
+// JSON-only stdout discipline for the otacon CLI (DESIGN.md §6): every command
+// prints exactly one JSON line on stdout — the machine-readable result a coding
+// agent parses as its Bash tool output — and human-facing notices go to stderr.
+//
+// Exit codes: 0 success (including {"event":"timeout"}, DESIGN.md §6), 1
+// expected failure the agent can act on (lint reject, ambiguous session, port
+// conflict), 2 usage or internal error.
+/** A machine-readable command failure; main.ts prints the payload and exits. */
+export class CliError extends Error {
+    code;
+    exitCode;
+    extra;
+    constructor(code, message, exitCode = 1, extra = {}) {
+        super(message);
+        this.code = code;
+        this.exitCode = exitCode;
+        this.extra = extra;
+        this.name = "CliError";
+    }
+    toPayload() {
+        return { ok: false, error: { code: this.code, message: this.message, ...this.extra } };
+    }
+}
+/** Throw an expected failure (exit 1 unless told otherwise). */
+export function fail(code, message, extra, exitCode = 1) {
+    throw new CliError(code, message, exitCode, extra);
+}
+export function usageError(message) {
+    throw new CliError("E_USAGE", message, 2);
+}
+/** The one stdout write a command makes. */
+export function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value)}\n`);
+}
+/** Human-facing notice; never stdout, which agents parse. */
+export function notice(message) {
+    process.stderr.write(`otacon: ${message}\n`);
+}
+//# sourceMappingURL=output.js.map

package/dist/cli/output.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"output.js","sourceRoot":"","sources":["../../src/cli/output.ts"],"names":[],"mappings":"AAAA,+EAA+E;AAC/E,gFAAgF;AAChF,gFAAgF;AAChF,EAAE;AACF,yEAAyE;AACzE,8EAA8E;AAC9E,wCAAwC;AAIxC,gFAAgF;AAChF,MAAM,OAAO,QAAS,SAAQ,KAAK;IAEtB;IAEA;IACA;IAJX,YACW,IAAY,EACrB,OAAe,EACN,WAAqB,CAAC,EACtB,QAAiC,EAAE;QAE5C,KAAK,CAAC,OAAO,CAAC,CAAC;QALN,SAAI,GAAJ,IAAI,CAAQ;QAEZ,aAAQ,GAAR,QAAQ,CAAc;QACtB,UAAK,GAAL,KAAK,CAA8B;QAG5C,IAAI,CAAC,IAAI,GAAG,UAAU,CAAC;IACzB,CAAC;IAED,SAAS;QACP,OAAO,EAAE,EAAE,EAAE,KAAK,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,OAAO,EAAE,IAAI,CAAC,OAAO,EAAE,GAAG,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC;IACzF,CAAC;CACF;AAED,gEAAgE;AAChE,MAAM,UAAU,IAAI,CAClB,IAAY,EACZ,OAAe,EACf,KAA+B,EAC/B,WAAqB,CAAC;IAEtB,MAAM,IAAI,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,QAAQ,EAAE,KAAK,CAAC,CAAC;AACrD,CAAC;AAED,MAAM,UAAU,UAAU,CAAC,OAAe;IACxC,MAAM,IAAI,QAAQ,CAAC,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC,CAAC;AAC5C,CAAC;AAED,4CAA4C;AAC5C,MAAM,UAAU,SAAS,CAAC,KAAc;IACtC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,GAAG,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC;AACrD,CAAC;AAED,6DAA6D;AAC7D,MAAM,UAAU,MAAM,CAAC,OAAe;IACpC,OAAO,CAAC,MAAM,CAAC,KAAK,CAAC,WAAW,OAAO,IAAI,CAAC,CAAC;AAC/C,CAAC"}