@crouton-kit/crouter 0.3.8 → 0.3.11

package/dist/core/command.js

@@ -17,14 +17,60 @@ export function defineLeaf(opts) {
         kind: 'leaf',
         name: opts.name,
         help: opts.help,
+        slash: opts.slash,
         run: opts.run,
     };
 }
 export function defineBranch(opts) {
-    return { kind: 'branch', name: opts.name, help: opts.help, children: opts.children };
+    return {
+        kind: 'branch',
+        name: opts.name,
+        help: opts.help,
+        rootEntry: opts.rootEntry,
+        slash: opts.slash,
+        children: opts.children,
+    };
 }
+/** Walk the whole tree and collect every node's SlashSpec (depth-first). Used
+ *  by the bootstrap to discover which commands opted into slash exposure. */
+export function collectSlashSpecs(root) {
+    const out = [];
+    const visit = (node) => {
+        if (node.slash !== undefined)
+            out.push(node.slash);
+        if (node.kind === 'branch')
+            for (const c of node.children)
+                visit(c);
+    };
+    for (const s of root.subtrees)
+        visit(s);
+    return out;
+}
+/** Assemble root -h from the subtrees themselves. Root owns only the tagline
+ *  and globals; every subtree's concept line, selection rubric, and dynamic
+ *  block come from its own RootEntry. A subtree without a rootEntry does not
+ *  appear in root -h — declaring the parent-level representation is how a
+ *  subtree opts into being listed. */
 export function defineRoot(opts) {
-    return { kind: 'root', help: opts.help, subtrees: opts.subtrees };
+    // Each listed subtree becomes one <name> block at root, assembled straight
+    // from its RootEntry. Root composes nothing and hardcodes nothing: add a
+    // subtree with a rootEntry and it surfaces; its concept, rubric, state tag,
+    // and dynamic block all travel with it.
+    const commands = opts.subtrees
+        .filter((s) => s.rootEntry !== undefined)
+        .map((s) => ({
+        name: s.name,
+        concept: s.rootEntry.concept,
+        desc: s.rootEntry.desc,
+        useWhen: s.rootEntry.useWhen,
+        dynamicState: s.rootEntry.dynamicState,
+    }));
+    const help = {
+        tagline: opts.tagline,
+        commands,
+        globals: opts.globals,
+    };
+    return { kind: 'root', help, subtrees: opts.subtrees };
 }
 /** Validate and return child names for an unknown-path error. */
 function childNames(node) {
@@ -35,10 +81,12 @@ function childNames(node) {
     return [];
 }
 /** Walk argv tokens to the deepest matched node.
- *  Returns { node, remaining } where remaining are unconsumed tokens.
+ *  Returns { node, path, remaining } where path is the sequence of matched node
+ *  names from root (excluding root itself) and remaining are unconsumed tokens.
  *  -h / --help tokens are NOT consumed here — the caller checks for them. */
-function walk(root, tokens) {
+export function walk(root, tokens) {
     let current = root;
+    const path = [];
     let i = 0;
     while (i < tokens.length) {
         const token = tokens[i];
@@ -50,6 +98,7 @@ function walk(root, tokens) {
             if (nextNode === undefined)
                 break;
             current = nextNode;
+            path.push(nextNode.name);
             i++;
         }
         else if (current.kind === 'branch') {
@@ -57,6 +106,7 @@ function walk(root, tokens) {
             if (nextNode === undefined)
                 break;
             current = nextNode;
+            path.push(nextNode.name);
             i++;
         }
         else {
@@ -64,7 +114,7 @@ function walk(root, tokens) {
             break;
         }
     }
-    return { node: current, remaining: tokens.slice(i) };
+    return { node: current, path, remaining: tokens.slice(i) };
 }
 function renderNode(node) {
     if (node.kind === 'root')
@@ -77,15 +127,13 @@ function helpRequested(remaining) {
     return remaining.some((t) => t === '-h' || t === '--help');
 }
 /** Build a structured unknown-path error. Names valid children of the deepest
- *  matched node and names the entry command per the spec. No fuzzy matching. */
-function unknownPathError(node, bad) {
+ *  matched node and names the entry command per the spec. The entry command is
+ *  the full path to the matched node (not just its local name), so the recovery
+ *  hint is a command that actually exists. No fuzzy matching. */
+export function unknownPathError(node, path, bad) {
     const valid = childNames(node);
     const validStr = valid.length > 0 ? valid.join(', ') : '(none)';
-    const entryCmd = node.kind === 'root'
-        ? 'crtr -h'
-        : node.kind === 'branch'
-            ? `crtr ${node.name} -h`
-            : 'crtr -h';
+    const entryCmd = path.length > 0 ? `crtr ${path.join(' ')} -h` : 'crtr -h';
     return new CrtrError('unknown_path', `unknown subcommand: ${bad}`, ExitCode.USAGE, {
         received: bad,
         next: `Valid children: ${validStr}. Run \`${entryCmd}\` for the full list.`,
@@ -257,7 +305,7 @@ export async function runCli(root, argv) {
         process.stdout.write(renderRoot(root.help) + '\n');
         process.exit(ExitCode.SUCCESS);
     }
-    const { node, remaining } = walk(root, tokens);
+    const { node, path, remaining } = walk(root, tokens);
     try {
         // Help anywhere in remaining tokens → print node help and exit
         if (helpRequested(remaining)) {
@@ -267,7 +315,7 @@ export async function runCli(root, argv) {
         // Bare branch or bare root (no -h, but no leaf selected) → help surface
         if (node.kind === 'root' || node.kind === 'branch') {
             if (remaining.length > 0) {
-                throw unknownPathError(node, remaining[0]);
+                throw unknownPathError(node, path, remaining[0]);
             }
             process.stdout.write(renderNode(node) + '\n');
             process.exit(ExitCode.SUCCESS);

package/dist/core/frontmatter.d.ts

@@ -5,4 +5,14 @@ export interface ParsedFrontmatter {
     raw: string;
 }
 export declare function parseFrontmatter(source: string): ParsedFrontmatter;
+export interface ParsedFrontmatterGeneric {
+    /** Raw, uncoerced key/value record from the YAML block (null when absent). */
+    data: Record<string, unknown> | null;
+    body: string;
+    raw: string;
+}
+/** Like parseFrontmatter but returns the raw key/value record instead of
+ *  coercing to SkillFrontmatter. Used by consumers (e.g. subagents) that read
+ *  fields skills don't declare, such as `tools` and `model`. */
+export declare function parseFrontmatterGeneric(source: string): ParsedFrontmatterGeneric;
 export declare function serializeFrontmatter(data: SkillFrontmatter): string;

package/dist/core/frontmatter.js

@@ -7,9 +7,30 @@ export function parseFrontmatter(source) {
     }
     const raw = match[1];
     const body = source.slice(match[0].length);
-    return { data: parseSimpleYaml(raw), body, raw };
+    return { data: toSkillFrontmatter(parseYamlRecord(raw)), body, raw };
 }
-function parseSimpleYaml(yaml) {
+/** Like parseFrontmatter but returns the raw key/value record instead of
+ *  coercing to SkillFrontmatter. Used by consumers (e.g. subagents) that read
+ *  fields skills don't declare, such as `tools` and `model`. */
+export function parseFrontmatterGeneric(source) {
+    const match = source.match(FRONTMATTER_RE);
+    if (!match) {
+        return { data: null, body: source, raw: '' };
+    }
+    const raw = match[1];
+    const body = source.slice(match[0].length);
+    return { data: parseYamlRecord(raw), body, raw };
+}
+function toSkillFrontmatter(out) {
+    const fm = {
+        name: typeof out.name === 'string' ? out.name : '',
+        description: typeof out.description === 'string' ? out.description : undefined,
+        keywords: Array.isArray(out.keywords) ? out.keywords : undefined,
+        type: isSkillType(out.type) ? out.type : undefined,
+    };
+    return fm;
+}
+function parseYamlRecord(yaml) {
     const lines = yaml.split(/\r?\n/);
     const out = {};
     let i = 0;
@@ -123,13 +144,7 @@ function parseSimpleYaml(yaml) {
         out[key] = stripQuotes(rest);
         i++;
     }
-    const fm = {
-        name: typeof out.name === 'string' ? out.name : '',
-        description: typeof out.description === 'string' ? out.description : undefined,
-        keywords: Array.isArray(out.keywords) ? out.keywords : undefined,
-        type: isSkillType(out.type) ? out.type : undefined,
-    };
-    return fm;
+    return out;
 }
 function stripQuotes(s) {
     if ((s.startsWith('"') && s.endsWith('"')) || (s.startsWith("'") && s.endsWith("'"))) {

package/dist/core/help.d.ts

@@ -47,17 +47,40 @@ export interface ContextFileParam {
     shape?: string;
 }
 export type InputParam = PositionalParam | FlagParam | StdinParam | ContextFileParam;
+/** A subtree's self-description at the parent (root) level. Each subtree owns
+ *  the content that represents it one level up: its vocabulary line, its
+ *  selection rubric, and any bounded block it contributes to the parent's -h.
+ *  defineRoot assembles the root help from these — root never hardcodes a
+ *  subtree's representation. See cli-design "Each node owns its parent-level
+ *  representation". */
+export interface RootEntry {
+    /** One-line vocabulary desc — what this subtree is. Rendered first in the
+     *  subtree's <name> block at root. */
+    concept: string;
+    /** Operations summary (verb list). Carried for completeness; the root block
+     *  leads with concept + rubric, so this is available but not rendered. */
+    desc: string;
+    /** The selection rubric — `use when X` in the subtree's <name> block. */
+    useWhen: string;
+    /** Optional bounded block this subtree contributes to its <name> block at
+     *  root. Returns a complete self-named state element (build it with
+     *  stateBlock), e.g. `<skills count="42">…</skills>`. Aggregate, never an
+     *  unbounded enumeration on a cold path. Soft-fails to omission on
+     *  null/throw. */
+    dynamicState?: () => string | null;
+}
 export interface RootHelp {
     tagline: string;
-    /** Vocabulary block — rendered before subtrees. */
-    concepts: {
-        name: string;
-        desc: string;
-    }[];
-    subtrees: {
+    /** One entry per listed subtree. Each renders as its own <name> XML block at
+     *  root, carrying the subtree's concept, selection rubric, and any nested
+     *  runtime-state block. Assembled from subtrees' RootEntry by defineRoot;
+     *  root hardcodes none of it. */
+    commands: {
         name: string;
+        concept: string;
         desc: string;
         useWhen: string;
+        dynamicState?: () => string | null;
     }[];
     globals: {
         name: string;
@@ -69,8 +92,9 @@ export interface BranchHelp {
     summary: string;
     /** Local lifecycle/model line that extends the parent definition. */
     model?: string;
-    /** Bounded runtime aggregate, e.g. "Current: 2 draft, 1 active".
-     *  Renderer soft-fails to omission if this returns null or throws. */
+    /** Bounded runtime aggregate as a complete self-named state element (build
+     *  it with stateBlock), e.g. `<skills count="42">…</skills>`. Renderer
+     *  soft-fails to omission if this returns null or throws. */
     dynamicState?: () => string | null;
     children: {
         name: string;
@@ -93,6 +117,13 @@ export interface LeafHelp {
      *  leaves use exactly: ["None. Read-only."] */
     effects: string[];
 }
+/** Build a self-named runtime-state element: `<tag attr="v">body</tag>`. The
+ *  subtree that owns the state authors it through this, so the tag name and any
+ *  scalar metadata (e.g. a count) travel with the data and render identically
+ *  at every level the block appears. The tag name carries the label, so the
+ *  body never repeats it. Attribute values are controlled (counts, short
+ *  tokens) and not escaped. */
+export declare function stateBlock(tag: string, attrs: Record<string, string | number>, body: string): string;
 export declare function renderRoot(h: RootHelp): string;
 export declare function renderBranch(h: BranchHelp): string;
 export declare function renderLeafArgv(h: LeafHelp): string;

package/dist/core/help.js

@@ -5,6 +5,30 @@
 // ---------------------------------------------------------------------------
 // Internal helpers
 // ---------------------------------------------------------------------------
+/** Build a self-named runtime-state element: `<tag attr="v">body</tag>`. The
+ *  subtree that owns the state authors it through this, so the tag name and any
+ *  scalar metadata (e.g. a count) travel with the data and render identically
+ *  at every level the block appears. The tag name carries the label, so the
+ *  body never repeats it. Attribute values are controlled (counts, short
+ *  tokens) and not escaped. */
+export function stateBlock(tag, attrs, body) {
+    const a = Object.entries(attrs)
+        .map(([k, v]) => ` ${k}="${v}"`)
+        .join('');
+    return `<${tag}${a}>\n${body}\n</${tag}>`;
+}
+/** Evaluate a dynamicState hook, soft-failing to null on throw or empty. */
+function evalDynamic(fn) {
+    if (fn === undefined)
+        return null;
+    try {
+        const s = fn();
+        return s !== null && s !== '' ? s : null;
+    }
+    catch {
+        return null;
+    }
+}
 /** Return the longest string length in an array of names. */
 function maxLen(names) {
     let max = 0;
@@ -23,27 +47,38 @@ function pad(s, width) {
 // ---------------------------------------------------------------------------
 const IO_CONTRACT = 'I/O contract: flags and positional args on input, JSON on stdout (JSONL for streams).\n' +
     'Exit 0 on success, non-zero on failure. Schemas appear at leaf -h.';
+// Behavioral instruction (not a schema) — engrained in the appended system
+// prompt so the model treats unfamiliar capabilities as a cue to discover the
+// contract, never to guess. Lives in the root guide, outside any leaf -h.
+const CAPABILITY_DISCOVERY = "If the user mentions or implies a crtr capability you don't fully understand, " +
+    'do not guess or assume it is unsupported — run `-h` on the relevant command ' +
+    '(append it anywhere along the path) to read the contract before acting.';
 export function renderRoot(h) {
     const lines = [];
     lines.push(`${h.tagline}`);
     lines.push('');
-    // Concepts block
-    lines.push('Concepts');
-    const cNameW = maxLen(h.concepts.map((c) => c.name));
-    for (const c of h.concepts) {
-        lines.push(`  ${pad(c.name, cNameW)}  ${c.desc}`);
-    }
-    lines.push('');
-    // Subtrees block
-    lines.push('Subtrees');
-    const sNameW = maxLen(h.subtrees.map((s) => s.name));
-    // Align desc column so "| use when X" starts at a consistent offset
-    const sDescW = maxLen(h.subtrees.map((s) => s.desc));
-    for (const s of h.subtrees) {
-        lines.push(`  ${pad(s.name, sNameW)}  ${pad(s.desc, sDescW)}  | use when ${s.useWhen}`);
+    // Each subtree is one <command name="…"> block. The uniform wrapper states
+    // "this is a command you invoke as `crtr <name>`" — so the model reads them
+    // by one rule, and a nested state element (which is never a <command>) can't
+    // be mistaken for a sibling command. Inside: the concept (what it is), the
+    // selection rubric (when to pick it), then any self-named state element
+    // grouped with the command it belongs to. Once injected into a system prompt,
+    // each block reads as one self-contained concern domain. Header (tagline) and
+    // footer (Globals + I/O contract + capability-discovery rule) are the only
+    // non-command areas. Two levels of nesting: <command> → <state>.
+    for (const c of h.commands) {
+        lines.push(`<command name="${c.name}">`);
+        lines.push(c.concept);
+        lines.push(`use when ${c.useWhen}`);
+        // dynamicState returns a complete self-named element (e.g.
+        // <skills count="42">…</skills>) — emit it as-is, nested in the command.
+        const state = evalDynamic(c.dynamicState);
+        if (state !== null)
+            lines.push(state);
+        lines.push('</command>');
+        lines.push('');
     }
-    lines.push('');
-    // Globals block
+    // Globals block (footer)
     lines.push('Globals');
     const gNameW = maxLen(h.globals.map((g) => g.name));
     for (const g of h.globals) {
@@ -51,6 +86,8 @@ export function renderRoot(h) {
     }
     lines.push('');
     lines.push(IO_CONTRACT);
+    lines.push('');
+    lines.push(CAPABILITY_DISCOVERY);
     return lines.join('\n');
 }
 // ---------------------------------------------------------------------------
@@ -59,25 +96,20 @@ export function renderRoot(h) {
 export function renderBranch(h) {
     const lines = [];
     lines.push(`${h.name}: ${h.summary}.`);
+    // Dynamic content leads — the live aggregate (e.g. the <skills> catalog)
+    // renders right after the name, before the hardcoded model prose, so current
+    // state is read first. The subtree authors the whole element, so the same
+    // self-named block appears identically at root and at `skill -h`.
+    const branchState = evalDynamic(h.dynamicState);
+    if (branchState !== null) {
+        // dynamicState returns a complete self-named element — emit as-is.
+        lines.push('');
+        lines.push(branchState);
+    }
     if (h.model !== undefined) {
+        lines.push('');
         lines.push(h.model);
     }
-    // Dynamic state — soft-fail to omission. Rendered as its own block,
-    // blank-line separated from the summary, so a multi-line runtime
-    // aggregate (e.g. the loaded-skills catalog) reads cleanly.
-    if (h.dynamicState !== undefined) {
-        let state = null;
-        try {
-            state = h.dynamicState();
-        }
-        catch {
-            // soft-fail: omit the block
-        }
-        if (state !== null && state !== '') {
-            lines.push('');
-            lines.push(state);
-        }
-    }
     lines.push('');
     lines.push('Branches');
     const nameW = maxLen(h.children.map((c) => c.name));

package/dist/core/jobs.d.ts

@@ -1,4 +1,4 @@
-type TerminalStatus = 'done' | 'failed' | 'canceled';
+type TerminalStatus = 'done' | 'failed' | 'canceled' | 'closed';
 type JobState = 'live' | TerminalStatus;
 type LogLevel = 'debug' | 'info' | 'warn' | 'error';
 /**
@@ -16,6 +16,11 @@ export declare function createJob(kind: string, opts: {
  * Record the tmux pane hosting a detached worker so `cancelJob` can kill it.
  */
 export declare function recordJobPane(jobId: string, paneId: string): void;
+/**
+ * Record the pid of a detached worker (e.g. a headless background agent) so
+ * jobStatus can mark the job failed if the process dies without a result.
+ */
+export declare function recordJobPid(jobId: string, pid: number): void;
 /**
  * Append one event line to log.jsonl. Does NOT throw if jobId doesn't exist —
  * a crashed writer should not further corrupt state; use a guard at the call site.
@@ -50,9 +55,10 @@ export declare function writeMarkdownResult(jobId: string, body: string, termina
  *   - JSON path:     { status, result: object }
  *   - Markdown path: { status, result_md: string, reason?: string }
  *   - Timeout:       { status: 'timeout' }
+ *   - Closed:        pane vanished with no result → status 'closed'
  */
 export interface ReadResultResponse {
-    status: 'done' | 'failed' | 'canceled' | 'timeout';
+    status: 'done' | 'failed' | 'canceled' | 'closed' | 'timeout';
     result?: object;
     result_md?: string;
     reason?: string;

package/dist/core/jobs.js

@@ -9,6 +9,13 @@
 //   result.md    — agent submissions (markdown body + YAML frontmatter). Written atomically.
 //   result.json  — programmatic submissions (structured object). Written atomically.
 // Either result file's APPEARANCE is the completion signal. Exactly one is written per job.
+//
+// A worker is not required to submit. Besides an explicit submit, a job becomes
+// terminal when (a) the wrapper shell's `crtr job _fail` runs on a clean exit,
+// or (b) the hosting tmux pane is closed — which sends SIGHUP so (a) never runs.
+// Case (b) is reaped here: when a live job's recorded pane is gone and no result
+// exists, we write a `closed` result (terminal, but distinct from `failed`) so
+// the job stops being a zombie without claiming an outcome we can't know.
 import { existsSync, mkdirSync, appendFileSync, readFileSync, writeFileSync, renameSync, readdirSync, statSync, } from 'node:fs';
 import { watch } from 'node:fs';
 import { spawnSync } from 'node:child_process';
@@ -87,6 +94,56 @@ function pidAlive(pid) {
         return false;
     }
 }
+/**
+ * Set of every tmux pane id across all sessions on the running server. Empty
+ * when no server is running (→ every recorded pane is treated as gone).
+ *
+ * This bridges tmux's pane lifecycle to the job registry. A worker whose pane
+ * is closed/killed receives SIGHUP, so the wrapper shell's `crtr job _fail`
+ * never runs and the job would otherwise stay `live` forever (a zombie). We
+ * detect the vanished pane and reap the job instead.
+ */
+function allTmuxPaneIds() {
+    const set = new Set();
+    const r = spawnSync('tmux', ['list-panes', '-a', '-F', '#{pane_id}'], { encoding: 'utf8' });
+    if (r.status !== 0 || typeof r.stdout !== 'string')
+        return set;
+    for (const line of r.stdout.split('\n')) {
+        const t = line.trim();
+        if (t !== '')
+            set.add(t);
+    }
+    return set;
+}
+/**
+ * Reap a job whose hosting tmux pane has disappeared. Acts only when the job is
+ * still `live`, has a recorded pane, and has produced no result file. Writes a
+ * terminal `closed` result so the job stops being a zombie and every reader
+ * (status, list, result --wait) agrees. `closed` is distinct from `failed`: we
+ * don't know the outcome, only that the pane is gone. Returns true if it reaped.
+ *
+ * `panes` lets a caller reuse a single tmux query across many jobs (listJobs).
+ */
+function reapIfPaneDead(meta, panes) {
+    if (meta.status !== 'live')
+        return false;
+    if (meta.pane_id === undefined || meta.pane_id === '')
+        return false;
+    if (existingResultPath(meta.job_id) !== null)
+        return false;
+    const set = panes ?? allTmuxPaneIds();
+    if (set.has(meta.pane_id))
+        return false;
+    try {
+        writeMarkdownResult(meta.job_id, '', 'closed', 'worker pane closed before submitting a result');
+    }
+    catch {
+        return false;
+    }
+    return true;
+}
+/** Poll cadence (ms) for detecting a closed worker pane during result --wait. */
+const PANE_POLL_MS = 2000;
 const LEVEL_RANK = {
     debug: 0,
     info: 1,
@@ -126,6 +183,15 @@ export function recordJobPane(jobId, paneId) {
     meta.pane_id = paneId;
     writeMeta(jobId, meta);
 }
+/**
+ * Record the pid of a detached worker (e.g. a headless background agent) so
+ * jobStatus can mark the job failed if the process dies without a result.
+ */
+export function recordJobPid(jobId, pid) {
+    const meta = readMeta(jobId);
+    meta.pid = pid;
+    writeMeta(jobId, meta);
+}
 /**
  * Append one event line to log.jsonl. Does NOT throw if jobId doesn't exist —
  * a crashed writer should not further corrupt state; use a guard at the call site.
@@ -275,11 +341,16 @@ export function readResult(jobId, opts = {}) {
     }
     return new Promise((resolve) => {
         let settled = false;
+        let timer;
+        let poll;
         const finish = (response) => {
             if (settled)
                 return;
             settled = true;
-            clearTimeout(timer);
+            if (timer !== undefined)
+                clearTimeout(timer);
+            if (poll !== undefined)
+                clearInterval(poll);
             try {
                 watcher.close();
             }
@@ -299,9 +370,33 @@ export function readResult(jobId, opts = {}) {
             finish(parseAt(path));
             return;
         }
-        const timer = setTimeout(() => {
-            finish({ status: 'timeout' });
-        }, opts.waitMs);
+        // fs.watch only fires on result files. A pane that closes without a submit
+        // produces no such event, so poll to reap it instead of hanging until the
+        // full timeout budget elapses.
+        poll = setInterval(() => {
+            const found = existingResultPath(jobId);
+            if (found !== null) {
+                finish(parseAt(found));
+                return;
+            }
+            try {
+                if (reapIfPaneDead(readMeta(jobId))) {
+                    const reaped = existingResultPath(jobId);
+                    if (reaped !== null)
+                        finish(parseAt(reaped));
+                }
+            }
+            catch { /* noop */ }
+        }, PANE_POLL_MS);
+        // A non-finite budget (Infinity) means block until a result appears or the
+        // worker pane dies — used by `human review`, where the human may take an
+        // unbounded amount of time. The poll above still reaps a dead pane, so this
+        // never hangs forever on a closed pane.
+        if (Number.isFinite(opts.waitMs)) {
+            timer = setTimeout(() => {
+                finish({ status: 'timeout' });
+            }, opts.waitMs);
+        }
     });
 }
 /**
@@ -309,7 +404,10 @@ export function readResult(jobId, opts = {}) {
  * If a pid is recorded, is not alive, and no result file exists → 'failed'.
  */
 export function jobStatus(jobId) {
-    const meta = readMeta(jobId);
+    let meta = readMeta(jobId);
+    if (reapIfPaneDead(meta)) {
+        meta = readMeta(jobId);
+    }
     const age_s = (Date.now() - new Date(meta.created_at).getTime()) / 1000;
     let state = meta.status;
     if (state === 'live') {
@@ -363,6 +461,8 @@ export function listJobs() {
         return [];
     const entries = readdirSync(root);
     const jobs = [];
+    // One tmux query, reused to reap every job whose pane has vanished.
+    const panes = allTmuxPaneIds();
     for (const entry of entries) {
         const dir = join(root, entry);
         try {
@@ -371,7 +471,10 @@ export function listJobs() {
             const mp = join(dir, 'meta.json');
             if (!existsSync(mp))
                 continue;
-            const meta = JSON.parse(readFileSync(mp, 'utf8'));
+            let meta = JSON.parse(readFileSync(mp, 'utf8'));
+            if (reapIfPaneDead(meta, panes)) {
+                meta = JSON.parse(readFileSync(mp, 'utf8'));
+            }
             // Derive effective state (result file beats meta.status for live jobs).
             let state = meta.status;
             if (state === 'live') {