tickmarkr 1.68.0 → 1.70.0

package/dist/report/compare.js

@@ -0,0 +1,231 @@
+import { estimateCosts } from "./cost.js";
+export function hasRunStart(events) {
+    return events.some((e) => e.event === "run-start");
+}
+// First run-start's environment, fail-closed on a missing or malformed stamp.
+export function recordedEnvironment(events) {
+    for (const e of events) {
+        if (e.event !== "run-start")
+            continue;
+        const env = e.data.environment;
+        if (!env || typeof env !== "object" || Array.isArray(env))
+            return undefined;
+        const o = env;
+        if (typeof o.tickmarkrVersion !== "string" || typeof o.configHash !== "string")
+            return undefined;
+        if (!o.adapterVersions || typeof o.adapterVersions !== "object" || Array.isArray(o.adapterVersions))
+            return undefined;
+        const adapterVersions = {};
+        for (const [k, v] of Object.entries(o.adapterVersions)) {
+            if (typeof v !== "string")
+                return undefined;
+            adapterVersions[k] = v;
+        }
+        return { tickmarkrVersion: o.tickmarkrVersion, configHash: o.configHash, adapterVersions };
+    }
+    return undefined;
+}
+// Canonical identity string for the `recorded` field — configHash is the axis the acceptance
+// criteria name; full environment equality still decides .comparable.
+function envFingerprint(env) {
+    return env.configHash;
+}
+function envEqual(a, b) {
+    if (a.tickmarkrVersion !== b.tickmarkrVersion || a.configHash !== b.configHash)
+        return false;
+    const ak = Object.keys(a.adapterVersions).sort();
+    const bk = Object.keys(b.adapterVersions).sort();
+    if (ak.length !== bk.length)
+        return false;
+    for (let i = 0; i < ak.length; i++) {
+        if (ak[i] !== bk[i])
+            return false;
+        if (a.adapterVersions[ak[i]] !== b.adapterVersions[bk[i]])
+            return false;
+    }
+    return true;
+}
+// THE environment-identity comparator (criterion: reuses engagementComparable's shape).
+// unbound = either side lacks a usable stamp; mismatch = stamps disagree; comparable = equal.
+export function environmentComparable(baselineEnv, currentEnv) {
+    if (baselineEnv === undefined || currentEnv === undefined)
+        return { comparable: false, reason: "unbound" };
+    const recorded = envFingerprint(baselineEnv);
+    return envEqual(baselineEnv, currentEnv)
+        ? { comparable: true, recorded }
+        : { comparable: false, reason: "mismatch", recorded };
+}
+export function runMetrics(events, rows = [], cost = {}) {
+    const start = events.find((e) => e.event === "run-start");
+    const end = [...events].reverse().find((e) => e.event === "run-end");
+    let durationMs;
+    if (start && end) {
+        const from = Date.parse(start.ts);
+        const to = Date.parse(end.ts);
+        if (Number.isFinite(from) && Number.isFinite(to) && to >= from)
+            durationMs = to - from;
+    }
+    const gates = events.filter((e) => e.event === "gate-result");
+    const gatePass = gates.filter((e) => e.data.pass === true).length;
+    const gateFail = gates.filter((e) => e.data.pass === false).length;
+    let costUsd;
+    let costSum = 0;
+    let hasCost = false;
+    for (const p of estimateCosts(rows, cost)) {
+        if (p.apiUsd !== undefined) {
+            costSum += p.apiUsd;
+            hasCost = true;
+        }
+        else if (p.amortizedUsd) {
+            costSum += (p.amortizedUsd[0] + p.amortizedUsd[1]) / 2;
+            hasCost = true;
+        }
+    }
+    if (hasCost)
+        costUsd = Math.round(costSum * 1e6) / 1e6;
+    let tokensTotal;
+    let tokenSum = 0;
+    let hasTokens = false;
+    for (const r of rows) {
+        if (!r.tokens)
+            continue;
+        hasTokens = true;
+        const t = r.tokens;
+        tokenSum += t.input + t.output + (t.cacheRead ?? 0) + (t.cacheWrite ?? 0) + (t.reasoning ?? 0);
+    }
+    if (hasTokens)
+        tokensTotal = tokenSum;
+    return { durationMs, gatePass, gateFail, gateTotal: gates.length, costUsd, tokensTotal };
+}
+const n = (x) => x.toLocaleString("en-US");
+const EM = "—";
+function fmtDuration(ms) {
+    if (ms === undefined)
+        return EM;
+    const seconds = Math.round(ms / 1_000);
+    const minutes = Math.floor(seconds / 60);
+    return minutes ? `${minutes}m ${seconds % 60}s` : `${seconds}s`;
+}
+function fmtSignedDuration(ms) {
+    if (ms === undefined)
+        return EM;
+    if (ms === 0)
+        return "0s";
+    const sign = ms > 0 ? "+" : "-";
+    return `${sign}${fmtDuration(Math.abs(ms))}`;
+}
+function fmtUsd(v) {
+    if (v === undefined)
+        return EM;
+    return `$${v.toFixed(6)}`;
+}
+function fmtSignedUsd(v) {
+    if (v === undefined)
+        return EM;
+    if (v === 0)
+        return "$0.000000";
+    const sign = v > 0 ? "+" : "-";
+    return `${sign}$${Math.abs(v).toFixed(6)}`;
+}
+function fmtInt(v) {
+    if (v === undefined)
+        return EM;
+    return n(v);
+}
+function fmtSignedInt(v) {
+    if (v === undefined)
+        return EM;
+    if (v === 0)
+        return "0";
+    return v > 0 ? `+${n(v)}` : `-${n(Math.abs(v))}`;
+}
+function comparabilityLine(cmp, baselineEnv, currentEnv) {
+    if (cmp.comparable) {
+        return `full comparability (environment identity matches; configHash=${cmp.recorded})`;
+    }
+    if (cmp.reason === "unbound") {
+        return "comparability caveat — one or both runs lack a recorded environment identity; not apples-to-apples";
+    }
+    const base = baselineEnv?.configHash ?? EM;
+    const cur = currentEnv?.configHash ?? EM;
+    return `comparability caveat — environment identity disagrees (baseline configHash=${base} ≠ current configHash=${cur}; recorded baseline ${cmp.recorded}); not apples-to-apples`;
+}
+export function renderComparison(opts) {
+    const { runId, baselineRunId, comparability, baselineEnv, currentEnv, current, baseline, delta } = opts;
+    // Both run ids are always named so the reader knows which is the baseline.
+    const lines = [
+        `## Comparison`,
+        "",
+        `- **run:** ${runId}`,
+        `- **baseline:** ${baselineRunId}`,
+        `- **comparability:** ${comparabilityLine(comparability, baselineEnv, currentEnv)}`,
+        "",
+        "### Delta (current − baseline)",
+        "",
+        `| metric | baseline (${baselineRunId}) | current (${runId}) | delta |`,
+        `| --- | --- | --- | --- |`,
+        `| duration | ${fmtDuration(baseline.durationMs)} | ${fmtDuration(current.durationMs)} | ${fmtSignedDuration(delta.durationMs)} |`,
+        `| gate failures | ${fmtInt(baseline.gateFail)} | ${fmtInt(current.gateFail)} | ${fmtSignedInt(delta.gateFail)} |`,
+        `| gate pass rate | ${baseline.gateTotal ? `${baseline.gatePass}/${baseline.gateTotal}` : EM} | ${current.gateTotal ? `${current.gatePass}/${current.gateTotal}` : EM} | ${EM} |`,
+        `| cost | ${fmtUsd(baseline.costUsd)} | ${fmtUsd(current.costUsd)} | ${fmtSignedUsd(delta.costUsd)} |`,
+        `| tokens | ${fmtInt(baseline.tokensTotal)} | ${fmtInt(current.tokensTotal)} | ${fmtSignedInt(delta.tokensTotal)} |`,
+        "",
+    ];
+    if (!comparability.comparable) {
+        lines.push("_Caveat: deltas are shown for inspection only — environment identity disagrees, so this is not an apples-to-apples table._", "");
+    }
+    return lines.join("\n").trimEnd() + "\n";
+}
+// Fail closed when either journal has no run-start (no partial / fabricated comparison).
+// Mismatch of environment identity still yields a rendered delta, with an explicit caveat.
+export function compareRuns(opts) {
+    if (!hasRunStart(opts.baselineEvents)) {
+        return {
+            ok: false,
+            reason: `baseline run ${opts.baselineRunId} has no recorded run-start event — cannot compare`,
+        };
+    }
+    if (!hasRunStart(opts.events)) {
+        return {
+            ok: false,
+            reason: `run ${opts.runId} has no recorded run-start event — cannot compare`,
+        };
+    }
+    const baselineEnv = recordedEnvironment(opts.baselineEvents);
+    const currentEnv = recordedEnvironment(opts.events);
+    const comparability = environmentComparable(baselineEnv, currentEnv);
+    const baseline = runMetrics(opts.baselineEvents, opts.baselineRows ?? [], opts.cost ?? {});
+    const current = runMetrics(opts.events, opts.rows ?? [], opts.cost ?? {});
+    const delta = {
+        durationMs: current.durationMs !== undefined && baseline.durationMs !== undefined
+            ? current.durationMs - baseline.durationMs
+            : undefined,
+        gateFail: current.gateFail - baseline.gateFail,
+        costUsd: current.costUsd !== undefined && baseline.costUsd !== undefined
+            ? Math.round((current.costUsd - baseline.costUsd) * 1e6) / 1e6
+            : undefined,
+        tokensTotal: current.tokensTotal !== undefined && baseline.tokensTotal !== undefined
+            ? current.tokensTotal - baseline.tokensTotal
+            : undefined,
+    };
+    const text = renderComparison({
+        runId: opts.runId,
+        baselineRunId: opts.baselineRunId,
+        comparability,
+        baselineEnv,
+        currentEnv,
+        current,
+        baseline,
+        delta,
+    });
+    return {
+        ok: true,
+        runId: opts.runId,
+        baselineRunId: opts.baselineRunId,
+        comparability,
+        current,
+        baseline,
+        delta,
+        text,
+    };
+}

package/dist/run/daemon.js

@@ -15,7 +15,9 @@ import { captureBaseline, detectGateCommands, detectVacuousOracles } from "../ga
 import { runGates } from "../gates/run-gates.js";
 import { addEvidence, attributeBlocked, blockedTasks, getTask, graphDefinitionHash, loadGraph, pendingTasks, readyTasks, saveGraph, setStatus } from "../graph/graph.js";
 import { augmentRetryBrief, consult, renderRetryGuidance } from "./consult.js";
+import { runEnvironment } from "./environment.js";
 import { cleanupRunWorktrees, gitHead, linkNodeModules, sh, shGit, WORKTREE_LAYOUT_CONTRACT, worktreePath } from "./git.js";
+import { runInteractiveSeed } from "./interactive-seed.js";
 import { classifyWorkerResultCause, engagementComparable, Journal, loadRoutingProfile, newRunId } from "./journal.js";
 import { acquireRunLock, releaseRunLock } from "./lock.js";
 import { ensureIntegration, integrationBranch, integrationHead, mergeTask, verifyIntegrationTip } from "./merge.js";
@@ -64,6 +66,10 @@ export function formatSummary(s) {
     return `done: ${s.done.length}, failed: ${s.failed.length}, human: ${s.human.length}, blocked: ${s.blocked.length}, pending: ${s.pending.length}\nintegration branch: ${s.branch}${tip}`;
 }
 const MAX_ATTEMPTS = 10; // ponytail: hard cap so a pathological ladder can never loop forever
+// v1.70 T5: request-changes review rounds a single task may draw before it parks for a human decision
+// instead of cycling. Well below MAX_ATTEMPTS so review non-convergence is caught long before the
+// global cap. ponytail: literal constant; lift to cfg.review.roundCap only if a second knob-turner appears.
+const REVIEW_ROUND_CAP = 3;
 const BLOCKED_POLL_MS = 30_000; // between trailer-wait slices, check whether the pane is blocked on a prompt
 const PROVIDER_DEATH_REQUEUE_CAP = 2; // v1.46 T1: requeue same assignment twice, then fall through to the normal ladder
 const PROVIDER_DEATH_BACKOFF_MS = 500; // short backoff before provider-death requeue
@@ -252,7 +258,11 @@ export async function runDaemon(repoRoot, opts = {}) {
             baseRef = await gitHead(repoRoot);
             baseline = await captureBaseline(repoRoot, commands);
             writeFileSync(join(journal.dir, "baseline.json"), JSON.stringify(baseline, null, 2));
-            journal.append("run-start", undefined, { pid: process.pid, baseRef, commands, channels: channels.map(channelKey), branch, graphDefinitionHash: graphDefinitionHash(graph), mode: rm.mode.mode, modeSource: rm.source, ...(prior ? { supersedes: prior.runId } : {}) }); // graphDefinitionHash: T3 engagement identity (status+resume share it); pid: v1.13 (VIS-11) liveness; mode/modeSource: v1.51 T2; supersedes: v1.53 T5
+            // v1.70 T2: environment identity beside the graph/branch identity — running tickmarkr version,
+            // loaded-config hash, and the probed CLI version of each adapter holding a channel in the run,
+            // gathered through the existing probe/config-load paths (no second mechanism).
+            const environment = runEnvironment(cfg, channels, health);
+            journal.append("run-start", undefined, { pid: process.pid, baseRef, commands, channels: channels.map(channelKey), branch, graphDefinitionHash: graphDefinitionHash(graph), mode: rm.mode.mode, modeSource: rm.source, environment, ...(prior ? { supersedes: prior.runId } : {}) }); // graphDefinitionHash: T3 engagement identity (status+resume share it); pid: v1.13 (VIS-11) liveness; mode/modeSource: v1.51 T2; supersedes: v1.53 T5
             runStarted = true;
             // v1.53 T5: mark the prior run AFTER this run's run-start exists, so the prior journal never
             // names a successor that has no journal. Append-only — the prior journal is never rewritten.
@@ -409,6 +419,14 @@ export async function runDaemon(repoRoot, opts = {}) {
             if (rs)
                 journal.append("resume-restore", t.id, { attempts: rs.attempts, tried: [...tried], assignment });
             const badReviewers = []; // v1.1: reviewer channels that produced unparseable output for this task
+            // v1.70 T5 (review-convergence): failed review rounds this task has drawn, counted from the per-task
+            // review history already in the journal — the SAME review gate-result stream onGate reads to grow the
+            // reviewer-exclusion list (badReviewers), never a second parallel counter. request-changes rounds do
+            // not exclude their reviewer (a fix is re-checked by the same seat), so their count lives here in the
+            // shared history rather than in badReviewers' garbage-only exclusion subset.
+            const reviewRoundsDrawn = () => journal.read().filter((e) => e.taskId === t.id && e.event === "gate-result" &&
+                e.data.gate === "review" &&
+                e.data.pass === false).length;
             let feedback = "";
             let ladderIdx = 0;
             let modeFallbackNoted = false; // v1.2: journal the interactive→print fallback once per task, not per attempt
@@ -509,6 +527,15 @@ export async function runDaemon(repoRoot, opts = {}) {
                     await park(t, `attempt cap (${MAX_ATTEMPTS}) reached`, "attempt-cap", assignment, attempt, startMs, gateFails, consults, tokens, metered, retryMode);
                     return;
                 }
+                // v1.70 T5: a task that has already drawn REVIEW_ROUND_CAP request-changes review rounds parks for
+                // a human decision instead of dispatching another round. Condition on the review history (data),
+                // never the code path — and let an operator's approval (the human decision the cap asked for)
+                // release it, mirroring the humanGate guard's condition-on-approval precedent. Rounds only accrue
+                // after attempt 0, so the guard skips the journal read on the happy path.
+                if (attempt > 0 && !approved.has(t.id) && reviewRoundsDrawn() >= REVIEW_ROUND_CAP) {
+                    await park(t, `review round cap (${REVIEW_ROUND_CAP}) reached — request-changes reviews not converging; a human should decide`, "gate-fail", assignment, attempt, startMs, gateFails, consults, tokens, metered, retryMode);
+                    return;
+                }
                 // OBS-57: a demoted channel must not be re-dispatched on consult retry or provider requeue.
                 if (demotedChannels.has(channelKey(assignment))) {
                     const next = nextChannel(assignment, t, cfg, channels, tried, profile, demotedChannels);
@@ -601,17 +628,22 @@ export async function runDaemon(repoRoot, opts = {}) {
                     : cfg.visibility.worker === "interactive" && driver.interactive
                         ? adapter.interactiveCommand(promptFile, assignment.model)
                         : null;
-                if (cfg.visibility.worker === "interactive" && icmd === null && !modeFallbackNoted) {
+                // v1.69 T6: adapters that declare interactiveSeed launch the real TUI and inject the prompt as a
+                // user turn; they do NOT need the argv-seeding surface that interactiveCommand represents.
+                const hasSeed = retryMode !== "resume" && cfg.visibility.worker === "interactive" && driver.interactive && !!adapter.interactiveSeed;
+                if (cfg.visibility.worker === "interactive" && icmd === null && !hasSeed && !modeFallbackNoted) {
                     modeFallbackNoted = true;
                     journal.append("worker-mode-fallback", t.id, { reason: driver.interactive ? "adapter" : "driver" });
                 }
-                const interactive = icmd !== null;
+                const interactive = icmd !== null || hasSeed;
                 // OBS-85 (v1.62 T1): both dispatch branches deliver ONE short script invocation — banner,
                 // adapter command, and nonce exit marker live in a per-attempt script beside the prompt
                 // artifact (the same paneDispatchCommand pattern judge/review/consult dispatches use). The
                 // delivered pane line carries no command substitution and no trailing shell text, so paste
                 // timing can never interleave a `$(…)` with what follows it (the codex corruption class).
-                const workerCmd = interactive ? icmd : adapter.invoke(t, wt, assignment, { promptFile }).command;
+                const workerCmd = interactive
+                    ? (hasSeed ? ":" : icmd)
+                    : adapter.invoke(t, wt, assignment, { promptFile }).command;
                 const dispatchScript = promptFile.replace(/\.md$/, ".sh");
                 writeFileSync(dispatchScript, [
                     "export BASH_SILENCE_DEPRECATION_WARNING=1",
@@ -659,117 +691,134 @@ export async function runDaemon(repoRoot, opts = {}) {
                 let exitCode;
                 let timedOut = false;
                 let settleParsed;
+                let seedResult;
                 if (interactive) {
                     // v1.2 interactive: the TUI doesn't exit on completion — the trailer is the finish line.
                     // The exit wrapper still fires if the TUI dies (crash/quit): fast-fail instead of burning the timeout.
-                    await driver.run(slot, paneDispatchCommand(dispatchScript));
-                    let paged = false;
-                    // v1.22 T5 / OBS-19: auto-answer a fingerprint-matched trust dialog exactly once per slot.
-                    // Any other blocked/idle dialog still pages the operator (paged latch below).
-                    let trustAnswered = false;
                     finished = false;
                     exitCode = null;
-                    output = await driver.read(slot, 1000);
-                    // OBS-54: reaping keys on new pane output, not dispatch wall clock. Poll at least twice per
-                    // stall window (and at the existing 30s cadence for normal windows) so an active worker resets it.
-                    const stallWindowMs = taskTimeoutMinutes * 60_000;
-                    // OBS-82: the stall clock compares NORMALIZED snapshots so a spinner glyph/elapsed-time
-                    // repaint is silence, not activity. ONLY this inactivity compare sees normalized text —
-                    // trailer detection, harvest, paging, and quota checks all read the raw pane.
-                    let lastStallSnapshot = normalizeStallSnapshot(output);
-                    let lastOutputAt = Date.now();
-                    while (Date.now() - lastOutputAt < stallWindowMs) {
-                        const sliceStart = Date.now();
-                        const remaining = stallWindowMs - (sliceStart - lastOutputAt);
-                        const slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
-                        if (await driver.waitOutput(slot, `(${trailerPattern(nonce)})|TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
-                            // verify before accepting: a worker that merely DISPLAYS a marker (e.g. editing tickmarkr's
-                            // own source, where "TICKMARKR_EXIT:" is a string literal) must not end the wait. Only a
-                            // parseable trailer or a digit-suffixed exit marker in the harvest is completion.
-                            output = await driver.read(slot, 1000); // TUI transcripts carry chrome — read deeper than print's 500
-                            finished = new RegExp(trailerPattern(nonce)).test(output);
-                            const exit = exitRe.exec(output);
-                            if (finished || exit) {
-                                exitCode = exit ? Number(exit[1]) : null; // null ⇔ the TUI is still alive
-                                await sampleContext(); // final poll-seam sample before leaving the wait
-                                break;
-                            }
-                        }
-                        const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 1000));
-                        if (currentStallSnapshot !== lastStallSnapshot) {
-                            lastStallSnapshot = currentStallSnapshot;
-                            lastOutputAt = Date.now();
-                        }
-                        // v1.23 T2: piggyback on this poll slice — same cadence as blocked/idle checks, no new timer.
-                        await sampleContext();
-                        // page on "idle" too: herdr's blocked-scrape is strict and proved flaky for TUI dialogs
-                        // (live check: cursor's trust dialog scraped as idle). "unknown" never pages — that's just
-                        // a pane the scraper can't read (subprocess, dead pane); the task timeout covers those.
-                        const st = paged ? "" : await driver.status(slot);
-                        if (!paged && (st === "blocked" || st === "idle")) {
-                            // T5: once-per-slot auto-answer when the adapter declares a trust dialog and the pane
-                            // text matches. tickmarkr created the worktree from the operator's own repo — safe by construction.
-                            if (!trustAnswered && adapter.trustDialog && driver.sendKey) {
-                                try {
-                                    const paneText = await driver.read(slot, 80);
-                                    if (matchesTrustDialog(paneText, adapter.trustDialog)) {
-                                        trustAnswered = true;
-                                        // v1.25 T1: audit trail for live runs — prove the dialog appeared and was answered.
-                                        // Latch + sendKey + no-page continue stay byte-identical; this append is additive only.
-                                        journal.append("trust-auto-answer", t.id, { slot: slot.name, adapter: adapter.id });
-                                        await driver.sendKey(slot, adapter.trustDialog.key);
-                                        const spent = Date.now() - sliceStart;
-                                        if (spent < slice)
-                                            await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
-                                        continue; // do not page — keep waiting for the trailer
-                                    }
-                                }
-                                catch {
-                                    /* read/send failed — fall through to page the operator */
-                                }
-                            }
-                            paged = true; // page once — the visible pane is the operator's to unblock; task timeout is the backstop
-                            const why = st === "blocked" ? "is blocked on a prompt — approve in its pane" : "looks idle without finishing — check its pane";
-                            await driver.notify(`tickmarkr ${runId}: ${slot.name} ${why}`, { tier: "attention" });
-                        }
-                        // a dead pane or a false-positive marker display returns fast — sleep the unspent slice, never hot-spin
-                        const spent = Date.now() - sliceStart;
-                        if (spent < slice)
-                            await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
+                    if (adapter.interactiveSeed) {
+                        // v1.69 T6: launch the real TUI without a prompt, wait for readiness, inject one seed turn,
+                        // then fall through to the normal trailer harvest. A failed seed is recorded as a finished
+                        // failure rather than allowed to race the trailer wait.
+                        seedResult = await runInteractiveSeed({ driver, slot, adapter, assignment, promptFile, taskTimeoutMinutes });
+                        output = seedResult.output;
                     }
-                    if (!finished && exitCode === null) {
-                        // timed out (or only ever saw false positives): harvest whatever the pane holds now
-                        timedOut = Date.now() - lastOutputAt >= stallWindowMs;
+                    else {
+                        await driver.run(slot, paneDispatchCommand(dispatchScript));
                         output = await driver.read(slot, 1000);
-                        finished = new RegExp(trailerPattern(nonce)).test(output);
-                        const exit = exitRe.exec(output);
-                        exitCode = exit ? Number(exit[1]) : null;
                     }
-                    if (finished) {
-                        await driver.waitAgentStatus(slot, "idle", 5_000); // settle, then re-harvest the final render
-                        output = await driver.read(slot, 1000);
+                    if (seedResult?.seedFailed) {
+                        finished = false;
                     }
-                    // T5 / OBS-111: an interactive harvest can race the TUI's final paint. When the pane
-                    // contains the nonce token but the JSON hasn't balanced yet, settle and re-read through
-                    // the existing pane-read seam once or twice before recording a malformed-trailer cause.
-                    if (interactive) {
+                    else {
+                        let paged = false;
+                        // v1.22 T5 / OBS-19: auto-answer a fingerprint-matched trust dialog exactly once per slot.
+                        // Any other blocked/idle dialog still pages the operator (paged latch below).
+                        let trustAnswered = false;
+                        finished = false;
+                        exitCode = null;
+                        // OBS-54: reaping keys on new pane output, not dispatch wall clock. Poll at least twice per
+                        // stall window (and at the existing 30s cadence for normal windows) so an active worker resets it.
                         const stallWindowMs = taskTimeoutMinutes * 60_000;
-                        const settleDeadline = attemptStart + stallWindowMs;
-                        const settleDelayMs = 1_000;
-                        const maxSettleRetries = 2;
-                        let settleTries = 0;
-                        settleParsed = adapter.parse(output, nonce);
-                        while (settleParsed.summary === UNPARSEABLE_TRAILER_SUMMARY && settleTries < maxSettleRetries) {
-                            const remaining = settleDeadline - Date.now();
-                            if (remaining <= 0)
-                                break;
-                            await new Promise((r) => setTimeout(r, Math.min(settleDelayMs, remaining)));
+                        // OBS-82: the stall clock compares NORMALIZED snapshots so a spinner glyph/elapsed-time
+                        // repaint is silence, not activity. ONLY this inactivity compare sees normalized text —
+                        // trailer detection, harvest, paging, and quota checks all read the raw pane.
+                        let lastStallSnapshot = normalizeStallSnapshot(output);
+                        let lastOutputAt = Date.now();
+                        while (Date.now() - lastOutputAt < stallWindowMs) {
+                            const sliceStart = Date.now();
+                            const remaining = stallWindowMs - (sliceStart - lastOutputAt);
+                            const slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                            if (await driver.waitOutput(slot, `(${trailerPattern(nonce)})|TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
+                                // verify before accepting: a worker that merely DISPLAYS a marker (e.g. editing tickmarkr's
+                                // own source, where "TICKMARKR_EXIT:" is a string literal) must not end the wait. Only a
+                                // parseable trailer or a digit-suffixed exit marker in the harvest is completion.
+                                output = await driver.read(slot, 1000); // TUI transcripts carry chrome — read deeper than print's 500
+                                finished = new RegExp(trailerPattern(nonce)).test(output);
+                                const exit = exitRe.exec(output);
+                                if (finished || exit) {
+                                    exitCode = exit ? Number(exit[1]) : null; // null ⇔ the TUI is still alive
+                                    await sampleContext(); // final poll-seam sample before leaving the wait
+                                    break;
+                                }
+                            }
+                            const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 1000));
+                            if (currentStallSnapshot !== lastStallSnapshot) {
+                                lastStallSnapshot = currentStallSnapshot;
+                                lastOutputAt = Date.now();
+                            }
+                            // v1.23 T2: piggyback on this poll slice — same cadence as blocked/idle checks, no new timer.
+                            await sampleContext();
+                            // page on "idle" too: herdr's blocked-scrape is strict and proved flaky for TUI dialogs
+                            // (live check: cursor's trust dialog scraped as idle). "unknown" never pages — that's just
+                            // a pane the scraper can't read (subprocess, dead pane); the task timeout covers those.
+                            const st = paged ? "" : await driver.status(slot);
+                            if (!paged && (st === "blocked" || st === "idle")) {
+                                // T5: once-per-slot auto-answer when the adapter declares a trust dialog and the pane
+                                // text matches. tickmarkr created the worktree from the operator's own repo — safe by construction.
+                                if (!trustAnswered && adapter.trustDialog && driver.sendKey) {
+                                    try {
+                                        const paneText = await driver.read(slot, 80);
+                                        if (matchesTrustDialog(paneText, adapter.trustDialog)) {
+                                            trustAnswered = true;
+                                            // v1.25 T1: audit trail for live runs — prove the dialog appeared and was answered.
+                                            // Latch + sendKey + no-page continue stay byte-identical; this append is additive only.
+                                            journal.append("trust-auto-answer", t.id, { slot: slot.name, adapter: adapter.id });
+                                            await driver.sendKey(slot, adapter.trustDialog.key);
+                                            const spent = Date.now() - sliceStart;
+                                            if (spent < slice)
+                                                await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
+                                            continue; // do not page — keep waiting for the trailer
+                                        }
+                                    }
+                                    catch {
+                                        /* read/send failed — fall through to page the operator */
+                                    }
+                                }
+                                paged = true; // page once — the visible pane is the operator's to unblock; task timeout is the backstop
+                                const why = st === "blocked" ? "is blocked on a prompt — approve in its pane" : "looks idle without finishing — check its pane";
+                                await driver.notify(`tickmarkr ${runId}: ${slot.name} ${why}`, { tier: "attention" });
+                            }
+                            // a dead pane or a false-positive marker display returns fast — sleep the unspent slice, never hot-spin
+                            const spent = Date.now() - sliceStart;
+                            if (spent < slice)
+                                await new Promise((r) => setTimeout(r, Math.min(slice - spent, 1_000)));
+                        }
+                        if (!finished && exitCode === null) {
+                            // timed out (or only ever saw false positives): harvest whatever the pane holds now
+                            timedOut = Date.now() - lastOutputAt >= stallWindowMs;
                             output = await driver.read(slot, 1000);
-                            settleParsed = adapter.parse(output, nonce);
-                            settleTries++;
+                            finished = new RegExp(trailerPattern(nonce)).test(output);
+                            const exit = exitRe.exec(output);
+                            exitCode = exit ? Number(exit[1]) : null;
                         }
-                        if (settleParsed.summary !== UNPARSEABLE_TRAILER_SUMMARY) {
-                            finished = settleParsed.summary !== NO_TRAILER_SUMMARY;
+                        if (finished) {
+                            await driver.waitAgentStatus(slot, "idle", 5_000); // settle, then re-harvest the final render
+                            output = await driver.read(slot, 1000);
+                        }
+                        // T5 / OBS-111: an interactive harvest can race the TUI's final paint. When the pane
+                        // contains the nonce token but the JSON hasn't balanced yet, settle and re-read through
+                        // the existing pane-read seam once or twice before recording a malformed-trailer cause.
+                        if (interactive) {
+                            const stallWindowMs = taskTimeoutMinutes * 60_000;
+                            const settleDeadline = attemptStart + stallWindowMs;
+                            const settleDelayMs = 1_000;
+                            const maxSettleRetries = 2;
+                            let settleTries = 0;
+                            settleParsed = adapter.parse(output, nonce);
+                            while (settleParsed.summary === UNPARSEABLE_TRAILER_SUMMARY && settleTries < maxSettleRetries) {
+                                const remaining = settleDeadline - Date.now();
+                                if (remaining <= 0)
+                                    break;
+                                await new Promise((r) => setTimeout(r, Math.min(settleDelayMs, remaining)));
+                                output = await driver.read(slot, 1000);
+                                settleParsed = adapter.parse(output, nonce);
+                                settleTries++;
+                            }
+                            if (settleParsed.summary !== UNPARSEABLE_TRAILER_SUMMARY) {
+                                finished = settleParsed.summary !== NO_TRAILER_SUMMARY;
+                            }
                         }
                     }
                 }

package/dist/run/environment.d.ts

@@ -0,0 +1,12 @@
+import type { AuthHealth, BillingChannel } from "../adapters/types.js";
+import type { TickmarkrConfig } from "../config/config.js";
+export interface RunEnvironment {
+    tickmarkrVersion: string;
+    configHash: string;
+    adapterVersions: Record<string, string>;
+}
+export declare const UNKNOWN_ADAPTER_VERSION = "unknown";
+export declare function tickmarkrVersion(): string;
+export declare function configHash(cfg: TickmarkrConfig): string;
+export declare function adapterVersions(channels: BillingChannel[], health: Record<string, AuthHealth>): Record<string, string>;
+export declare function runEnvironment(cfg: TickmarkrConfig, channels: BillingChannel[], health: Record<string, AuthHealth>): RunEnvironment;

package/dist/run/environment.js

@@ -0,0 +1,41 @@
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+// An adapter whose version probe failed is recorded, not dropped — "unknown", never a fabricated string.
+export const UNKNOWN_ADAPTER_VERSION = "unknown";
+// Same package.json read as src/cli/commands/version.ts (one resolution pattern, two consumers).
+const pkgPath = join(dirname(fileURLToPath(import.meta.url)), "../../package.json");
+export function tickmarkrVersion() {
+    const { version: v } = JSON.parse(readFileSync(pkgPath, "utf8"));
+    return v;
+}
+// Key order in a parsed config is an accident of the schema/merge layers, so the hash canonicalizes
+// first: object keys sorted recursively, undefined dropped (JSON semantics), array order preserved.
+function stableStringify(v) {
+    if (v === null || typeof v !== "object")
+        return JSON.stringify(v);
+    if (Array.isArray(v))
+        return `[${v.map(stableStringify).join(",")}]`;
+    const entries = Object.entries(v)
+        .filter(([, val]) => val !== undefined)
+        .sort(([a], [b]) => (a < b ? -1 : a > b ? 1 : 0));
+    return `{${entries.map(([k, val]) => `${JSON.stringify(k)}:${stableStringify(val)}`).join(",")}}`;
+}
+// sha256 truncated to 16 hex — the graphDefinitionHash convention (stable, grep-friendly).
+export function configHash(cfg) {
+    return createHash("sha256").update(stableStringify(cfg)).digest("hex").slice(0, 16);
+}
+// One entry per adapter with a channel in the run (not per channel). The version is whatever the
+// adapter's own probe recorded in health; a missing/undefined probe result becomes "unknown".
+export function adapterVersions(channels, health) {
+    const out = {};
+    for (const c of channels) {
+        if (!(c.adapter in out))
+            out[c.adapter] = health[c.adapter]?.version ?? UNKNOWN_ADAPTER_VERSION;
+    }
+    return out;
+}
+export function runEnvironment(cfg, channels, health) {
+    return { tickmarkrVersion: tickmarkrVersion(), configHash: configHash(cfg), adapterVersions: adapterVersions(channels, health) };
+}

package/dist/run/interactive-seed.d.ts

@@ -0,0 +1,15 @@
+import type { Assignment, WorkerAdapter } from "../adapters/types.js";
+import type { ExecutorDriver, Slot } from "../drivers/types.js";
+export interface InteractiveSeedResult {
+    output: string;
+    seedFailed: boolean;
+    seedError?: string;
+}
+export declare function runInteractiveSeed(opts: {
+    driver: Pick<ExecutorDriver, "run" | "waitOutput" | "read">;
+    slot: Slot;
+    adapter: WorkerAdapter;
+    assignment: Assignment;
+    promptFile: string;
+    taskTimeoutMinutes: number;
+}): Promise<InteractiveSeedResult>;