@crouton-kit/crouter 0.2.6 → 0.3.1

package/dist/{commands/update.js → core/self-update.js}

@@ -1,42 +1,44 @@
+// Self-update and content-check primitives extracted from commands/update.ts.
+// Moved here to break the core→commands import inversion: auto-update.ts
+// (core) previously imported from commands/update.ts (commands layer).
 import { spawnSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import { join, dirname } from 'node:path';
 import { readFileSync } from 'node:fs';
-import { err, warn, handleError } from '../core/output.js';
-import { projectScopeRoot } from '../core/scope.js';
-import { updateState } from '../core/config.js';
-import { listAllPlugins, listAllMarketplaces } from '../core/resolver.js';
-import { pull, fetch, currentSha, remoteSha } from '../core/git.js';
-import { nowIso } from '../core/fs-utils.js';
-import { network, general } from '../core/errors.js';
+import { listAllPlugins, listAllMarketplaces } from './resolver.js';
+import { pull, fetch, currentSha, remoteSha } from './git.js';
+import { updateState } from './config.js';
+import { nowIso } from './fs-utils.js';
+import { general, network } from './errors.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-const PKG_ROOT = join(__dirname, '..', '..', '..');
+// src/core/self-update.ts → up to src/ → up to pkg root
+const PKG_ROOT = join(__dirname, '..', '..');
 const PACKAGE_JSON_PATH = join(PKG_ROOT, 'package.json');
-function currentVersion() {
+export function currentVersion() {
     const raw = readFileSync(PACKAGE_JSON_PATH, 'utf8');
     const parsed = JSON.parse(raw);
     return parsed.version;
 }
-function selfUpdate() {
+export function selfUpdate() {
     const res = spawnSync('npm', ['i', '-g', '@crouton-kit/crtr@latest'], { stdio: 'inherit' });
     if (res.status !== 0) {
         throw general('npm install failed');
     }
 }
+/** Check whether a newer crtr version is available on npm.
+ *  Warns to stderr if network unavailable; returns {current, latest} or null if unreachable. */
 export function selfCheck() {
     const res = spawnSync('npm', ['view', '@crouton-kit/crtr', 'version'], { encoding: 'utf8' });
     if (res.status !== 0) {
-        warn('could not check for crtr updates (network unavailable)');
-        return;
+        return null;
     }
     const latest = res.stdout.trim();
     const current = currentVersion();
-    if (latest !== current) {
-        err(`crtr: v${latest} available (current ${current}) — run \`crtr update --self\``);
-    }
+    return { current, latest };
 }
-function contentUpdate() {
+/** Pull updates for all installed marketplaces and standalone plugins. */
+export function contentUpdate() {
     const marketplaces = listAllMarketplaces();
     for (const mkt of marketplaces) {
         const res = pull(mkt.root);
@@ -66,19 +68,21 @@ function contentUpdate() {
         });
     }
 }
+/** Check whether any marketplace/plugin has updates available.
+ *  Returns per-item status without applying anything. */
 export function contentCheck() {
+    const results = [];
     const marketplaces = listAllMarketplaces();
     for (const mkt of marketplaces) {
         const fetchRes = fetch(mkt.root, mkt.ref);
         if (fetchRes.status !== 0) {
-            warn(`could not fetch ${mkt.name} (network unavailable)`);
+            results.push({ name: mkt.name, kind: 'marketplace', current: null, latest: null, up_to_date: true, unreachable: true });
             continue;
         }
         const head = currentSha(mkt.root);
         const remote = remoteSha(mkt.root, mkt.ref);
-        if (head !== null && remote !== null && head !== remote) {
-            err(`crtr: marketplace ${mkt.name} has updates available — run \`crtr update --content\``);
-        }
+        const up_to_date = head !== null && remote !== null ? head === remote : true;
+        results.push({ name: mkt.name, kind: 'marketplace', current: head, latest: remote, up_to_date, unreachable: false });
     }
     const plugins = listAllPlugins();
     for (const plugin of plugins) {
@@ -89,52 +93,13 @@ export function contentCheck() {
         const ref = 'main';
         const fetchRes = fetch(plugin.root, ref);
         if (fetchRes.status !== 0) {
-            warn(`could not fetch ${plugin.name} (network unavailable)`);
+            results.push({ name: plugin.name, kind: 'plugin', current: null, latest: null, up_to_date: true, unreachable: true });
             continue;
         }
         const head = currentSha(plugin.root);
         const remote = remoteSha(plugin.root, ref);
-        if (head !== null && remote !== null && head !== remote) {
-            err(`crtr: plugin ${plugin.name} has updates available — run \`crtr plugin update ${plugin.name}\``);
-        }
+        const up_to_date = head !== null && remote !== null ? head === remote : true;
+        results.push({ name: plugin.name, kind: 'plugin', current: head, latest: remote, up_to_date, unreachable: false });
     }
-}
-export function registerUpdateCommand(program) {
-    program
-        .command('update')
-        .description('update crtr itself and/or installed plugins and marketplaces')
-        .option('--self', 'update crtr binary via npm')
-        .option('--content', 'pull updates for all installed plugins and marketplaces')
-        .option('--check', 'check for updates without applying them')
-        .action(async (opts) => {
-        try {
-            const runSelf = opts.self === true;
-            const runContent = opts.content === true;
-            const runBoth = !runSelf && !runContent;
-            if (opts.check) {
-                if (runSelf || runBoth)
-                    selfCheck();
-                if (runContent || runBoth)
-                    contentCheck();
-                return;
-            }
-            if (runSelf || runBoth) {
-                selfUpdate();
-                const scopes = ['user'];
-                if (projectScopeRoot())
-                    scopes.unshift('project');
-                for (const scope of scopes) {
-                    updateState(scope, (s) => {
-                        s.last_self_check = nowIso();
-                    });
-                }
-            }
-            if (runContent || runBoth) {
-                contentUpdate();
-            }
-        }
-        catch (e) {
-            handleError(e);
-        }
-    });
+    return results;
 }

package/dist/core/spawn.d.ts

@@ -1,95 +1,77 @@
-export interface SidePaneOptions {
-    /** Full first user message — task + checklist + submit instructions all in one. */
+export interface SpawnAgentOptions {
+    /** First user message for the new claude session. */
     prompt: string;
     cwd: string;
-    timeoutMs: number;
+    /** crtr job_id injected as CRTR_JOB_ID env var in the pane. */
+    jobId: string;
+    /** If set, resume this Claude Code session with --fork-session (new session id). */
+    fork?: {
+        sessionId: string;
+    };
+    /** Max panes per tmux window before overflowing to a new window. */
+    maxPanesPerWindow: number;
 }
-export declare const DEFAULT_PANE_OPTS: {
-    timeoutMs: number;
-};
-export type SidePaneStatus = 'submitted' | 'timeout' | 'pane-closed' | 'spawn-failed';
-export interface SidePaneResult {
-    status: SidePaneStatus;
-    content: string;
+export interface SpawnAgentResult {
+    status: 'spawned' | 'spawn-failed' | 'not-in-tmux';
+    /** tmux pane id of the spawned pane. */
     paneId?: string;
-    sessionDir: string;
+    /** How the pane was placed. */
+    placement?: 'split-window' | 'new-window';
+    message: string;
 }
-export declare function createSession(): {
-    id: string;
-    dir: string;
-};
-export declare function submitToSession(sessionDir: string, content: string): void;
 export interface DetachOptions {
-    /** Full first user message for the new claude session. No custom system prompt. */
-    prompt: string;
+    /** Inner command to run in the pane. If omitted, build `claude … <prompt>`. */
+    command?: string;
+    /** Full first user message for the new claude session (claude mode only;
+     *  ignored when `command` is set). No custom system prompt. */
+    prompt?: string;
     cwd: string;
+    /** crtr job_id injected as CRTR_JOB_ID env var in the pane and used by the
+     *  `_fail` guard. Optional only when `failGuard` is false. */
+    jobId?: string;
     /** Where to open the new pane. */
     placement: 'split-h' | 'split-v' | 'new-window';
     /** Seconds to wait before killing the originating pane so the caller can finish. */
     killAfterSeconds: number;
+    /** Append `; crtr job _fail <jobId>` and inject CRTR_JOB_ID. Default true. */
+    failGuard?: boolean;
+    /** Pin the new pane to this tmux pane: split-window splits it; new-window is
+     *  inserted immediately after its window (-a -t <pane>). Without this, tmux
+     *  uses the attached client's currently-focused pane — which drifts if the
+     *  user switches windows between kickoff and spawn. */
+    targetPane?: string;
 }
 export interface DetachResult {
     status: 'spawned' | 'spawn-failed' | 'not-in-tmux';
     paneId?: string;
     message: string;
 }
+export declare function isInTmux(): boolean;
+export declare function shellQuote(s: string): string;
+export declare function countPanesInCurrentWindow(): number;
+/**
+ * Schedule a kill-pane on the *current* tmux pane after `delaySeconds`, detached
+ * so the caller can return normally before the pane dies. No-op outside tmux
+ * or when TMUX_PANE is unset.
+ *
+ * Used by `crtr job submit` (kill_pane=true) so a reviewer agent can self-close
+ * its pane after delivering its verdict, and by `spawnAndDetach` for handoff
+ * self-kill.
+ */
+export declare function scheduleKillCurrentPane(delaySeconds: number): boolean;
 /**
  * Fire-and-forget: launch an interactive `claude` in a new pane (or window),
  * then schedule the originating pane to be killed after `killAfterSeconds`.
  *
- * No custom system prompt — the task is delivered as the first user message
- * so the user can `/clear` to fall back to a normal default Claude session.
- *
+ * No custom system prompt — the task is delivered as the first user message.
  * Returns as soon as the new pane is up; does NOT wait for claude to finish.
  */
 export declare function spawnAndDetach(opts: DetachOptions): DetachResult;
-/**
- * Spawn a side-pane `claude` reviewer. Blocks until the reviewer calls
- * `crtr agent submit <content>`, the 10-min budget elapses, or the pane is closed.
- *
- * No custom system prompt — the task is delivered as the first user message
- * so the reviewer is a normal Claude session running a single task.
- */
-export declare function spawnSidePaneReview(opts: SidePaneOptions): Promise<SidePaneResult>;
-export interface SpawnAgentOptions {
-    /** First user message for the new claude session. */
-    prompt: string;
-    cwd: string;
-    /** If set, resume this Claude Code session with --fork-session (new session id). */
-    fork?: {
-        sessionId: string;
-    };
-    /** Max panes per tmux window before overflowing to a new window. */
-    maxPanesPerWindow: number;
-}
-export interface SpawnAgentResult {
-    status: 'spawned' | 'spawn-failed' | 'not-in-tmux';
-    /** crtr session UUID — pass to `crtr agent await` to receive the result. */
-    sessionId?: string;
-    /** tmux pane id of the spawned pane. */
-    paneId?: string;
-    /** How the pane was placed. */
-    placement?: 'split-window' | 'new-window';
-    message: string;
-}
-export declare function sessionDirForId(sessionId: string): string;
-export declare function countPanesInCurrentWindow(): number;
 /**
  * Async sibling spawn. Launches a claude session in a new tmux pane or window
  * (depending on current pane count vs maxPanesPerWindow). Returns immediately
- * with the crtr session id; the parent stays alive.
+ * with the pane id; the parent stays alive.
  *
- * If `fork` is set, uses `claude --resume <id> --fork-session` so the child
- * gets a fresh session id and does not contend with the parent's JSONL.
+ * If `fork` is set, uses `claude --resume <id> --fork-session`.
  */
 export declare function spawnAgent(opts: SpawnAgentOptions): SpawnAgentResult;
-export interface AwaitOptions {
-    timeoutMs: number;
-    /** Kill the child pane after content is received. Default true. */
-    killPane: boolean;
-}
-/**
- * Block until the agent identified by `sessionId` calls `crtr agent submit`.
- * Returns content + status. Cleans up the session dir on completion.
- */
-export declare function awaitSession(sessionId: string, opts: AwaitOptions): Promise<SidePaneResult>;

package/dist/core/spawn.js

@@ -1,55 +1,71 @@
+// Tmux pane spawning machinery for crtr job subtree.
+//
+// Kept: spawnAgent (fire-and-forget new pane), spawnAndDetach (detach + kill originating pane),
+//       shellQuote, isInTmux, countPanesInCurrentWindow.
+//
+// Removed: createSession, submitToSession, awaitSession, waitForResult,
+//          sessionDirForId, writeSessionMeta, readSessionMeta — all superseded
+//          by the jobs.ts sidecar model (result.json + log.jsonl).
+//
+// Crash detection: the wrapper shell command is:
+//   `claude --dangerously-skip-permissions <prompt>; crtr job _fail <job_id>`
+// If the worker calls `crtr job submit` before claude exits, result.json is
+// written and `_fail` is a no-op (writeResult is idempotent for done status).
+// If claude dies without a submit, `_fail` writes status 'failed'. Either way
+// `job read result` sees a terminal result.json.
 import { spawnSync } from 'node:child_process';
-import { mkdirSync, watch, readFileSync, existsSync, writeFileSync, renameSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { randomUUID } from 'node:crypto';
-import { general, notFound } from './errors.js';
-const DEFAULT_TIMEOUT_MS = 10 * 60 * 1000;
-const PANE_POLL_MS = 2000;
-export const DEFAULT_PANE_OPTS = {
-    timeoutMs: DEFAULT_TIMEOUT_MS,
-};
-function isInTmux() {
+export function isInTmux() {
     return Boolean(process.env.TMUX);
 }
-function sessionRoot() {
-    const root = join(tmpdir(), 'crtr-sessions');
-    mkdirSync(root, { recursive: true });
-    return root;
-}
-export function createSession() {
-    const id = randomUUID();
-    const dir = join(sessionRoot(), id);
-    mkdirSync(dir, { recursive: true });
-    return { id, dir };
-}
-export function submitToSession(sessionDir, content) {
-    const tmp = join(sessionDir, '.content.tmp');
-    const final = join(sessionDir, 'content');
-    writeFileSync(tmp, content, 'utf8');
-    renameSync(tmp, final);
+export function shellQuote(s) {
+    return `'${s.replace(/'/g, "'\\''")}'`;
 }
-function paneAlive(paneId) {
-    const result = spawnSync('tmux', ['list-panes', '-a', '-F', '#{pane_id}'], {
+export function countPanesInCurrentWindow() {
+    const result = spawnSync('tmux', ['list-panes', '-F', '#{pane_id}'], {
         encoding: 'utf8',
     });
     if (result.status !== 0)
-        return false;
-    return result.stdout.split('\n').some((line) => line.trim() === paneId);
+        return 0;
+    return result.stdout.split('\n').filter((line) => line.trim() !== '').length;
 }
-function killPane(paneId) {
-    spawnSync('tmux', ['kill-pane', '-t', paneId], { stdio: 'ignore' });
+/**
+ * Schedule a kill-pane on the *current* tmux pane after `delaySeconds`, detached
+ * so the caller can return normally before the pane dies. No-op outside tmux
+ * or when TMUX_PANE is unset.
+ *
+ * Used by `crtr job submit` (kill_pane=true) so a reviewer agent can self-close
+ * its pane after delivering its verdict, and by `spawnAndDetach` for handoff
+ * self-kill.
+ */
+export function scheduleKillCurrentPane(delaySeconds) {
+    const currentPane = process.env.TMUX_PANE;
+    if (currentPane === undefined || currentPane === '' || delaySeconds <= 0) {
+        return false;
+    }
+    const killCmd = `sleep ${delaySeconds}; tmux kill-pane -t ${currentPane}`;
+    spawnSync('sh', ['-c', `nohup sh -c ${shellQuote(killCmd)} </dev/null >/dev/null 2>&1 &`], {
+        stdio: 'ignore',
+    });
+    return true;
 }
-function shellQuote(s) {
-    return `'${s.replace(/'/g, "'\\''")}'`;
+/**
+ * Build the wrapper shell command passed to the tmux pane.
+ *
+ * Pattern: `claude <args>; crtr job _fail <job_id>`
+ *
+ * If the worker submits via `crtr job submit` before claude exits,
+ * result.json is already written (`done`); `_fail` sees it and is a no-op.
+ * If claude crashes/exits without submitting, `_fail` writes status `failed`
+ * so `job read result` can distinguish completion from crash.
+ */
+function wrapperCmd(claudeCmd, jobId) {
+    return `${claudeCmd}; crtr job _fail ${shellQuote(jobId)}`;
 }
 /**
  * Fire-and-forget: launch an interactive `claude` in a new pane (or window),
  * then schedule the originating pane to be killed after `killAfterSeconds`.
  *
- * No custom system prompt — the task is delivered as the first user message
- * so the user can `/clear` to fall back to a normal default Claude session.
- *
+ * No custom system prompt — the task is delivered as the first user message.
  * Returns as soon as the new pane is up; does NOT wait for claude to finish.
  */
 export function spawnAndDetach(opts) {
@@ -59,22 +75,32 @@ export function spawnAndDetach(opts) {
             message: 'handoff requires tmux (TMUX env var not set)',
         };
     }
-    const claudeCmd = [
-        'claude',
-        '--dangerously-skip-permissions',
-        shellQuote(opts.prompt),
-    ].join(' ');
+    const inner = opts.command !== undefined
+        ? opts.command
+        : ['claude', '--dangerously-skip-permissions', shellQuote(opts.prompt)].join(' ');
+    const useFailGuard = opts.failGuard !== false;
+    const fullCmd = useFailGuard ? wrapperCmd(inner, opts.jobId) : inner;
     const splitArgs = [];
     if (opts.placement === 'new-window') {
         splitArgs.push('new-window');
+        if (opts.targetPane !== undefined && opts.targetPane !== '') {
+            // -a = insert after target window; -t <pane> resolves to that pane's window.
+            splitArgs.push('-a', '-t', opts.targetPane);
+        }
     }
     else {
         splitArgs.push('split-window');
         splitArgs.push(opts.placement === 'split-h' ? '-h' : '-v');
+        if (opts.targetPane !== undefined && opts.targetPane !== '') {
+            splitArgs.push('-t', opts.targetPane);
+        }
     }
     splitArgs.push('-P', '-F', '#{pane_id}');
     splitArgs.push('-c', opts.cwd);
-    splitArgs.push(claudeCmd);
+    if (opts.jobId !== undefined) {
+        splitArgs.push('-e', `CRTR_JOB_ID=${opts.jobId}`);
+    }
+    splitArgs.push(fullCmd);
     const split = spawnSync('tmux', splitArgs, { encoding: 'utf8' });
     if (split.status !== 0) {
         const stderrText = split.stderr.trim();
@@ -82,228 +108,52 @@ export function spawnAndDetach(opts) {
         return { status: 'spawn-failed', message: msg };
     }
     const paneId = split.stdout.trim();
-    // Schedule self-kill of the originating pane. We detach this so it survives
-    // crtr's exit.
-    const currentPane = process.env.TMUX_PANE;
-    if (currentPane !== undefined && currentPane !== '' && opts.killAfterSeconds > 0) {
-        const killCmd = `sleep ${opts.killAfterSeconds}; tmux kill-pane -t ${currentPane}`;
-        spawnSync('sh', ['-c', `nohup sh -c ${shellQuote(killCmd)} </dev/null >/dev/null 2>&1 &`], {
-            stdio: 'ignore',
-        });
-    }
+    // Schedule self-kill of the originating pane.
+    scheduleKillCurrentPane(opts.killAfterSeconds);
     return {
         status: 'spawned',
         paneId,
         message: `handed off to pane ${paneId}; this pane will close in ${opts.killAfterSeconds}s`,
     };
 }
-/**
- * Spawn a side-pane `claude` reviewer. Blocks until the reviewer calls
- * `crtr agent submit <content>`, the 10-min budget elapses, or the pane is closed.
- *
- * No custom system prompt — the task is delivered as the first user message
- * so the reviewer is a normal Claude session running a single task.
- */
-export async function spawnSidePaneReview(opts) {
-    if (!isInTmux()) {
-        throw general('side-pane review requires tmux (TMUX env var not set)');
-    }
-    const session = createSession();
-    const timeoutMs = opts.timeoutMs;
-    const cwd = opts.cwd;
-    const claudeCmd = [
-        'claude',
-        '-p',
-        '--dangerously-skip-permissions',
-        shellQuote(opts.prompt),
-    ].join(' ');
-    // After claude exits, sleep briefly so the watcher can confirm submission.
-    // The watcher kills the pane anyway once content arrives.
-    const fullCmd = `cd ${shellQuote(cwd)} && ${claudeCmd}; sleep 2`;
-    const splitArgs = [
-        'split-window',
-        '-h',
-        '-P',
-        '-F',
-        '#{pane_id}',
-        '-e',
-        `CRTR_SESSION=${session.id}`,
-        '-e',
-        `CRTR_PIPE=${session.dir}`,
-        fullCmd,
-    ];
-    const split = spawnSync('tmux', splitArgs, { encoding: 'utf8' });
-    if (split.status !== 0) {
-        rmSync(session.dir, { recursive: true, force: true });
-        const stderrText = split.stderr.trim();
-        const msg = stderrText === '' ? 'tmux split-window failed' : stderrText;
-        return {
-            status: 'spawn-failed',
-            content: msg,
-            sessionDir: session.dir,
-        };
-    }
-    const paneId = split.stdout.trim();
-    const contentPath = join(session.dir, 'content');
-    const result = await waitForResult(session.dir, contentPath, paneId, timeoutMs);
-    if (paneAlive(paneId))
-        killPane(paneId);
-    try {
-        rmSync(session.dir, { recursive: true, force: true });
-    }
-    catch {
-        /* noop */
-    }
-    return { ...result, paneId, sessionDir: session.dir };
-}
-function metaPath(sessionDir) {
-    return join(sessionDir, 'meta.json');
-}
-function writeSessionMeta(sessionDir, meta) {
-    writeFileSync(metaPath(sessionDir), JSON.stringify(meta), 'utf8');
-}
-function readSessionMeta(sessionDir) {
-    const p = metaPath(sessionDir);
-    if (!existsSync(p))
-        return undefined;
-    try {
-        return JSON.parse(readFileSync(p, 'utf8'));
-    }
-    catch {
-        return undefined;
-    }
-}
-export function sessionDirForId(sessionId) {
-    return join(sessionRoot(), sessionId);
-}
-export function countPanesInCurrentWindow() {
-    // -t '' targets the current window of the current session.
-    const result = spawnSync('tmux', ['list-panes', '-F', '#{pane_id}'], {
-        encoding: 'utf8',
-    });
-    if (result.status !== 0)
-        return 0;
-    return result.stdout.split('\n').filter((line) => line.trim() !== '').length;
-}
 /**
  * Async sibling spawn. Launches a claude session in a new tmux pane or window
  * (depending on current pane count vs maxPanesPerWindow). Returns immediately
- * with the crtr session id; the parent stays alive.
+ * with the pane id; the parent stays alive.
  *
- * If `fork` is set, uses `claude --resume <id> --fork-session` so the child
- * gets a fresh session id and does not contend with the parent's JSONL.
+ * If `fork` is set, uses `claude --resume <id> --fork-session`.
  */
 export function spawnAgent(opts) {
     if (!isInTmux()) {
         return {
             status: 'not-in-tmux',
-            message: 'crtr agent requires tmux (TMUX env var not set)',
+            message: 'crtr job requires tmux (TMUX env var not set)',
         };
     }
-    const session = createSession();
     const claudeParts = ['claude'];
     if (opts.fork !== undefined) {
         claudeParts.push('--resume', opts.fork.sessionId, '--fork-session');
     }
     claudeParts.push('--dangerously-skip-permissions', shellQuote(opts.prompt));
     const claudeCmd = claudeParts.join(' ');
+    const fullCmd = wrapperCmd(claudeCmd, opts.jobId);
     const useNewWindow = countPanesInCurrentWindow() >= opts.maxPanesPerWindow;
     const placement = useNewWindow ? 'new-window' : 'split-window';
     const tmuxArgs = [placement];
     if (!useNewWindow)
         tmuxArgs.push('-h');
-    tmuxArgs.push('-P', '-F', '#{pane_id}', '-c', opts.cwd, '-e', `CRTR_SESSION=${session.id}`, '-e', `CRTR_PIPE=${session.dir}`, claudeCmd);
+    tmuxArgs.push('-P', '-F', '#{pane_id}', '-c', opts.cwd, '-e', `CRTR_JOB_ID=${opts.jobId}`, fullCmd);
     const split = spawnSync('tmux', tmuxArgs, { encoding: 'utf8' });
     if (split.status !== 0) {
-        rmSync(session.dir, { recursive: true, force: true });
         const stderrText = split.stderr.trim();
         const msg = stderrText === '' ? `tmux ${placement} failed` : stderrText;
         return { status: 'spawn-failed', message: msg };
     }
     const paneId = split.stdout.trim();
-    writeSessionMeta(session.dir, {
-        paneId,
-        createdAt: Date.now(),
-        kind: opts.fork !== undefined ? 'fork' : 'new',
-    });
     return {
         status: 'spawned',
-        sessionId: session.id,
         paneId,
         placement,
-        message: `agent ${session.id} spawned in pane ${paneId} (${placement})`,
+        message: `agent spawned in pane ${paneId} (${placement})`,
     };
 }
-/**
- * Block until the agent identified by `sessionId` calls `crtr agent submit`.
- * Returns content + status. Cleans up the session dir on completion.
- */
-export async function awaitSession(sessionId, opts) {
-    const sessionDir = sessionDirForId(sessionId);
-    if (!existsSync(sessionDir)) {
-        throw notFound(`agent session not found: ${sessionId} (looked at ${sessionDir})`);
-    }
-    const meta = readSessionMeta(sessionDir);
-    let paneId;
-    if (meta !== undefined && meta.paneId !== '') {
-        paneId = meta.paneId;
-    }
-    const contentPath = join(sessionDir, 'content');
-    const result = await waitForResult(sessionDir, contentPath, paneId, opts.timeoutMs);
-    if (opts.killPane && paneId !== undefined && paneAlive(paneId))
-        killPane(paneId);
-    try {
-        rmSync(sessionDir, { recursive: true, force: true });
-    }
-    catch {
-        /* noop */
-    }
-    return { ...result, paneId, sessionDir };
-}
-function waitForResult(sessionDir, contentPath, paneId, timeoutMs) {
-    return new Promise((resolve) => {
-        let settled = false;
-        const finish = (status, content) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timeoutTimer);
-            if (paneTimer !== undefined)
-                clearInterval(paneTimer);
-            try {
-                watcher.close();
-            }
-            catch {
-                /* noop */
-            }
-            resolve({ status, content });
-        };
-        const watcher = watch(sessionDir, (_event, name) => {
-            if (name === 'content' && existsSync(contentPath)) {
-                const content = readFileSync(contentPath, 'utf8');
-                finish('submitted', content);
-            }
-        });
-        if (existsSync(contentPath)) {
-            finish('submitted', readFileSync(contentPath, 'utf8'));
-            return;
-        }
-        const timeoutTimer = setTimeout(() => {
-            finish('timeout', '');
-        }, timeoutMs);
-        let paneTimer;
-        if (paneId !== undefined) {
-            const watchedPaneId = paneId;
-            paneTimer = setInterval(() => {
-                if (!paneAlive(watchedPaneId)) {
-                    if (existsSync(contentPath)) {
-                        finish('submitted', readFileSync(contentPath, 'utf8'));
-                    }
-                    else {
-                        finish('pane-closed', '');
-                    }
-                }
-            }, PANE_POLL_MS);
-        }
-    });
-}