tickmarkr 1.69.0 → 1.71.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/route/preference.d.ts

@@ -25,3 +25,12 @@ export declare function disallowedBy(c: {
     adapter: string;
     model: string;
 }, routing: TickmarkrConfig["routing"]): Disallowed | null;
+export interface DenyPreferCollision {
+    kind: "prefer" | "pin";
+    shape: string;
+    detail: string;
+    disallowed: Disallowed;
+}
+export declare function preferEntryDenied(p: string, cfg: TickmarkrConfig): Disallowed | null;
+export declare function denyPreferCollisions(cfg: TickmarkrConfig): DenyPreferCollision[];
+export declare function denyPreferCollisionLine({ kind, shape, detail, disallowed }: DenyPreferCollision): string;

package/dist/route/preference.js

@@ -1,4 +1,6 @@
 import { channelKey, channelsFromConfig } from "../adapters/types.js";
+import { validateGraph } from "../graph/schema.js";
+import { route, RoutingError } from "./router.js";
 const adapterIds = (adapters) => typeof adapters[0] === "string" ? adapters : adapters.map((a) => a.id);
 export function excludedChannels(cfg, adapters, health) {
     const { allow, deny } = cfg.routing;
@@ -47,3 +49,62 @@ export function disallowedBy(c, routing) {
     }
     return null;
 }
+// Delegates to route()'s preflightPrefer — doctor/resume preflight reuses the router grammar,
+// not a second colon/tier/model parser of the same config.
+const PREFLIGHT_SHAPE = "chore";
+const preflightTask = validateGraph({
+    version: 1, spec: { source: "prd", paths: ["p"], hash: "h" },
+    tasks: [{ id: "T0", title: "preflight", goal: "preflight", shape: PREFLIGHT_SHAPE, complexity: 1, acceptance: ["preflight"] }],
+}).tasks[0];
+const disallowedFromPreferError = (msg) => {
+    const m = msg.match(/prefer entry .+ is disallowed by routing\.(deny|allow) \(([^)]+)\)/);
+    return m ? { by: m[1], entry: m[2] } : null;
+};
+export function preferEntryDenied(p, cfg) {
+    if (!cfg.routing.allow && !cfg.routing.deny)
+        return null;
+    const probe = structuredClone(cfg);
+    probe.routing.map = { ...probe.routing.map, [PREFLIGHT_SHAPE]: { prefer: [p] } };
+    try {
+        route(preflightTask, probe, []);
+        return null;
+    }
+    catch (e) {
+        if (e instanceof RoutingError)
+            return disallowedFromPreferError(e.message);
+        throw e;
+    }
+}
+export function denyPreferCollisions(cfg) {
+    if (!cfg.routing.allow && !cfg.routing.deny)
+        return [];
+    const out = [];
+    for (const [shape, entry] of Object.entries(cfg.routing.map)) {
+        if (entry.pin) {
+            const d = disallowedBy({ adapter: entry.pin.via, model: entry.pin.model }, cfg.routing);
+            if (d) {
+                out.push({
+                    kind: "pin",
+                    shape,
+                    detail: `${entry.pin.via}:${entry.pin.model}`,
+                    disallowed: d,
+                });
+            }
+        }
+        const prefer = entry.prefer ?? [];
+        if (prefer.length && prefer.every((p) => preferEntryDenied(p, cfg) !== null)) {
+            out.push({
+                kind: "prefer",
+                shape,
+                detail: prefer.join(" > "),
+                disallowed: preferEntryDenied(prefer[0], cfg),
+            });
+        }
+    }
+    return out;
+}
+export function denyPreferCollisionLine({ kind, shape, detail, disallowed }) {
+    const surface = kind === "pin" ? `routing.map.${shape}.pin` : `routing.map.${shape}.prefer`;
+    const verb = kind === "pin" ? "is disallowed" : "fully disallowed";
+    return `deny∩prefer: ${surface} ${detail} ${verb} by routing.${disallowed.by} (${disallowed.entry}) — remove the ${disallowed.by} entry or adjust ${kind === "pin" ? "pin" : "prefer"}`;
+}

package/dist/run/daemon.d.ts

@@ -41,4 +41,8 @@ export interface RunSummary {
     lastMergedTask?: string;
 }
 export declare function formatSummary(s: RunSummary): string;
+export declare const EARLY_LAUNCH_LIVENESS_MS = 60000;
+/** Test seam — lowers the empty-pane liveness window without sleeping 60s per case. */
+export declare function setEarlyLaunchLivenessMsForTests(ms: number): void;
+export declare function resetEarlyLaunchLivenessMsForTests(): void;
 export declare function runDaemon(repoRoot: string, opts?: RunOptions): Promise<RunSummary>;

package/dist/run/daemon.js

@@ -15,6 +15,7 @@ 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";
@@ -65,10 +66,26 @@ 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
 const NO_TRAILER_DEMOTION_STREAK = 2; // OBS-57: consecutive no-trailer windows demote a channel for the rest of the run
+// OBS-117 (v1.71 T6): a worker pane that never prints a byte by T+60s after dispatch is a dead
+// channel — don't burn the full stall window waiting for a silent launch failure. Checked on the
+// existing stall-wait poll cadence only (no new timer). Spinner/ANSI repaints count as output.
+export const EARLY_LAUNCH_LIVENESS_MS = 60_000;
+let earlyLaunchLivenessMs = EARLY_LAUNCH_LIVENESS_MS;
+/** Test seam — lowers the empty-pane liveness window without sleeping 60s per case. */
+export function setEarlyLaunchLivenessMsForTests(ms) {
+    earlyLaunchLivenessMs = ms;
+}
+export function resetEarlyLaunchLivenessMsForTests() {
+    earlyLaunchLivenessMs = EARLY_LAUNCH_LIVENESS_MS;
+}
 async function commitsAheadOf(base, wt) {
     const head = await gitHead(wt);
     if (head === base)
@@ -212,6 +229,7 @@ export async function runDaemon(repoRoot, opts = {}) {
         // GATE-08 lesson at the humanGate guard: condition on the data, not the code path). Dead-code
         // equivalence to the router.ts:194 profile⇒undefined pattern: no map entry ⇒ today's literal.
         const resume = opts.resume ? journal.replayResumeState() : new Map();
+        const replayedExclusions = opts.resume ? journal.replayExcludedChannels() : new Set();
         if (opts.resume) {
             // v1.53 T5: a superseded run is dead — resuming it beside its successor is the exact
             // two-concurrent-runs hazard supersession exists to prevent. Fail closed, naming the successor.
@@ -247,13 +265,20 @@ export async function runDaemon(repoRoot, opts = {}) {
                     continue;
                 graph = setStatus(graph, id, st);
             }
-            journal.append("run-resume", undefined, { pid: process.pid }); // v1.13 (VIS-11): record the live daemon pid for status liveness
+            journal.append("run-resume", undefined, {
+                pid: process.pid, // v1.13 (VIS-11): record the live daemon pid for status liveness
+                ...(replayedExclusions.size > 0 ? { excludedChannels: [...replayedExclusions].sort() } : {}),
+            });
         }
         else {
             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.
@@ -292,7 +317,8 @@ export async function runDaemon(repoRoot, opts = {}) {
         const keptSlots = [];
         const runTag = runId.replace(/^run-/, ""); // full date-time — cross-run unique even across days
         // OBS-57: per-run in-run demotion — channels that burn consecutive no-trailer windows route around for later attempts.
-        const demotedChannels = new Set();
+        // v1.71 OBS-119: on resume, re-seed from the journal fold (replayedExclusions) before any dispatch.
+        const demotedChannels = new Set(replayedExclusions);
         const noTrailerStreak = new Map();
         // OBS-17 T2: reconcile at every safe point — run start/resume (just journaled above), each task
         // terminal event, and run-end. The desired set is the pure journal fold (reconcile.ts); the driver
@@ -385,7 +411,9 @@ export async function runDaemon(repoRoot, opts = {}) {
             // fresh-budget release, prefer nextChannel over the surviving tried-list so burned channels are
             // not re-tried first (consult bans / prior failovers survive the release).
             const rs = resume.get(t.id);
-            if (rs?.lastAssignment && rs.attempts > 0 && channels.some((c) => channelKey(c) === channelKey(rs.lastAssignment))) {
+            if (rs?.lastAssignment && rs.attempts > 0
+                && channels.some((c) => channelKey(c) === channelKey(rs.lastAssignment))
+                && !demotedChannels.has(channelKey(rs.lastAssignment))) {
                 assignment = rs.lastAssignment; // restore the consult-chosen assignment (bypasses route()'s static re-pick)
             }
             else if (rs && rs.tried.length) {
@@ -410,6 +438,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
@@ -510,6 +546,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);
@@ -664,6 +709,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 let output;
                 let exitCode;
                 let timedOut = false;
+                let earlyLaunchDead = false;
                 let settleParsed;
                 let seedResult;
                 if (interactive) {
@@ -698,12 +744,18 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // 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 everHadOutput = output.length > 0;
                         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)));
+                            let slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                            if (!everHadOutput) {
+                                const earlyLeft = earlyLaunchLivenessMs - (sliceStart - attemptStart);
+                                if (earlyLeft > 0)
+                                    slice = Math.min(slice, earlyLeft);
+                            }
                             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
@@ -717,11 +769,20 @@ export async function runDaemon(repoRoot, opts = {}) {
                                     break;
                                 }
                             }
-                            const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 1000));
+                            const paneText = await driver.read(slot, 1000);
+                            if (paneText.length > 0)
+                                everHadOutput = true;
+                            const currentStallSnapshot = normalizeStallSnapshot(paneText);
                             if (currentStallSnapshot !== lastStallSnapshot) {
                                 lastStallSnapshot = currentStallSnapshot;
                                 lastOutputAt = Date.now();
                             }
+                            // OBS-117 (v1.71 T6): zero raw output by the early-launch deadline is a dead channel now.
+                            if (!everHadOutput && Date.now() - attemptStart >= earlyLaunchLivenessMs) {
+                                earlyLaunchDead = true;
+                                output = paneText;
+                                break;
+                            }
                             // 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
@@ -802,21 +863,35 @@ export async function runDaemon(repoRoot, opts = {}) {
                     // OBS-82: same normalized-snapshot compare as the interactive site — spinner-only repaints
                     // exhaust the budget here too; harvest below still reads the raw pane.
                     const stallWindowMs = taskTimeoutMinutes * 60_000;
-                    let lastStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 500));
+                    const initialPane = await driver.read(slot, 500);
+                    let everHadOutput = initialPane.length > 0;
+                    let lastStallSnapshot = normalizeStallSnapshot(initialPane);
                     let lastOutputAt = Date.now();
                     finished = false;
                     while (Date.now() - lastOutputAt < stallWindowMs) {
                         const remaining = stallWindowMs - (Date.now() - lastOutputAt);
-                        const slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                        let slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
+                        if (!everHadOutput) {
+                            const earlyLeft = earlyLaunchLivenessMs - (Date.now() - attemptStart);
+                            if (earlyLeft > 0)
+                                slice = Math.min(slice, earlyLeft);
+                        }
                         if (await driver.waitOutput(slot, `TICKMARKR_EXIT_${nonce}:\\d`, slice, { regex: true })) {
                             finished = true;
                             break;
                         }
-                        const currentStallSnapshot = normalizeStallSnapshot(await driver.read(slot, 500));
+                        const paneText = await driver.read(slot, 500);
+                        if (paneText.length > 0)
+                            everHadOutput = true;
+                        const currentStallSnapshot = normalizeStallSnapshot(paneText);
                         if (currentStallSnapshot !== lastStallSnapshot) {
                             lastStallSnapshot = currentStallSnapshot;
                             lastOutputAt = Date.now();
                         }
+                        if (!everHadOutput && Date.now() - attemptStart >= earlyLaunchLivenessMs) {
+                            earlyLaunchDead = true;
+                            break;
+                        }
                     }
                     output = await driver.read(slot, 500);
                     exitCode = Number(exitRe.exec(output)?.[1] ?? 1);
@@ -914,10 +989,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                 // AFTER the quota check so quota behavior stays byte-identical (a quota hit returns/continues
                 // before reaching here); provider-outage lands here only once the v1.46 same-channel requeue
                 // cap above is spent, so a transient blip still recovers in place.
-                const dead = classifyDeadChannel(result);
+                // OBS-117 (v1.71 T6): a silent launch failure has no CLI signature to parse — the same
+                // setup-required typed dead-channel path a late-harvest "command not found" would take.
+                const dead = classifyDeadChannel(result) ?? (earlyLaunchDead ? "setup-required" : undefined);
                 if (dead) {
                     const from = channelKey(assignment);
                     demotedChannels.add(from); // excluded for later attempts AND later tasks in this run
+                    journal.append("channel-exclusion", t.id, { channel: from, reason: dead, kind: "dead-channel" });
                     const next = failover("dead-channel");
                     journal.append("dead-channel-failover", t.id, { reason: dead, from, to: next ? channelKey(next) : null });
                     if (next) {
@@ -1104,9 +1182,14 @@ export async function runDaemon(repoRoot, opts = {}) {
             for (const t of ready) {
                 const p = execTask(t)
                     .catch(async (err) => {
+                    const taskEvents = journal.read().filter((e) => e.taskId === t.id);
+                    const dispatch = [...taskEvents].reverse().find((e) => e.event === "task-dispatch");
+                    const verifiedFailure = taskEvents.some((e) => e.event === "gate-result" && e.data.pass === false);
+                    const kind = verifiedFailure ? "gate-fail" : dispatch ? "dispatch" : "infra";
+                    const attempts = dispatch && Number.isInteger(dispatch.data.attempt) ? dispatch.data.attempt : 0;
                     graph = setStatus(graph, t.id, "failed");
                     saveGraph(repoRoot, graph);
-                    journal.append("task-failed", t.id, { error: String(err) });
+                    journal.append("task-failed", t.id, { error: String(err), kind, attempts });
                     journal.telemetry({ taskId: t.id, shape: t.shape, adapter: "-", model: "-", channel: "-", attempts: 0, outcome: "failed", durationMs: 0 });
                     await reconcile({ spareLiveLlm: true }); // task-failed is a terminal event
                 })

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

@@ -4,6 +4,7 @@ export interface InteractiveSeedResult {
     output: string;
     seedFailed: boolean;
     seedError?: string;
+    sessionId?: string;
 }
 export declare function runInteractiveSeed(opts: {
     driver: Pick<ExecutorDriver, "run" | "waitOutput" | "read">;

package/dist/run/interactive-seed.js

@@ -6,9 +6,17 @@ export async function runInteractiveSeed(opts) {
     const seed = opts.adapter.interactiveSeed;
     await opts.driver.run(opts.slot, seed.launch(opts.assignment.model));
     const ready = await opts.driver.waitOutput(opts.slot, seed.readinessMatch, opts.taskTimeoutMinutes * 60_000);
+    const banner = await opts.driver.read(opts.slot, 1000);
     if (!ready) {
-        const output = await opts.driver.read(opts.slot, 1000);
-        return { output, seedFailed: true, seedError: `readiness pattern not seen: ${seed.readinessMatch}` };
+        return { output: banner, seedFailed: true, seedError: `readiness pattern not seen: ${seed.readinessMatch}` };
+    }
+    let sessionId;
+    if (seed.confirmBanner) {
+        const confirm = seed.confirmBanner(banner, opts.assignment.model);
+        if (!confirm.ok) {
+            return { output: banner, seedFailed: true, seedError: confirm.error };
+        }
+        sessionId = confirm.sessionId;
     }
     const seedText = seed.seedLine(opts.promptFile);
     await opts.driver.run(opts.slot, seedText);
@@ -18,8 +26,8 @@ export async function runInteractiveSeed(opts) {
         output = await opts.driver.read(opts.slot, 1000);
         const bottom = output.trimEnd().split("\n").pop() ?? "";
         if (!bottom.includes(seedText)) {
-            return { output, seedFailed: false };
+            return { output, seedFailed: false, ...(sessionId ? { sessionId } : {}) };
         }
     }
-    return { output, seedFailed: true, seedError: "seed line never left the input box" };
+    return { output, seedFailed: true, seedError: "seed line never left the input box", ...(sessionId ? { sessionId } : {}) };
 }