@crouton-kit/crouter 0.3.8 → 0.3.12

package/dist/commands/agent.js

@@ -1,384 +0,0 @@
-// `crtr agent` umbrella — agentic workflows: spec/plan/debug + spawn primitives.
-//
-// `agent new {prompt,fork,planner,implementer,reviewer}` are the spawn leaves
-// (formerly `job start *`). Spawning creates a job record; monitoring lives at
-// `crtr job`. This split keeps the job registry agnostic of producer — agents
-// are one producer, future producers compose under their own subtree.
-//
-// Terminal-write contract for spawned workers:
-//   Worker calls `crtr job submit` → jobs.writeResult(jobId, result, 'done').
-//   If claude exits without submitting, the wrapper shell calls `crtr job _fail`
-//   → jobs.writeResult(jobId, {}, 'failed') IF result.json does not yet exist.
-//   `job read result` watches result.json appearance as the sole completion signal.
-import { defineBranch, defineLeaf } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { createJob, appendEvent } from '../core/jobs.js';
-import { spawnAgent, spawnAndDetach, isInTmux } from '../core/spawn.js';
-import { readConfig } from '../core/config.js';
-import { planHandoffPrompt, implementHandoffPrompt, reviewerHandoffPrompt } from '../prompts/agent.js';
-import { existsSync } from 'node:fs';
-import { registerSpec } from './spec.js';
-import { registerPlan } from './plan.js';
-import { registerDebug } from './debug.js';
-const DEFAULT_KILL_SECS = 2;
-function followUpResult(jobId) {
-    return `crtr job read result ${jobId} --wait`;
-}
-function resolveMaxPanes() {
-    const cfg = readConfig('user');
-    return cfg.max_panes_per_window;
-}
-function assertTmux() {
-    if (!isInTmux()) {
-        throw new InputError({
-            error: 'not_in_tmux',
-            message: 'crtr agent new requires tmux (TMUX env var not set).',
-            next: 'Run inside a tmux session.',
-        });
-    }
-}
-// ---------------------------------------------------------------------------
-// agent new prompt
-// ---------------------------------------------------------------------------
-const newPrompt = defineLeaf({
-    name: 'prompt',
-    help: {
-        name: 'agent new prompt',
-        summary: 'spawn a fresh Claude agent with a prompt; returns a job handle immediately',
-        params: [
-            { kind: 'stdin', name: 'prompt', required: true, constraint: 'Prompt text sent to the spawned agent.' },
-            { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: 'Working directory for the spawned agent. Defaults to process.cwd().' },
-            { kind: 'flag', name: 'name', type: 'string', required: true, constraint: 'Display name passed to `claude -n`; surfaces in pane title and /resume picker.' },
-        ],
-        output: [
-            { name: 'job_id', type: 'string', required: true, constraint: 'Use with `crtr job read status|logs|result` and `crtr job cancel`.' },
-            { name: 'follow_up', type: 'string', required: true, constraint: 'Recommended next call.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Spawns a Claude agent in a sibling tmux pane.',
-            'Creates a job entry at $XDG_STATE_HOME/crtr/jobs/<job_id>/.',
-            'On completion, result writes atomically to result.json.',
-        ],
-    },
-    run: async (input) => {
-        assertTmux();
-        const prompt = input['prompt'];
-        const cwd = typeof input['cwd'] === 'string' ? input['cwd'] : process.cwd();
-        const name = input['name'];
-        const { jobId } = createJob('prompt', { cwd });
-        const promptWithSubmit = `${prompt}
-
----
-When your task is complete, submit your result (markdown body piped on stdin):
-\`\`\`bash
-crtr job submit ${jobId} <<'MD'
-<your result as markdown>
-MD
-\`\`\`
-If you cannot complete the task, submit a failure with a reason (no stdin needed):
-\`\`\`bash
-crtr job submit ${jobId} --status failed --reason "<why>"
-\`\`\``;
-        const result = spawnAgent({
-            prompt: promptWithSubmit,
-            cwd,
-            jobId,
-            maxPanesPerWindow: resolveMaxPanes(),
-            name,
-        });
-        if (result.status === 'not-in-tmux') {
-            throw new InputError({ error: 'not_in_tmux', message: result.message, next: 'Run inside a tmux session.' });
-        }
-        if (result.status === 'spawn-failed') {
-            throw new InputError({ error: 'spawn_failed', message: result.message, next: 'Check tmux is running and try again.' });
-        }
-        const paneLabel = result.paneId !== undefined ? result.paneId : 'unknown';
-        appendEvent(jobId, { level: 'info', event: 'worker_started', message: `pane ${paneLabel} spawned` });
-        return { job_id: jobId, follow_up: followUpResult(jobId) };
-    },
-});
-// ---------------------------------------------------------------------------
-// agent new fork
-// ---------------------------------------------------------------------------
-const newFork = defineLeaf({
-    name: 'fork',
-    help: {
-        name: 'agent new fork',
-        summary: 'fork the current Claude session into a sibling pane; returns a job handle immediately',
-        params: [
-            { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: 'Working directory. Defaults to process.cwd().' },
-            { kind: 'flag', name: 'name', type: 'string', required: true, constraint: 'Display name passed to `claude -n`; surfaces in pane title and /resume picker.' },
-        ],
-        output: [
-            { name: 'job_id', type: 'string', required: true, constraint: 'Use with `crtr job read *` and `crtr job cancel`.' },
-            { name: 'follow_up', type: 'string', required: true, constraint: 'Recommended next call.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Requires $CLAUDE_CODE_SESSION_ID — must run inside Claude Code.',
-            'Spawns a forked Claude session in a sibling tmux pane.',
-            'Creates a job entry and result sidecar as with `agent new prompt`.',
-        ],
-    },
-    run: async (input) => {
-        assertTmux();
-        const parentSessionId = process.env['CLAUDE_CODE_SESSION_ID'];
-        if (parentSessionId === undefined || parentSessionId === '') {
-            throw new InputError({
-                error: 'missing_session_id',
-                message: 'crtr agent new fork requires $CLAUDE_CODE_SESSION_ID — must run inside Claude Code.',
-                next: 'Run this command from within a Claude Code session.',
-            });
-        }
-        const cwd = typeof input['cwd'] === 'string' ? input['cwd'] : process.cwd();
-        const name = input['name'];
-        const { jobId } = createJob('fork', { cwd });
-        const promptWithSubmit = `Fork of session ${parentSessionId}
-
----
-When your task is complete, submit your result (markdown body piped on stdin):
-\`\`\`bash
-crtr job submit ${jobId} <<'MD'
-<your result as markdown>
-MD
-\`\`\`
-If you cannot complete the task, submit a failure with a reason (no stdin needed):
-\`\`\`bash
-crtr job submit ${jobId} --status failed --reason "<why>"
-\`\`\``;
-        const result = spawnAgent({
-            prompt: promptWithSubmit,
-            cwd,
-            jobId,
-            fork: { sessionId: parentSessionId },
-            maxPanesPerWindow: resolveMaxPanes(),
-            name,
-        });
-        if (result.status === 'not-in-tmux') {
-            throw new InputError({ error: 'not_in_tmux', message: result.message, next: 'Run inside a tmux session.' });
-        }
-        if (result.status === 'spawn-failed') {
-            throw new InputError({ error: 'spawn_failed', message: result.message, next: 'Check tmux is running and try again.' });
-        }
-        const forkPaneLabel = result.paneId !== undefined ? result.paneId : 'unknown';
-        appendEvent(jobId, { level: 'info', event: 'worker_started', message: `forked pane ${forkPaneLabel} spawned` });
-        return { job_id: jobId, follow_up: followUpResult(jobId) };
-    },
-});
-// ---------------------------------------------------------------------------
-// agent new planner
-// ---------------------------------------------------------------------------
-const newPlanner = defineLeaf({
-    name: 'planner',
-    help: {
-        name: 'agent new planner',
-        summary: 'launch a planning agent for an approved spec; closes the originating pane after handoff',
-        params: [
-            { kind: 'positional', name: 'spec_path', type: 'path', required: true, constraint: 'Absolute path to the spec file.' },
-            { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: 'Working directory. Defaults to process.cwd().' },
-            { kind: 'flag', name: 'name', type: 'string', required: true, constraint: 'Display name passed to `claude -n`; surfaces in pane title and /resume picker.' },
-        ],
-        output: [
-            { name: 'job_id', type: 'string', required: true, constraint: 'Use with `crtr job read *` and `crtr job cancel`.' },
-            { name: 'follow_up', type: 'string', required: true, constraint: 'Recommended next call.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Spawns a planner agent in a sibling tmux pane.',
-            'Closes the originating pane after a short delay.',
-            'Creates a job entry and result sidecar.',
-        ],
-    },
-    run: async (input) => {
-        assertTmux();
-        const specPath = input['spec_path'];
-        const cwd = typeof input['cwd'] === 'string' ? input['cwd'] : process.cwd();
-        const name = input['name'];
-        if (!existsSync(specPath)) {
-            throw new InputError({
-                error: 'not_found',
-                message: `spec not found: ${specPath}`,
-                field: 'spec_path',
-                next: 'Provide an absolute path to an existing spec file.',
-            });
-        }
-        const { jobId } = createJob('planner', { cwd });
-        const result = spawnAndDetach({
-            prompt: planHandoffPrompt(specPath, jobId),
-            cwd,
-            jobId,
-            placement: 'split-h',
-            killAfterSeconds: DEFAULT_KILL_SECS,
-            name,
-        });
-        if (result.status === 'not-in-tmux') {
-            throw new InputError({ error: 'not_in_tmux', message: result.message, next: 'Run inside a tmux session.' });
-        }
-        if (result.status === 'spawn-failed') {
-            throw new InputError({ error: 'spawn_failed', message: result.message, next: 'Check tmux is running and try again.' });
-        }
-        const plannerPaneLabel = result.paneId !== undefined ? result.paneId : 'unknown';
-        appendEvent(jobId, { level: 'info', event: 'worker_started', message: `planner pane ${plannerPaneLabel} spawned` });
-        return { job_id: jobId, follow_up: followUpResult(jobId) };
-    },
-});
-// ---------------------------------------------------------------------------
-// agent new implementer
-// ---------------------------------------------------------------------------
-const newImplementer = defineLeaf({
-    name: 'implementer',
-    help: {
-        name: 'agent new implementer',
-        summary: 'launch an implementation agent for an approved plan; closes the originating pane after handoff',
-        params: [
-            { kind: 'positional', name: 'plan_path', type: 'path', required: true, constraint: 'Absolute path to the plan file.' },
-            { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: 'Working directory. Defaults to process.cwd().' },
-            { kind: 'flag', name: 'name', type: 'string', required: true, constraint: 'Display name passed to `claude -n`; surfaces in pane title and /resume picker.' },
-        ],
-        output: [
-            { name: 'job_id', type: 'string', required: true, constraint: 'Use with `crtr job read *` and `crtr job cancel`.' },
-            { name: 'follow_up', type: 'string', required: true, constraint: 'Recommended next call.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Spawns an implementer agent in a sibling tmux pane.',
-            'Closes the originating pane after a short delay.',
-            'Creates a job entry and result sidecar.',
-        ],
-    },
-    run: async (input) => {
-        assertTmux();
-        const planPath = input['plan_path'];
-        const cwd = typeof input['cwd'] === 'string' ? input['cwd'] : process.cwd();
-        const name = input['name'];
-        if (!existsSync(planPath)) {
-            throw new InputError({
-                error: 'not_found',
-                message: `plan not found: ${planPath}`,
-                field: 'plan_path',
-                next: 'Provide an absolute path to an existing plan file.',
-            });
-        }
-        const { jobId } = createJob('implementer', { cwd });
-        const result = spawnAndDetach({
-            prompt: implementHandoffPrompt(planPath, jobId),
-            cwd,
-            jobId,
-            placement: 'split-h',
-            killAfterSeconds: DEFAULT_KILL_SECS,
-            name,
-        });
-        if (result.status === 'not-in-tmux') {
-            throw new InputError({ error: 'not_in_tmux', message: result.message, next: 'Check tmux is running and try again.' });
-        }
-        if (result.status === 'spawn-failed') {
-            throw new InputError({ error: 'spawn_failed', message: result.message, next: 'Check tmux is running and try again.' });
-        }
-        const implPaneLabel = result.paneId !== undefined ? result.paneId : 'unknown';
-        appendEvent(jobId, { level: 'info', event: 'worker_started', message: `implementer pane ${implPaneLabel} spawned` });
-        return { job_id: jobId, follow_up: followUpResult(jobId) };
-    },
-});
-// ---------------------------------------------------------------------------
-// agent new reviewer
-// ---------------------------------------------------------------------------
-const newReviewer = defineLeaf({
-    name: 'reviewer',
-    help: {
-        name: 'agent new reviewer',
-        summary: 'launch a reviewer agent for a plan or spec artifact; the originating pane stays alive to collect the verdict',
-        params: [
-            { kind: 'positional', name: 'artifact_path', type: 'path', required: true, constraint: 'Absolute path to the artifact to review.' },
-            { kind: 'flag', name: 'kind', type: 'enum', choices: ['plan', 'spec'], required: true, constraint: 'Artifact kind to review.' },
-            { kind: 'flag', name: 'spec-path', type: 'path', required: false, constraint: 'Absolute path to the spec, for plan reviews. Omit for spec reviews.' },
-            { kind: 'flag', name: 'cwd', type: 'path', required: false, constraint: 'Working directory. Defaults to process.cwd().' },
-            { kind: 'flag', name: 'name', type: 'string', required: true, constraint: 'Display name passed to `claude -n`; surfaces in pane title and /resume picker.' },
-        ],
-        output: [
-            { name: 'job_id', type: 'string', required: true, constraint: 'Use with `crtr job read *` and `crtr job cancel`.' },
-            { name: 'follow_up', type: 'string', required: true, constraint: 'Recommended next call.' },
-        ],
-        outputKind: 'object',
-        effects: [
-            'Spawns a reviewer agent in a sibling tmux pane.',
-            'The originating pane stays alive — wait on the result and act on the verdict.',
-            'Creates a job entry and result sidecar.',
-        ],
-    },
-    run: async (input) => {
-        assertTmux();
-        const artifactPath = input['artifact_path'];
-        const artifactKind = input['kind'];
-        const specPath = typeof input['specPath'] === 'string' ? input['specPath'] : undefined;
-        const cwd = typeof input['cwd'] === 'string' ? input['cwd'] : process.cwd();
-        const name = input['name'];
-        if (!existsSync(artifactPath)) {
-            throw new InputError({
-                error: 'not_found',
-                message: `artifact not found: ${artifactPath}`,
-                field: 'artifact_path',
-                next: 'Provide an absolute path to an existing artifact file.',
-            });
-        }
-        const { jobId } = createJob('reviewer', { cwd });
-        // The reviewer is a subordinate the caller waits on (verdict → revise or
-        // hand off), NOT a handoff successor. Use spawnAgent so the originating
-        // pane (planner/orchestrator) stays alive to collect the result; do not
-        // self-kill the caller the way planner/implementer handoffs do.
-        const result = spawnAgent({
-            prompt: reviewerHandoffPrompt(artifactPath, artifactKind, specPath !== undefined ? specPath : null, jobId),
-            cwd,
-            jobId,
-            maxPanesPerWindow: resolveMaxPanes(),
-            name,
-        });
-        if (result.status === 'not-in-tmux') {
-            throw new InputError({ error: 'not_in_tmux', message: result.message, next: 'Run inside a tmux session.' });
-        }
-        if (result.status === 'spawn-failed') {
-            throw new InputError({ error: 'spawn_failed', message: result.message, next: 'Check tmux is running and try again.' });
-        }
-        const reviewerPaneLabel = result.paneId !== undefined ? result.paneId : 'unknown';
-        appendEvent(jobId, { level: 'info', event: 'worker_started', message: `reviewer pane ${reviewerPaneLabel} spawned` });
-        return { job_id: jobId, follow_up: followUpResult(jobId) };
-    },
-});
-// ---------------------------------------------------------------------------
-// agent new (branch)
-// ---------------------------------------------------------------------------
-const newBranch = defineBranch({
-    name: 'new',
-    help: {
-        name: 'agent new',
-        summary: 'spawn agent workers; all return a job handle immediately',
-        children: [
-            { name: 'prompt', desc: 'fresh agent with a prompt', useWhen: 'spawning a general-purpose agent' },
-            { name: 'fork', desc: 'fork current session into a sibling pane', useWhen: 'branching the current session\'s context into a new agent' },
-            { name: 'planner', desc: 'planning agent for a spec', useWhen: 'handing off spec → plan decomposition' },
-            { name: 'implementer', desc: 'implementation agent for a plan', useWhen: 'handing off plan → code implementation' },
-            { name: 'reviewer', desc: 'review agent for a plan or spec', useWhen: 'launching a review of a plan or spec artifact' },
-        ],
-    },
-    children: [newPrompt, newFork, newPlanner, newImplementer, newReviewer],
-});
-// ---------------------------------------------------------------------------
-// agent (root umbrella)
-// ---------------------------------------------------------------------------
-export function registerAgent() {
-    return defineBranch({
-        name: 'agent',
-        help: {
-            name: 'agent',
-            summary: 'agentic workflows: spec, plan, debug, and spawning agent workers',
-            model: 'spec captures requirements; plan decomposes them; debug root-causes failures reproduce-first; new spawns the worker that executes the next phase. Spawned workers register as jobs — monitor and collect at `crtr job`.',
-            children: [
-                { name: 'spec', desc: 'create, read, list specifications', useWhen: 'capturing requirements before planning' },
-                { name: 'plan', desc: 'create, read, list plans', useWhen: 'shaping or inspecting work' },
-                { name: 'debug', desc: 'reproduce-first root-cause workflow', useWhen: 'a bug, test failure, or unexpected behavior needs root-causing' },
-                { name: 'new', desc: 'spawn agent workers (prompt, fork, planner, implementer, reviewer)', useWhen: 'launching a new agent worker' },
-            ],
-        },
-        children: [registerSpec(), registerPlan(), registerDebug(), newBranch],
-    });
-}

package/dist/commands/debug.d.ts

@@ -1,3 +0,0 @@
-export declare const FLOW_DEBUG_GUIDE = "## Debug workflow \u2014 reproduce first\n\nAudience: the agent that ran `crtr agent debug`. A reproduction agent is\nalready spawned in a sibling pane. It writes ONE failing integration test and\nnever fixes anything. You do everything after: gate on the repro, root-cause,\nfix, verify against that same test.\n\n### Phase 0: Await the repro agent\n\nRun `crtr job read result <job_id> --wait` (10-min budget).\nOn status:\"timeout\": re-issue the wait, or run `crtr job read logs <job_id> --follow`\nuntil the job is terminal.\n\n### Phase 1: Gate on reproduction\n\n`reproduces:true`: read `test_path`, run `test_command` YOURSELF, confirm\nit fails for the stated reason. Do not trust the agent's claim \u2014 if it passes\nor fails differently, treat repro as NOT achieved. This test is the regression\ngate; it stays in the suite after the fix.\n`status:\"failed\"` / `reproduces:false` / your run disproves it: no repro\nharness. Continue, but record \"no reproduction \u2014 fix unverified; do not claim\nverified-fixed.\"\n\n### Phase 2: Reconnaissance\n\nRead the key files yourself \u2014 entry point, failure point, the data flow\nbetween. `git log` / `git blame` near the failure: recent changes are\nhigh-signal.\n\n### Phase 3: Assess difficulty, scale investigators\n\nSimple \u2192 solo (Explore subagents for tracing if the area is large).\nMedium \u2192 2\u20133 parallel `devcore:senior-advisor`: data-flow tracer, assumption\nauditor, change investigator.\nHard (intermittent, races, \"been stuck\", many modules) \u2192 3\u20135 parallel:\nend-to-end tracer, assumption breaker, git archaeologist, boundary inspector.\nGive investigators file paths, observed behavior, and concrete tasks \u2014 never\nyour hypotheses. Challenge theories against each other; the one that survives\ndisconfirmation wins.\n\n### Phase 4: Fix\n\nMinimal root-cause fix. No scope expansion, no drive-by refactor.\n\n### Phase 5: Verify\n\nRe-run `test_command`: it MUST now pass. Run the broader suite for\nregressions. If there was no repro test, state the fix is unverified by\nreproduction and recommend explicit manual verification.\n\n### Phase 6: Report\n\nRoot cause (exact line + why), evidence, the now-passing repro test path,\nconfidence (High/Medium/Low; if not High, name what is uncertain).\n\n### Constraints\n\nThe repro test is the regression guard \u2014 it stays; a fix-agent must never\nweaken it. Investigators run in forked contexts; they return summaries, not\nraw output. No code changes during Phases 2\u20133 except the repro test.";
-import type { LeafDef } from '../core/command.js';
-export declare function registerDebug(): LeafDef;

package/dist/commands/debug.js

@@ -1,179 +0,0 @@
-// `crtr agent debug` leaf — reproduce-first root-cause workflow.
-//
-// Running it spawns a reproduction-only agent in a sibling tmux pane (the same
-// spawn + job-handle shape as `crtr agent new prompt`) and returns a job handle
-// plus a follow_up. The orchestrator-side methodology lives in FLOW_DEBUG_GUIDE
-// (the leaf's help.guide), loaded via `crtr agent debug -h` after the repro
-// agent returns. Methodology stays in the CLI guide field, like PLAN_NEW_GUIDE;
-// no builtin skill.
-export const FLOW_DEBUG_GUIDE = `## Debug workflow — reproduce first
-
-Audience: the agent that ran \`crtr agent debug\`. A reproduction agent is
-already spawned in a sibling pane. It writes ONE failing integration test and
-never fixes anything. You do everything after: gate on the repro, root-cause,
-fix, verify against that same test.
-
-### Phase 0: Await the repro agent
-
-Run \`crtr job read result <job_id> --wait\` (10-min budget).
-On status:"timeout": re-issue the wait, or run \`crtr job read logs <job_id> --follow\`
-until the job is terminal.
-
-### Phase 1: Gate on reproduction
-
-\`reproduces:true\`: read \`test_path\`, run \`test_command\` YOURSELF, confirm
-it fails for the stated reason. Do not trust the agent's claim — if it passes
-or fails differently, treat repro as NOT achieved. This test is the regression
-gate; it stays in the suite after the fix.
-\`status:"failed"\` / \`reproduces:false\` / your run disproves it: no repro
-harness. Continue, but record "no reproduction — fix unverified; do not claim
-verified-fixed."
-
-### Phase 2: Reconnaissance
-
-Read the key files yourself — entry point, failure point, the data flow
-between. \`git log\` / \`git blame\` near the failure: recent changes are
-high-signal.
-
-### Phase 3: Assess difficulty, scale investigators
-
-Simple → solo (Explore subagents for tracing if the area is large).
-Medium → 2–3 parallel \`devcore:senior-advisor\`: data-flow tracer, assumption
-auditor, change investigator.
-Hard (intermittent, races, "been stuck", many modules) → 3–5 parallel:
-end-to-end tracer, assumption breaker, git archaeologist, boundary inspector.
-Give investigators file paths, observed behavior, and concrete tasks — never
-your hypotheses. Challenge theories against each other; the one that survives
-disconfirmation wins.
-
-### Phase 4: Fix
-
-Minimal root-cause fix. No scope expansion, no drive-by refactor.
-
-### Phase 5: Verify
-
-Re-run \`test_command\`: it MUST now pass. Run the broader suite for
-regressions. If there was no repro test, state the fix is unverified by
-reproduction and recommend explicit manual verification.
-
-### Phase 6: Report
-
-Root cause (exact line + why), evidence, the now-passing repro test path,
-confidence (High/Medium/Low; if not High, name what is uncertain).
-
-### Constraints
-
-The repro test is the regression guard — it stays; a fix-agent must never
-weaken it. Investigators run in forked contexts; they return summaries, not
-raw output. No code changes during Phases 2–3 except the repro test.`;
-import { defineLeaf } from '../core/command.js';
-import { InputError } from '../core/io.js';
-import { createJob, appendEvent } from '../core/jobs.js';
-import { spawnAgent, isInTmux } from '../core/spawn.js';
-import { readConfig } from '../core/config.js';
-import { reproHandoffPrompt } from '../prompts/debug.js';
-// Inlined from job.ts (module-private there; not exported, per the no-shim
-// convention). Same forms.
-function resolveMaxPanes() {
-    const cfg = readConfig('user');
-    return cfg.max_panes_per_window;
-}
-function assertTmux() {
-    if (!isInTmux()) {
-        throw new InputError({
-            error: 'not_in_tmux',
-            message: 'crtr agent debug requires tmux (TMUX env var not set).',
-            next: 'Run inside a tmux session.',
-        });
-    }
-}
-export function registerDebug() {
-    return defineLeaf({
-        name: 'debug',
-        help: {
-            name: 'agent debug',
-            summary: 'reproduce-first root-cause workflow: spawns a reproduction agent, then you root-cause and fix',
-            guide: FLOW_DEBUG_GUIDE,
-            params: [
-                {
-                    kind: 'stdin',
-                    name: 'steps_to_reproduce',
-                    required: true,
-                    constraint: 'Prose describing how to reproduce the failure. Pipe on stdin.',
-                },
-                {
-                    kind: 'flag',
-                    name: 'summary',
-                    type: 'string',
-                    required: true,
-                    constraint: 'One paragraph summary of the failure: symptom, where observed, expected vs actual.',
-                },
-                {
-                    kind: 'flag',
-                    name: 'cwd',
-                    type: 'path',
-                    required: false,
-                    constraint: 'Working directory for the spawned agent. Defaults to process.cwd().',
-                },
-            ],
-            output: [
-                {
-                    name: 'job_id',
-                    type: 'string',
-                    required: true,
-                    constraint: 'Use with `job read status`, `job read logs`, `job read result`, `job cancel`.',
-                },
-                {
-                    name: 'follow_up',
-                    type: 'string',
-                    required: true,
-                    constraint: 'Recommended next call.',
-                },
-            ],
-            outputKind: 'object',
-            effects: [
-                'Spawns a reproduction agent in a sibling tmux pane.',
-                'Creates a job entry at $XDG_STATE_HOME/crtr/jobs/<job_id>/.',
-                'On completion, result writes atomically to result.json.',
-            ],
-        },
-        run: async (input) => {
-            assertTmux();
-            const stepsToReproduce = input['steps_to_reproduce'];
-            const summary = input['summary'];
-            const cwd = input['cwd'] ?? process.cwd();
-            const issue = `${summary}\n\n${stepsToReproduce}`;
-            const { jobId } = createJob('debug-repro', { cwd });
-            const result = spawnAgent({
-                prompt: reproHandoffPrompt(issue, jobId),
-                cwd,
-                jobId,
-                maxPanesPerWindow: resolveMaxPanes(),
-            });
-            if (result.status === 'not-in-tmux') {
-                throw new InputError({
-                    error: 'not_in_tmux',
-                    message: result.message,
-                    next: 'Run inside a tmux session.',
-                });
-            }
-            if (result.status === 'spawn-failed') {
-                throw new InputError({
-                    error: 'spawn_failed',
-                    message: result.message,
-                    next: 'Check tmux is running and try again.',
-                });
-            }
-            const paneLabel = result.paneId !== undefined ? result.paneId : 'unknown';
-            appendEvent(jobId, {
-                level: 'info',
-                event: 'worker_started',
-                message: `repro pane ${paneLabel} spawned`,
-            });
-            return {
-                job_id: jobId,
-                follow_up: `Await the reproduction agent: crtr job read result ${jobId} --wait. Then run \`crtr agent debug -h\` and follow the workflow from Phase 1.`,
-            };
-        },
-    });
-}