@crouton-kit/crouter 0.3.8 → 0.3.12

package/dist/core/jobs.js

@@ -1,462 +0,0 @@
-// Job / long-running-operation infrastructure.
-//
-// Files are the single source of truth. No in-memory registry. An agent picks
-// up a job by id across processes. Crashes recover by reading files.
-//
-// Layout: ${XDG_STATE_HOME or ~/.local/state}/crtr/jobs/<job_id>/
-//   meta.json    — written atomically on create; updated atomically on terminal transition.
-//   log.jsonl    — append-only event log.
-//   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.
-import { existsSync, mkdirSync, appendFileSync, readFileSync, writeFileSync, renameSync, readdirSync, statSync, } from 'node:fs';
-import { watch } from 'node:fs';
-import { spawnSync } from 'node:child_process';
-import { join } from 'node:path';
-import { homedir } from 'node:os';
-import { randomBytes } from 'node:crypto';
-import { notFound, general } from './errors.js';
-// ---------------------------------------------------------------------------
-// Paths
-// ---------------------------------------------------------------------------
-function jobsRoot() {
-    const xdg = process.env['XDG_STATE_HOME'];
-    const base = (xdg !== undefined && xdg !== '') ? xdg : join(homedir(), '.local', 'state');
-    return join(base, 'crtr', 'jobs');
-}
-function jobDir(jobId) {
-    return join(jobsRoot(), jobId);
-}
-function metaPath(jobId) {
-    return join(jobDir(jobId), 'meta.json');
-}
-function logPath(jobId) {
-    return join(jobDir(jobId), 'log.jsonl');
-}
-function resultJsonPath(jobId) {
-    return join(jobDir(jobId), 'result.json');
-}
-function resultMdPath(jobId) {
-    return join(jobDir(jobId), 'result.md');
-}
-/** Path of whichever result file currently exists, or null if neither does. */
-function existingResultPath(jobId) {
-    const md = resultMdPath(jobId);
-    if (existsSync(md))
-        return md;
-    const js = resultJsonPath(jobId);
-    if (existsSync(js))
-        return js;
-    return null;
-}
-// ---------------------------------------------------------------------------
-// Internal helpers
-// ---------------------------------------------------------------------------
-function generateJobId() {
-    const ts = Date.now().toString(36);
-    const rnd = randomBytes(4).toString('hex');
-    return `${ts}-${rnd}`;
-}
-function ensureJobsRoot() {
-    mkdirSync(jobsRoot(), { recursive: true });
-}
-function readMeta(jobId) {
-    const p = metaPath(jobId);
-    if (!existsSync(p)) {
-        throw notFound(`job not found: ${jobId}`, { job_id: jobId });
-    }
-    try {
-        return JSON.parse(readFileSync(p, 'utf8'));
-    }
-    catch {
-        throw general(`failed to parse meta.json for job ${jobId}`, { job_id: jobId });
-    }
-}
-function writeMeta(jobId, meta) {
-    const dir = jobDir(jobId);
-    const tmp = join(dir, '.meta.tmp');
-    writeFileSync(tmp, JSON.stringify(meta, null, 2), 'utf8');
-    renameSync(tmp, metaPath(jobId));
-}
-function pidAlive(pid) {
-    try {
-        process.kill(pid, 0);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-const LEVEL_RANK = {
-    debug: 0,
-    info: 1,
-    warn: 2,
-    error: 3,
-};
-// ---------------------------------------------------------------------------
-// Exported API
-// ---------------------------------------------------------------------------
-/**
- * Allocate a new job directory and write meta.json atomically.
- * Returns the job_id and the absolute directory path.
- */
-export function createJob(kind, opts) {
-    ensureJobsRoot();
-    const jobId = generateJobId();
-    const dir = jobDir(jobId);
-    mkdirSync(dir, { recursive: true });
-    const meta = {
-        job_id: jobId,
-        kind,
-        created_at: new Date().toISOString(),
-        cwd: opts.cwd,
-        status: 'live',
-    };
-    if (opts.pid !== undefined) {
-        meta.pid = opts.pid;
-    }
-    writeMeta(jobId, meta);
-    return { jobId, dir };
-}
-/**
- * Record the tmux pane hosting a detached worker so `cancelJob` can kill it.
- */
-export function recordJobPane(jobId, paneId) {
-    const meta = readMeta(jobId);
-    meta.pane_id = paneId;
-    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.
- */
-export function appendEvent(jobId, event) {
-    const p = logPath(jobId);
-    const line = {
-        ts: new Date().toISOString(),
-        level: event.level,
-        event: event.event,
-        message: event.message,
-    };
-    if (event.data !== undefined) {
-        line.data = event.data;
-    }
-    appendFileSync(p, JSON.stringify(line) + '\n', 'utf8');
-}
-/**
- * Atomically write result.json (structured object) and update meta.json status.
- * Used by programmatic callers (human, sys) that produce object results.
- * The result file's appearance is the completion signal — never inferred from log content.
- */
-export function writeResult(jobId, result, terminalStatus) {
-    const dir = jobDir(jobId);
-    if (!existsSync(dir)) {
-        throw notFound(`job not found: ${jobId}`, { job_id: jobId });
-    }
-    const payload = {
-        status: terminalStatus,
-        result,
-        written_at: new Date().toISOString(),
-    };
-    const tmp = join(dir, '.result.tmp');
-    writeFileSync(tmp, JSON.stringify(payload, null, 2), 'utf8');
-    renameSync(tmp, resultJsonPath(jobId));
-    const meta = readMeta(jobId);
-    meta.status = terminalStatus;
-    writeMeta(jobId, meta);
-}
-/**
- * Atomically write result.md (YAML frontmatter + markdown body) and update meta.json status.
- * Used by `crtr job submit` for agent-driven markdown results.
- */
-export function writeMarkdownResult(jobId, body, terminalStatus, reason) {
-    const dir = jobDir(jobId);
-    if (!existsSync(dir)) {
-        throw notFound(`job not found: ${jobId}`, { job_id: jobId });
-    }
-    const fm = {
-        status: terminalStatus,
-        written_at: new Date().toISOString(),
-    };
-    if (reason !== undefined && reason !== '') {
-        fm.reason = reason;
-    }
-    const content = `${renderFrontmatter(fm)}${body}`;
-    const tmp = join(dir, '.result.tmp');
-    writeFileSync(tmp, content, 'utf8');
-    renameSync(tmp, resultMdPath(jobId));
-    const meta = readMeta(jobId);
-    meta.status = terminalStatus;
-    writeMeta(jobId, meta);
-}
-/**
- * Render a small fixed-shape frontmatter block. We control writer and reader,
- * so a 3-key hand-rolled emitter is plenty — no YAML dep, no escaping surprises.
- * Values are plain strings; we double-quote `reason` to survive newlines/colons.
- */
-function renderFrontmatter(fm) {
-    const lines = ['---', `status: ${fm.status}`, `written_at: ${fm.written_at}`];
-    if (fm.reason !== undefined) {
-        const escaped = fm.reason.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
-        lines.push(`reason: "${escaped}"`);
-    }
-    lines.push('---', '');
-    return lines.join('\n');
-}
-/**
- * Parse the small fixed-shape frontmatter we emit. Tolerant of trailing
- * whitespace; returns `{ frontmatter, body }`. Throws if the document does not
- * start with `---\n` or no closing `---` is found.
- */
-function parseMarkdownResult(raw) {
-    if (!raw.startsWith('---\n') && !raw.startsWith('---\r\n')) {
-        throw new Error('result.md missing opening --- delimiter');
-    }
-    const afterOpen = raw.indexOf('\n') + 1;
-    const closeIdx = raw.indexOf('\n---', afterOpen);
-    if (closeIdx === -1) {
-        throw new Error('result.md missing closing --- delimiter');
-    }
-    const fmBlock = raw.slice(afterOpen, closeIdx);
-    // Body starts after the closing `---` line.
-    const afterCloseLine = raw.indexOf('\n', closeIdx + 1);
-    const body = afterCloseLine === -1 ? '' : raw.slice(afterCloseLine + 1);
-    const fm = {};
-    for (const line of fmBlock.split('\n')) {
-        const m = line.match(/^([a-z_]+):\s*(.*)$/);
-        if (m === null)
-            continue;
-        const key = m[1];
-        if (m[2] === undefined)
-            continue;
-        let val = m[2];
-        if (val.startsWith('"') && val.endsWith('"') && val.length >= 2) {
-            val = val.slice(1, -1).replace(/\\n/g, '\n').replace(/\\"/g, '"').replace(/\\\\/g, '\\');
-        }
-        if (key === 'status') {
-            fm.status = val;
-        }
-        else if (key === 'written_at') {
-            fm.written_at = val;
-        }
-        else if (key === 'reason') {
-            fm.reason = val;
-        }
-    }
-    if (fm.status === undefined || fm.written_at === undefined) {
-        throw new Error('result.md frontmatter missing status or written_at');
-    }
-    return { frontmatter: fm, body };
-}
-export function readResult(jobId, opts = {}) {
-    const dir = jobDir(jobId);
-    if (!existsSync(dir)) {
-        throw notFound(`job not found: ${jobId}`, { job_id: jobId });
-    }
-    function parseAt(path) {
-        const raw = readFileSync(path, 'utf8');
-        if (path.endsWith('.md')) {
-            const { frontmatter, body } = parseMarkdownResult(raw);
-            const out = { status: frontmatter.status, result_md: body };
-            if (frontmatter.reason !== undefined) {
-                out.reason = frontmatter.reason;
-            }
-            return out;
-        }
-        const parsed = JSON.parse(raw);
-        return { status: parsed.status, result: parsed.result };
-    }
-    const existing = existingResultPath(jobId);
-    if (existing !== null) {
-        return Promise.resolve(parseAt(existing));
-    }
-    if (opts.waitMs === undefined || opts.waitMs <= 0) {
-        return Promise.resolve({ status: 'timeout' });
-    }
-    return new Promise((resolve) => {
-        let settled = false;
-        const finish = (response) => {
-            if (settled)
-                return;
-            settled = true;
-            clearTimeout(timer);
-            try {
-                watcher.close();
-            }
-            catch { /* noop */ }
-            resolve(response);
-        };
-        const watcher = watch(dir, (_event, name) => {
-            if (name !== 'result.md' && name !== 'result.json')
-                return;
-            const path = existingResultPath(jobId);
-            if (path !== null) {
-                finish(parseAt(path));
-            }
-        });
-        const path = existingResultPath(jobId);
-        if (path !== null) {
-            finish(parseAt(path));
-            return;
-        }
-        const timer = setTimeout(() => {
-            finish({ status: 'timeout' });
-        }, opts.waitMs);
-    });
-}
-/**
- * Derive job state from meta.json, the result file, and the tail of log.jsonl.
- * If a pid is recorded, is not alive, and no result file exists → 'failed'.
- */
-export function jobStatus(jobId) {
-    const meta = readMeta(jobId);
-    const age_s = (Date.now() - new Date(meta.created_at).getTime()) / 1000;
-    let state = meta.status;
-    if (state === 'live') {
-        const existing = existingResultPath(jobId);
-        if (existing !== null) {
-            // Result file present but meta not yet updated (rare); trust the file.
-            try {
-                if (existing.endsWith('.md')) {
-                    const { frontmatter } = parseMarkdownResult(readFileSync(existing, 'utf8'));
-                    state = frontmatter.status;
-                }
-                else {
-                    const r = JSON.parse(readFileSync(existing, 'utf8'));
-                    state = r.status;
-                }
-            }
-            catch { /* leave as live */ }
-        }
-        else if (meta.pid !== undefined && !pidAlive(meta.pid)) {
-            state = 'failed';
-        }
-    }
-    // Tail of log for last_event.
-    let last_event = null;
-    const lp = logPath(jobId);
-    if (existsSync(lp)) {
-        const lines = readFileSync(lp, 'utf8').trimEnd().split('\n');
-        for (let i = lines.length - 1; i >= 0; i--) {
-            const line = lines[i];
-            if (line === undefined || line.trim() === '')
-                continue;
-            try {
-                const ev = JSON.parse(line);
-                last_event = { event: ev.event, ts: ev.ts };
-                break;
-            }
-            catch {
-                continue;
-            }
-        }
-    }
-    return { state, age_s, last_event };
-}
-/**
- * List all jobs sorted by created_at ascending. Pagination is applied by the
- * caller, not here.
- */
-export function listJobs() {
-    const root = jobsRoot();
-    if (!existsSync(root))
-        return [];
-    const entries = readdirSync(root);
-    const jobs = [];
-    for (const entry of entries) {
-        const dir = join(root, entry);
-        try {
-            if (!statSync(dir).isDirectory())
-                continue;
-            const mp = join(dir, 'meta.json');
-            if (!existsSync(mp))
-                continue;
-            const meta = JSON.parse(readFileSync(mp, 'utf8'));
-            // Derive effective state (result file beats meta.status for live jobs).
-            let state = meta.status;
-            if (state === 'live') {
-                const mdP = join(dir, 'result.md');
-                const jsP = join(dir, 'result.json');
-                try {
-                    if (existsSync(mdP)) {
-                        const { frontmatter } = parseMarkdownResult(readFileSync(mdP, 'utf8'));
-                        state = frontmatter.status;
-                    }
-                    else if (existsSync(jsP)) {
-                        const r = JSON.parse(readFileSync(jsP, 'utf8'));
-                        state = r.status;
-                    }
-                }
-                catch { /* leave as live */ }
-            }
-            jobs.push({ job_id: meta.job_id, kind: meta.kind, state, created_at: meta.created_at });
-        }
-        catch {
-            continue;
-        }
-    }
-    jobs.sort((a, b) => a.created_at.localeCompare(b.created_at));
-    return jobs;
-}
-/**
- * Read and filter log events. Ordering preserved. sinceTs/untilTs are ISO8601
- * strings; minLevel filters by severity rank (inclusive).
- */
-export function readLog(jobId, opts = {}) {
-    const dir = jobDir(jobId);
-    if (!existsSync(dir)) {
-        throw notFound(`job not found: ${jobId}`, { job_id: jobId });
-    }
-    const lp = logPath(jobId);
-    if (!existsSync(lp))
-        return [];
-    const raw = readFileSync(lp, 'utf8');
-    const results = [];
-    const minRank = opts.minLevel !== undefined ? LEVEL_RANK[opts.minLevel] : 0;
-    for (const line of raw.split('\n')) {
-        if (line.trim() === '')
-            continue;
-        let ev;
-        try {
-            ev = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        if (opts.sinceTs !== undefined && ev.ts < opts.sinceTs)
-            continue;
-        if (opts.untilTs !== undefined && ev.ts >= opts.untilTs)
-            continue;
-        if (LEVEL_RANK[ev.level] < minRank)
-            continue;
-        results.push(ev);
-    }
-    return results;
-}
-/**
- * Best-effort cancel: send SIGTERM to the recorded pid (if any), mark meta
- * canceled. Success means the signal was delivered, not that execution stopped.
- */
-export function cancelJob(jobId) {
-    const meta = readMeta(jobId);
-    if (meta.status !== 'live') {
-        // Already terminal — nothing to cancel.
-        return { canceled: false };
-    }
-    let signaled = false;
-    if (meta.pid !== undefined) {
-        try {
-            process.kill(meta.pid, 'SIGTERM');
-            signaled = true;
-        }
-        catch { /* pid gone or unpermitted */ }
-    }
-    if (meta.pane_id !== undefined && meta.pane_id !== '') {
-        const k = spawnSync('tmux', ['kill-pane', '-t', meta.pane_id], { encoding: 'utf8' });
-        if (k.status === 0)
-            signaled = true;
-    }
-    meta.status = 'canceled';
-    writeMeta(jobId, meta);
-    return { canceled: signaled };
-}

package/dist/prompts/agent.d.ts

@@ -1,18 +0,0 @@
-/**
- * First user message for a spec → plan handoff.
- *
- * Thin prompt: the worker discovers the full planning workflow by running
- * `crtr agent plan new -h`, then saves the plan via `crtr agent plan new`. This
- * avoids embedding the planPrompt() blob here and keeps the prompt in sync
- * with the live CLI without any coupling.
- */
-export declare function planHandoffPrompt(specPath: string, jobId: string): string;
-/**
- * First user message for a plan → implementation handoff.
- */
-export declare function implementHandoffPrompt(planPath: string, jobId: string): string;
-/**
- * First user message for a reviewer agent.
- * The reviewer submits via `crtr job submit` rather than `crtr agent submit`.
- */
-export declare function reviewerHandoffPrompt(artifactPath: string, artifactKind: 'plan' | 'spec', specPath: string | null, jobId: string): string;

package/dist/prompts/agent.js

@@ -1,153 +0,0 @@
-import { planReviewPrompt, specReviewPrompt } from './review.js';
-/**
- * First user message for a spec → plan handoff.
- *
- * Thin prompt: the worker discovers the full planning workflow by running
- * `crtr agent plan new -h`, then saves the plan via `crtr agent plan new`. This
- * avoids embedding the planPrompt() blob here and keeps the prompt in sync
- * with the live CLI without any coupling.
- */
-export function planHandoffPrompt(specPath, jobId) {
-    return `You were launched in a new tmux pane to turn an approved spec into a plan.
-
-**Spec:** ${specPath}
-
-1. Run \`crtr agent plan new -h\` to load the planning workflow and output schema.
-2. Read the spec end-to-end.
-3. Follow the workflow from step 1 and save the plan by passing the plan markdown to \`crtr agent plan new\` on stdin.
-4. When done, submit a short markdown report on stdin:
-
-\`\`\`bash
-crtr job submit ${jobId} <<'MD'
-Plan saved at <path>. <one-line summary of the plan's shape>.
-MD
-\`\`\`
-
-If you cannot complete the plan, submit a failure with a reason:
-
-\`\`\`bash
-crtr job submit ${jobId} --status failed --reason "<why>"
-\`\`\`
-
-Begin now.`;
-}
-/**
- * First user message for a plan → implementation handoff.
- */
-export function implementHandoffPrompt(planPath, jobId) {
-    return `You are executing an approved plan. For small plans, implement directly.
-For plans with parallelizable scale, orchestrate parallel subagents and
-coordinate them — don't write all the code yourself when the plan is
-structured to fan out.
-
-**Plan to implement:** ${planPath}
-
-## Phase 1: Read
-
-1. Read the plan end-to-end. If it references a spec, read that too.
-2. Read the files the plan names under "Files to modify / create" and
-   "Existing utilities to reuse" to ground yourself in current code.
-3. If the plan has task blocks with dependencies, extract the task list,
-   dependency graph, and integration contracts.
-
-## Phase 2: Scale
-
-Count the plan's **independent task groups** (tasks with no mutual
-dependencies that can run in parallel). Pick the strategy:
-
-| Independent groups | Files touched | Strategy |
-|-------------------|---------------|----------|
-| 1                 | 1–3           | **Implement directly.** Skip Phases 3–5; just execute the plan and go to Phase 6. |
-| 1–2               | 3–5           | Implement directly, or single subagent if you want parallelism with verification |
-| 2–4               | 5–15          | **2 parallel subagents** |
-| 4–8               | 10–30         | **3 parallel subagents** |
-| 8+                | 25+           | **4 parallel subagents** (cap) |
-
-Use the higher column to pick the tier. Never spawn more subagents than
-there are independent groups. **Bump one tier** if: tight cross-group
-interface coordination, mixed languages/frameworks, or both infra +
-application layers change.
-
-## Phase 3: Partition
-
-Group tasks into **disjoint sets** where:
-
-- Each group owns clear file boundaries — **no two groups edit the same files**.
-- Within a group, tasks are sequenced for one subagent to execute in order.
-- Across groups, dependencies become layers: dependent groups run *after*
-  their predecessors complete.
-
-If two tasks must touch the same file, sequence them in the same group.
-
-## Phase 4: Dispatch
-
-For each task group in the current dependency layer, dispatch a subagent
-in parallel via the Task tool. Use \`general-purpose\` by default; use
-\`devcore:programmer\` if the project has devcore installed.
-
-**Each subagent's prompt must include:**
-- The specific tasks from the plan it owns (paste verbatim)
-- The plan path: \`${planPath}\`
-- The spec path if one exists
-- The exact file ownership for this group
-- Integration contracts it produces or consumes (types, APIs, shapes)
-- **Constraint: do NOT run tests or typechecks** — other subagents may be
-  mid-edit. The orchestrator runs verification at layer boundaries.
-- Instruction to return when its tasks are complete, surfacing blockers
-
-## Phase 5: Coordinate
-
-Wait for all subagents in the current layer. Then:
-
-- If any reports a blocker, resolve it: fix yourself, adjust scope with
-  the user, or re-dispatch a corrected task. Don't proceed past the blocker.
-- Run the plan's verification for the just-finished layer (tests, manual
-  checks). Fix any failures before dispatching the next layer.
-- Dispatch the next layer.
-
-**Stay in the coordinator role.** Don't implement tasks yourself unless a
-subagent returns blocked work and the fix is small enough that re-dispatch
-would be slower.
-
-## Phase 6: Report and submit
-
-When all tasks complete and verification passes, submit a markdown report on stdin:
-
-\`\`\`bash
-crtr job submit ${jobId} <<'MD'
-**Summary:** <one-line summary of files touched>
-
-<optional further notes — verification output, surprises, callouts>
-MD
-\`\`\`
-
-If implementation fails, submit a failure with a reason:
-\`\`\`bash
-crtr job submit ${jobId} --status failed --reason "<why>"
-\`\`\`
-
-## Guardrails (apply to you AND your subagents)
-
-- **No redesign.** If the plan is wrong, surface the issue — do not
-  silently substitute your own approach.
-- **No scope expansion.** No drive-by refactors, no "while I'm here"
-  cleanup, no new abstractions the plan didn't request.
-- **Honor conventions.** Match each file's existing style, naming, and
-  patterns. Use the utilities the plan named.
-- **Commit only if the user asks.**
-
-Begin by reading the plan.`;
-}
-/**
- * First user message for a reviewer agent.
- * The reviewer submits via `crtr job submit` rather than `crtr agent submit`.
- */
-export function reviewerHandoffPrompt(artifactPath, artifactKind, specPath, jobId) {
-    const reviewBody = artifactKind === 'spec'
-        ? specReviewPrompt(artifactPath)
-        : planReviewPrompt(artifactPath, specPath);
-    const patched = reviewBody.replace('__CRTR_SUBMIT_INSTRUCTION__', `the submit command injected below. Pipe your full review markdown on stdin. The \`--kill-pane\` flag closes this reviewer pane after submission — keep it, do not drop it.\n\n\`\`\`bash\ncrtr job submit ${jobId} --kill-pane <<'MD'\n<your full review markdown — the same Status/Issues/Recommendations block you composed above>\nMD\n\`\`\`\n\nIf the artifact is too malformed to review, submit a failure instead:\n\n\`\`\`bash\ncrtr job submit ${jobId} --status failed --reason "<why>" --kill-pane\n\`\`\``);
-    return `${patched}
-
-After calling \`crtr job submit\`, your turn ends and the pane closes itself. Do NOT chat or summarize after submission.`;
-}

package/dist/prompts/debug.d.ts

@@ -1,8 +0,0 @@
-/**
- * First user message for a reproduction-only debug handoff.
- *
- * The agent's sole job is ONE failing integration test that reproduces the
- * reported bug. It never fixes the bug. Symmetric with the agent.ts handoff
- * builders: thin prompt, exact submit contract, turn ends after submit.
- */
-export declare function reproHandoffPrompt(issue: string, jobId: string): string;

package/dist/prompts/debug.js

@@ -1,44 +0,0 @@
-/**
- * First user message for a reproduction-only debug handoff.
- *
- * The agent's sole job is ONE failing integration test that reproduces the
- * reported bug. It never fixes the bug. Symmetric with the agent.ts handoff
- * builders: thin prompt, exact submit contract, turn ends after submit.
- */
-export function reproHandoffPrompt(issue, jobId) {
-    return `You were spawned solely to write ONE integration test that fails *because of this bug*:
-
-${issue}
-
-Rules — follow exactly:
-
-- Do NOT fix the bug. Do NOT modify product code to make a test pass. Your only output is a test.
-- The test must fail against the current code, and the failure must BE the reported bug — not an import error, a typo, or an unrelated assertion. Run it; paste the real failing output; confirm the failure mode matches the issue.
-- Prefer an integration test against real dependencies. Mocking away the broken component is theater and does NOT count as reproduction.
-- If you cannot produce a faithful failing test, GIVE UP. Never weaken assertions, hardcode expected values, or fabricate a clean-looking run — a tautological or over-mocked test is worse than none.
-
-Submit exactly one of the following via \`crtr job submit\`, then your turn ends — do not chat:
-
-Reproduced (markdown body on stdin):
-\`\`\`bash
-crtr job submit ${jobId} <<'MD'
-**Reproduces:** yes
-
-**Test path:** <path>
-
-**Test command:** \`<exact cmd>\`
-
-**Failure output:**
-\`\`\`
-<pasted failing output>
-\`\`\`
-MD
-\`\`\`
-
-Gave up (no faithful repro achievable):
-\`\`\`bash
-crtr job submit ${jobId} --status failed --reason "<why a faithful repro was not achievable>"
-\`\`\`
-
-Begin now.`;
-}