tickmarkr 1.85.0 → 1.86.0

package/dist/cli/commands/fleet.js

@@ -1,9 +1,10 @@
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
 import { dirname } from "node:path";
 import { parseArgs } from "node:util";
-import { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse, readAutoPrefer } from "../../adapters/registry.js";
+import { allAdapters, discoverChannels, doctorAgeMs, initDoctorReuse } from "../../adapters/registry.js";
 import { fleetUnclassifiedModels } from "../../adapters/model-lints.js";
-import { fleetEditableFromConfig, fleetEditableEquals, fleetRepoOverlayFromDelta, formatFleetPrint, globalConfigDir, harvestFleetProvenance, overlayBytesLoadError, overlayPreferShapes, readOverlayFile, repoOverlayPath, repoOverlayYaml, ROUTING_MODES, unifiedYamlDiff, } from "../../config/config.js";
+import { fleetEditableFromConfig, fleetEditableEquals, formatFleetPrint, globalConfigDir, overlayBytesLoadError, renderFleetOverlayWrite, repoOverlayPath, ROUTING_MODES, unifiedYamlDiff, } from "../../config/config.js";
+import { projectFleetWhy, renderFleetWhy } from "../../config/fleet-why.js";
 import { SHAPES, TIERS } from "../../graph/schema.js";
 import { candidateRow, costSignal, shapeCandidates } from "./fleet-picker.js";
 import { route } from "../../route/router.js";
@@ -36,26 +37,30 @@ function currentRepoOverlayText(repoRoot) {
     const p = repoOverlayPath(repoRoot);
     return existsSync(p) ? readFileSync(p, "utf8") : "";
 }
-function provenanceMap(editable) {
-    const out = {};
-    for (const [adapter, models] of Object.entries(editable.tiers)) {
-        for (const [model, v] of Object.entries(models)) {
-            if (v?.provenance) {
-                out[adapter] ??= {};
-                out[adapter][model] = v.provenance;
-            }
+/** Atomic sibling-temp writer. Reading and serializing happen before `${path}.tmp` exists, and
+ * any pre-rename interruption unlinks only that exact candidate while the original remains intact. */
+export function writeFleetOverlay(path, serialize, hooks = {}) {
+    const prior = hooks.readPrior
+        ? hooks.readPrior(path)
+        : (existsSync(path) ? readFileSync(path, "utf8") : "");
+    const bytes = serialize(prior);
+    mkdirSync(dirname(path), { recursive: true });
+    const tmp = `${path}.tmp`;
+    try {
+        writeFileSync(tmp, bytes);
+        hooks.beforeRename?.();
+        renameSync(tmp, path);
+    }
+    catch (error) {
+        try {
+            if (existsSync(tmp))
+                unlinkSync(tmp);
         }
+        catch {
+            // Preserve the write failure; cleanup is constrained to the exact sibling candidate.
+        }
+        throw error;
     }
-    return out;
-}
-// v1.51 T4: serializeFleetOverlay predates routing.mode — splice the mode line under routing:
-// so a repo-declared mode survives fleet writes and a mode selection lands as routing.mode.
-function withModeLine(yaml, mode) {
-    if (!mode)
-        return yaml;
-    if (/^routing:$/m.test(yaml))
-        return yaml.replace(/^routing:$/m, `routing:\n  mode: ${mode}`);
-    return `routing:\n  mode: ${mode}\n${yaml}`;
 }
 function formatFleetSteering(cfg) {
     const blocks = [];
@@ -76,12 +81,14 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         args: argv,
         options: {
             print: { type: "boolean" },
+            why: { type: "boolean" },
             "global-dir": { type: "string" },
             fresh: { type: "boolean" },
         },
     });
     const globalDir = values["global-dir"] ?? globalConfigDir();
     const print = values.print ?? false;
+    const why = values.why ?? false;
     const input = io.input ?? process.stdin;
     const output = io.output ?? process.stdout;
     const interactive = input.isTTY === true && output.isTTY === true;
@@ -95,7 +102,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         // not from another parse of either raw overlay.
         return `${body.slice(0, nl)}\n# mode: ${rm.mode.mode} (${rm.source})${body.slice(nl)}${formatFleetSteering(rm.cfg)}`;
     }
-    if (!interactive)
+    if (!why && !interactive)
         return { out: NON_TTY_MSG, code: 1 };
     const fresh = values.fresh ?? false;
     const { reuse, health: cached } = initDoctorReuse(cwd, fresh);
@@ -107,10 +114,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
     }
     const rm = resolveRunMode(cwd, { globalDir });
     const cfg = rm.cfg;
-    // OBS-88: harvest existing `# note` comments from the overlay bytes at session load — the
-    // session must know about every prior note, not only its own edits, or the next write strips them
-    const harvested = harvestFleetProvenance(currentRepoOverlayText(cwd));
-    const initial = fleetEditableFromConfig(cfg, harvested.tiers);
+    const initial = fleetEditableFromConfig(cfg);
     const editable = structuredClone(initial);
     const health = cached;
     const modelGroups = adapters
@@ -183,21 +187,52 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
                 : ["    (no floor changes)"]),
         ];
     };
-    const autoPrefer = readAutoPrefer(cwd);
-    const overlayShapes = overlayPreferShapes(cwd, { globalDir });
-    const routedShapeRows = (mode, map) => SHAPES.map((shape) => {
-        let now;
-        try {
-            const routed = route(previewTask(shape), previewCfg(mode, map), channels, profile, undefined, undefined, PREVIEW_EXPLORE);
-            const assignment = routed.assignment;
-            now = `${assignment.adapter}:${assignment.model} (${assignment.channel}, ${assignment.tier})  ${costSignal(assignment, cfg.pricing)}`;
-        }
-        catch (error) {
-            now = error.message;
+    const whyDeclaration = (shape, mode, map, mapProducedValue) => {
+        const mapChanged = JSON.stringify(map[shape] ?? {}) !== JSON.stringify(editable.map[shape] ?? {});
+        if (mapProducedValue) {
+            return mapChanged
+                ? { operatorPinned: true }
+                : { declaredAt: `routing.map.${shape}` };
         }
-        const auto = autoPrefer?.[shape] && !overlayShapes.has(shape) ? "  (auto-prefer active)" : "";
-        return { id: shape, label: `${shape}  →  ${now}${auto}` };
-    });
+        const floorSource = modeCfgs[mode].mode.provenance[shape];
+        if (floorSource === undefined)
+            return {};
+        if (floorSource === "config floors")
+            return { declaredAt: `routing.floors.${shape}` };
+        if (mode !== rm.mode.mode)
+            return { operatorPinned: true };
+        return rm.source === "default"
+            ? { declaredAt: `routing.floors.${shape}` }
+            : { declaredAt: "routing.mode" };
+    };
+    const projectedShapeRows = (mode, map) => {
+        const values = SHAPES.map((shape) => {
+            try {
+                const routed = route(previewTask(shape), previewCfg(mode, map), channels, profile, undefined, undefined, PREVIEW_EXPLORE);
+                const assignment = routed.assignment;
+                const effective = `${assignment.adapter}:${assignment.model} (${assignment.channel}, ${assignment.tier})  ${costSignal(assignment, cfg.pricing)}`;
+                const mapProducedValue = map[shape]?.pin !== undefined || routed.provenance.includes("via prefer");
+                return {
+                    id: shape,
+                    effective,
+                    ...whyDeclaration(shape, mode, map, mapProducedValue),
+                };
+            }
+            catch (error) {
+                const mapProducedValue = map[shape]?.pin !== undefined || (map[shape]?.prefer?.length ?? 0) > 0;
+                return {
+                    id: shape,
+                    effective: error.message,
+                    ...whyDeclaration(shape, mode, map, mapProducedValue),
+                    setupCommand: "tickmarkr fleet",
+                };
+            }
+        });
+        return projectFleetWhy(values, { repoRoot: cwd, globalDir });
+    };
+    const routedShapeRows = (mode, map) => projectedShapeRows(mode, map).map(({ id, label }) => ({ id, label }));
+    if (why)
+        return renderFleetWhy(projectedShapeRows(rm.mode.mode, editable.map));
     const candidatesForShape = (shape, mode, map) => shapeCandidates(previewTask(shape), previewCfg(mode, map), channels, profile).map((candidate) => ({
         id: `${candidate.assignment.adapter}:${candidate.assignment.model}`,
         label: candidateRow(candidate, cfg.pricing),
@@ -220,6 +255,7 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         const discovered = which === "review" ? [...reviewAdapters, ...seats] : seats;
         return [...discovered, ...current.filter((entry) => !discovered.includes(entry))];
     };
+    let pendingWrite = null;
     const reviewOverlay = (state) => {
         const staged = structuredClone(initial);
         staged.denyAdapters = state.denyAdapters;
@@ -237,42 +273,24 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         // the diff and asks for confirmation, but owns neither filesystem access nor a writer.
         const before = currentRepoOverlayText(cwd);
         const path = repoOverlayPath(cwd);
-        const existing = readOverlayFile(path);
         const modeChanged = state.selectedMode !== rm.mode.mode;
-        const writeMode = modeChanged
-            ? state.selectedMode
-            : existing.routing?.mode;
-        const merged = fleetEditableEquals(initial, staged)
-            ? structuredClone(existing)
-            : fleetRepoOverlayFromDelta(initial, staged, existing);
-        let steeringChanged = false;
-        for (const key of ["review", "consult"]) {
-            if (JSON.stringify(state.steering[key]) === JSON.stringify(initialSteering[key]))
-                continue;
-            steeringChanged = true;
-            const block = { ...merged[key] };
-            if (state.steering[key])
-                block.prefer = state.steering[key];
-            else
-                delete block.prefer;
-            if (Object.keys(block).length)
-                merged[key] = block;
-            else
-                delete merged[key];
-        }
-        const tierNotes = structuredClone(harvested.tiers);
-        for (const [adapter, models] of Object.entries(provenanceMap(staged))) {
-            for (const [model, note] of Object.entries(models)) {
-                (tierNotes[adapter] ??= {})[model] = note;
-            }
+        const steeringChanged = ["review", "consult"].some((key) => JSON.stringify(state.steering[key]) !== JSON.stringify(initialSteering[key]));
+        if (!modeChanged && !steeringChanged && fleetEditableEquals(initial, staged)) {
+            pendingWrite = null;
+            return { kind: "empty" };
         }
-        const after = withModeLine(repoOverlayYaml(merged, tierNotes, {
-            adapters: harvested.denyAdapters,
-            models: harvested.denyModels,
-        }), writeMode);
-        if ((!modeChanged && !steeringChanged && fleetEditableEquals(initial, staged)) || before === after) {
+        const write = {
+            initial,
+            edited: staged,
+            ...(modeChanged ? { mode: state.selectedMode } : {}),
+            steering: { initial: initialSteering, edited: state.steering },
+        };
+        const after = renderFleetOverlayWrite(before, write);
+        if (before === after) {
+            pendingWrite = null;
             return { kind: "empty" };
         }
+        pendingWrite = write;
         return {
             kind: "diff",
             before,
@@ -348,7 +366,9 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         return "fleet: discarded overlay changes";
     // The command remains the single config actuator. Every interactive edit reaches this
     // one write only after the component-rendered diff confirm and the production reload guard.
-    mkdirSync(dirname(result.review.path), { recursive: true });
-    writeFileSync(result.review.path, result.review.after);
+    const write = pendingWrite;
+    if (!write)
+        throw new Error("fleet write reached confirmation without a staged overlay mutation");
+    writeFleetOverlay(result.review.path, (prior) => renderFleetOverlayWrite(prior, write));
     return `fleet: wrote ${result.review.path}`;
 }

package/dist/cli/commands/init.js

@@ -109,6 +109,43 @@ A run is green only when the run-end event exists in the journal AND tip verify
 ### Verified handoffs
 
 When relaying missions between agents, never use bare send-text (\`herdr agent send\` / pane send-text) — it omits Enter. Use \`herdr pane run <pane> "<message>"\` or \`herdr notification show "<message>"\`. Confirm delivery by reading the target pane afterward; never report "relayed" without read-back.
+
+### Orient before you act — this block may be the ONLY guidance your host loaded
+
+These same bytes are written into EVERY repository guidance file this project has, because hosts disagree
+about which one they read: some load only \`AGENTS.md\`, some also load a repo-level guidance file, some load
+a user-level one instead. **Anything stated in only one file is invisible to some agent.** So do not assume
+you were handed the whole picture — list the repository root, open every guidance file present, and then:
+
+- **Read your host's PROJECT MEMORY before starting.** Hosts that keep one store it under a per-project
+  state directory keyed by the absolute working-directory path; find it and read its index plus every entry
+  whose name concerns METHOD or DISCIPLINE. It holds rules that cost real defects to learn. Entries may
+  predate a project rename, so **search by CONCEPT, not by the current product name.** A memory nobody opens
+  is worse than none: every seat assumes the lesson is recorded somewhere and no seat looks.
+- **The gates are the product.** Seven, defined in \`src/graph/schema.ts\`:
+  \`build test lint evidence scope acceptance review\`. **That is DECLARATION order, not execution order** —
+  the first five run as a battery that stops at its first red, then \`acceptance\` and \`review\` run
+  CONCURRENTLY (\`run-gates.ts:39\`, *"judge ‖ review"*). The first five are MANDATORY; only \`acceptance\` and
+  \`review\` may be omitted per task. Implementations are in \`src/gates/\` — \`baseline.ts\` (build/test/lint,
+  diffed against a recorded baseline so pre-existing failures are forgiven), \`evidence.ts\`, \`scope.ts\`,
+  \`acceptance.ts\` (its judge reads the DIFF and every criterion must cite a changed hunk), \`review.ts\`
+  (cross-vendor). \`run-gates.ts\` drives them. **A declared gate is not a passed gate, and a gate that
+  returned zero findings is not the same as a gate that ran.**
+- **Spec-authoring law ships in the spec template** that \`tickmarkr init\` writes: the hard bounds and which
+  direction each moves, what makes a criterion real, and why an absence or a source-text grep is never a
+  criterion. Read it before authoring or repairing acceptance items.
+- **Editing \`src/gates/\`, \`src/compile/\` or \`src/graph/\`?** Read \`docs/codebase/ARCHITECTURE.md\` first.
+- **EVERY fix gets a ship/no-ship decision, recorded, at the moment it is made.** Ask one question of each
+  one: *does a user hit this defect?* If yes, the fix belongs in \`src/**\` or \`skills/**\` — the only trees
+  the package carries (\`files: [dist, schema, skills, fixtures]\`). A script, overlay, config entry or
+  operator-side workaround that resolves the symptom **locally is not the fix; it is a decision to leave
+  every other user broken**, and it must say so in writing and name the condition that removes it.
+  **The default answer is SHIP.** A local remedy is the exception and carries the burden of proof.
+  Watch for the three shapes this hides in: a fix applied where you happened to be standing rather than
+  where the defect lives; an observation filed with a product fix named in its own text and queued
+  nowhere; and a local tool that quietly grows into a product feature nobody shipped. **A defect and its
+  fix must be recorded in the same place, or the queue silently becomes a list of things everyone assumed
+  someone else had shipped.**
 ${DOCS_END}
 `;
 // Every applicable host location gets the skills, each paired with its own repository guidance
@@ -120,6 +157,54 @@ const hostTargets = (cwd) => {
         targets.push({ skillsDir: join(cwd, ".claude", "skills"), docPath: join(cwd, "CLAUDE.md") });
     return targets;
 };
+const packagedSkillDir = (skill) => fileURLToPath(new URL(`../../../skills/${skill}`, import.meta.url));
+// Every file the package ships for a skill, DERIVED from the tree rather than listed. OBS-373: a script
+// was added to the shipped overseer skill long after repos had installed it, and because the SKILL.md
+// that MANDATES that script was already on disk, every existence check reported "installed" while the
+// thing the skill tells you to run was absent. A literal list here would be the same closed-set-restated
+// defect one layer down, so this walks instead.
+function skillFileList(root, prefix = "") {
+    return readdirSync(root, { withFileTypes: true })
+        .sort((a, b) => a.name.localeCompare(b.name))
+        .flatMap((entry) => {
+        const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+        return entry.isDirectory() ? skillFileList(join(root, entry.name), rel) : [rel];
+    });
+}
+// Drift is only computed for skills that ARE installed. A skill never installed is not drift — `--agent`
+// installs it and says so, and nagging about it would bury the case this exists for.
+function skillDrift(cwd) {
+    const drifted = [];
+    for (const { skillsDir } of hostTargets(cwd)) {
+        for (const skill of AGENT_SKILLS) {
+            const dir = join(skillsDir, skill);
+            if (!existsSync(join(dir, "SKILL.md")))
+                continue;
+            const src = packagedSkillDir(skill);
+            const missing = [];
+            const modified = [];
+            for (const rel of skillFileList(src)) {
+                // readFileSync resolves symlinks, so a symlinked mirror compares equal to a copied one.
+                if (!existsSync(join(dir, rel)))
+                    missing.push(rel);
+                else if (!readFileSync(join(dir, rel)).equals(readFileSync(join(src, rel))))
+                    modified.push(rel);
+            }
+            if (missing.length || modified.length)
+                drifted.push({ skill, dir, missing, modified });
+        }
+    }
+    return drifted;
+}
+// Name what drifted. "stale" alone sends the reader to diff three directories by hand, and the file that
+// matters is usually the one they never knew shipped.
+const describeDrift = (d) => [
+    d.missing.length ? `missing ${d.missing.join(", ")}` : "",
+    d.modified.length ? `modified ${d.modified.join(", ")}` : "",
+].filter(Boolean).join(", ");
+// PRESENCE, deliberately — the wizard's question is "install these?", and a repo that already has them
+// should not be asked again just because a copy drifted. Staleness is a different question with a
+// different answer (`--agent --force`), and it is reported by name on every init path below.
 const skillsInstalled = (cwd) => hostTargets(cwd).every((t) => AGENT_SKILLS.every((s) => existsSync(join(t.skillsDir, s, "SKILL.md"))));
 const wizardDriverDefault = () => process.env.HERDR_ENV === "1" ? "herdr" : "auto";
 async function installAgentFiles(cwd, force, docs, notes) {
@@ -132,12 +217,20 @@ async function installAgentFiles(cwd, force, docs, notes) {
         return /^(?:y|yes)$/i.test((await prompt.question(`${question} [y/N] `)).trim());
     };
     try {
+        const drift = skillDrift(cwd);
         for (const { skillsDir, docPath } of hostTargets(cwd)) {
             for (const skill of AGENT_SKILLS) {
                 const dest = join(skillsDir, skill, "SKILL.md");
                 const exists = existsSync(dest);
-                if (exists && !force && !(await confirm(`Overwrite ${dest}?`))) {
-                    notes.push(`skipped existing ${dest}; pass --force to overwrite it`);
+                const stale = drift.find((d) => d.dir === join(skillsDir, skill));
+                // An install that already matches the package byte for byte needs no prompt and no write. Before
+                // this, every re-init asked to overwrite a current skill and the answer meant nothing either way.
+                if (exists && !stale) {
+                    notes.push(`kept current ${dest}`);
+                    continue;
+                }
+                if (exists && !force && !(await confirm(`Overwrite ${dest} (${describeDrift(stale)})?`))) {
+                    notes.push(`skipped existing ${dest} — ${describeDrift(stale)}; pass --force to overwrite it`);
                     continue;
                 }
                 // whole skill dir, not just SKILL.md — the overseer ships its pane-watcher script
@@ -145,9 +238,21 @@ async function installAgentFiles(cwd, force, docs, notes) {
                 notes.push(`${exists ? "overwrote" : "wrote"} ${dest}`);
             }
             const current = existsSync(docPath) ? readFileSync(docPath, "utf8") : "";
-            if (current.includes(DOCS_BEGIN) || current.includes(`<!-- ${LEGACY_PREFIX}:agent-docs begin -->`)
-                || current.includes(DOCS_END) || current.includes(`<!-- ${LEGACY_PREFIX}:agent-docs end -->`)) {
-                notes.push(`kept existing tickmarkr agent docs in ${docPath}`);
+            // The block is CANONICAL guidance ("stated once here, restated nowhere"), so a repo that has
+            // run init once must still be able to receive corrections to it. Before v1.86 this branch only
+            // ever said "kept", with no lever — not even --force, which IS honoured for skills above. So
+            // the block was write-once and every later improvement reached new repos only. Under --force,
+            // replace the marked region in place and leave every human-authored line outside it untouched.
+            const marked = new RegExp(`<!-- (?:tickmarkr|${LEGACY_PREFIX}):agent-docs begin -->[\\s\\S]*?`
+                + `<!-- (?:tickmarkr|${LEGACY_PREFIX}):agent-docs end -->`);
+            if (marked.test(current)) {
+                if (force) {
+                    writeFileSync(docPath, current.replace(marked, AGENT_DOCS.trimEnd()));
+                    notes.push(`refreshed tickmarkr agent docs in ${docPath}`);
+                }
+                else {
+                    notes.push(`kept existing tickmarkr agent docs in ${docPath}; pass --force to refresh them`);
+                }
             }
             else if (docs || await confirm(`Append tickmarkr agent docs to ${docPath}?`)) {
                 appendFileSync(docPath, `${current ? current.endsWith("\n") ? "\n" : "\n\n" : ""}${AGENT_DOCS}`);
@@ -249,6 +354,14 @@ export async function init(argv, cwd = process.cwd()) {
             notes.push(`wrote ${specPath}`);
         }
     }
+    // Say it on EVERY init, not only the --agent path. The upgrade that produced OBS-373 is silent by
+    // shape: the package moves, the installed copy does not, and nothing in the repo changes to hint at it.
+    // --agent reports drift per skill below, so this only speaks when that path will not.
+    if (!values.agent) {
+        for (const d of skillDrift(cwd)) {
+            notes.push(`stale ${join(d.dir, "SKILL.md")} — ${describeDrift(d)}; run tickmarkr init --agent --force to refresh it`);
+        }
+    }
     const fresh = values.fresh ?? false;
     const { reuse, ageMs, health } = initDoctorReuse(cwd, fresh);
     const doc = reuse && health && ageMs !== null

package/dist/cli/commands/status.js

@@ -9,6 +9,7 @@ import { foldActivity } from "../../run/activity.js";
 import { Journal, engagementComparable, isQualityFailureParkKind, recordedTaskFailureKind, runHasEnded, } from "../../run/journal.js";
 import { normalizeStallSnapshot } from "../../run/stall.js";
 import { deriveRunCockpitData, } from "../../tui/cockpit/derive.js";
+import { cellWidth, fitCells } from "../../tui/cockpit/width.js";
 // ponytail: fixed 2s refresh; promote to config.visibility.* only when an operator asks.
 const REFRESH_MS = 2000;
 const NOT_COMPARABLE_NOTICE = "graph recompiled since this run — task states not comparable; resume with `--graph-changed` to audit this recompile";
@@ -132,6 +133,20 @@ const optionValue = (argv, name) => {
     const value = index >= 0 ? argv[index + 1] : undefined;
     return value && !value.startsWith("-") ? value : undefined;
 };
+// The one positional this command takes: an explicit run id. Everything else is a flag or a flag's
+// value (`--webhook <url>`), so the first bare token that is not a --webhook value is the run id.
+const positionalRunId = (argv) => {
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === "--webhook") {
+            i += 1;
+            continue;
+        }
+        if (!arg.startsWith("-"))
+            return arg;
+    }
+    return undefined;
+};
 const defaultPostWebhook = (url, event) => fetch(url, {
     method: "POST",
     headers: { "content-type": "application/json" },
@@ -307,13 +322,18 @@ const failedSuffix = (states) => {
 // cell when present: a post-approval park is not awaiting the designed gate. Plain text for column
 // math; rendered with a dim dot + warn words. TTY-only — the non-TTY surface stays byte-pinned.
 export const humanGateSuffix = (t, st, states) => st === "human" && t.humanGate && failedGates(states).length === 0 ? " · awaiting approval" : "";
+// Task titles are graph-authored data. Remove terminal controls and row-breaking whitespace before
+// either width measurement or rendering so zero-cell ECMA-48 bytes cannot escape the task column.
+const ECMA_48_CONTROL = /(?:\u001B\][\s\S]*?(?:\u0007|\u001B\\)|\u009D[\s\S]*?(?:\u0007|\u009C)|\u001B[P^_X][\s\S]*?\u001B\\|[\u0090\u0098\u009E\u009F][\s\S]*?\u009C|(?:\u001B\[|\u009B)[0-?]*[ -/]*[@-~]|\u001B[@-_])/gu;
+const sanitizeTaskText = (text) => text.replace(ECMA_48_CONTROL, "").replace(/\p{Cc}/gu, " ").replace(/\s+/gu, " ").trim();
 export const shortGoal = (goal, max) => {
-    const clause = goal.split(/[,;.?!]/, 1)[0].trim();
-    if (clause.length <= max)
+    const clause = sanitizeTaskText(goal).split(/[,;.?!]/, 1)[0].trim();
+    const cells = Math.max(0, Math.floor(max));
+    if (cellWidth(clause) <= cells)
         return clause;
-    if (max <= 3)
-        return clause.slice(0, Math.max(0, max));
-    return `${clause.slice(0, max - 3).trimEnd()}...`;
+    if (cells <= 3)
+        return fitCells(clause, cells).trimEnd();
+    return `${fitCells(clause, cells - 3).trimEnd()}...`;
 };
 // VIS-11 (v1.13): a liveness header for renderFrame — last journal event age + whether the recorded
 // daemon pid is still alive. Honest about unknowns: a pre-v1.13 journal with no pid renders "unknown",
@@ -487,9 +507,11 @@ const parseJournalSnapshot = (raw) => raw.split("\n").flatMap((line) => {
         return [];
     }
 });
-const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness = new Map(), journalRowsOnly = false) => {
+const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness = new Map(), journalRowsOnly = false, namedRunId) => {
     const g = loadGraph(cwd);
-    const runId = Journal.latestRunId(cwd, { withJournal: true });
+    // An explicit <runId> is a resolution, not a hint: Journal.open below refuses an id without a
+    // readable journal, so status fails loudly naming that id instead of rendering any other run.
+    const runId = namedRunId ?? Journal.latestRunId(cwd, { withJournal: true });
     const assignments = new Map();
     let replayed = null;
     let cockpit;
@@ -619,7 +641,7 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
             const chain = gateChain(states, false);
             const prefix = livePhase ? `  ${ASCII_SPINNER[animationFrame % ASCII_SPINNER.length]} ${t.id} ` : `  ${surfaceTaskBox(st, merged)} ${t.id} `;
             const suffix = `  ${chain}${priorGraph ? ` ${PRIOR_GRAPH_MARKER}` : ""}  ${livePhase ? "running" : surfaceStatusWord(st)}${label}  ${assignCol}`;
-            return `${prefix}${shortGoal(t.goal, Math.max(0, width - prefix.length - suffix.length))}${suffix}`;
+            return `${prefix}${shortGoal(t.title, Math.max(0, width - prefix.length - suffix.length))}${suffix}`;
         });
         const zone = journalRowsOnly ? `${divider}zone ${localZoneLabel(zoneReference)}` : "";
         const header = runId
@@ -668,9 +690,9 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
     const nowLine = activity.now ? [legend(`   now: ${activity.now}`)] : [];
     const gatesLegend = legend(`   gates: ${GATE_NAMES.join(" · ")}`);
     // Two-line card per task (operator request, v1.67): line 1 carries identity + verdict — glyph,
-    // id, goal at full width, and only SHORT status words. Line 2 carries the machinery, dim and
-    // aligned under the goal: gate chain, live activity phrase (or channel), ctx. Long channel names
-    // and activity phrases live on line 2 only, so they can never squeeze the goal or wrap line 1.
+    // id, title at full width, and only SHORT status words. Line 2 carries the machinery, dim and
+    // aligned under the title: gate chain, live activity phrase (or channel), ctx. Long channel names
+    // and activity phrases live on line 2 only, so they can never squeeze the title or wrap line 1.
     const taskVerdict = (c) => c.merged ? "pass" : c.redTier ? "fail" : c.st === "failed" || c.st === "human" ? "warn" : "neutral";
     const statusWord = (c) => c.livePhase ? "running" : c.redTier ? "failed" : c.st === "failed" ? "warn" : surfaceStatusWord(c.st);
     const idW = Math.max(...cells.map((c) => c.t.id.length), 2);
@@ -679,9 +701,9 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
         + humanGateSuffix(c.t, graphTaskStatus(c.st, c.t.status), c.states);
     const stW = Math.max(...cells.map((c) => statusWord(c).length + suffixPlain(c).length));
     const avail = Math.max(8, width - (5 + idW) - 2 - stW);
-    const goals = cells.map((c) => shortGoal(c.t.goal, avail));
-    const goalW = Math.max(8, ...goals.map((s) => s.length));
-    const indent = " ".repeat(idW + 5); // line 2 starts under the goal column
+    const titles = cells.map((c) => shortGoal(c.t.title, avail));
+    const titleW = Math.max(8, ...titles.map(cellWidth));
+    const indent = " ".repeat(idW + 5); // line 2 starts under the title column
     const rows = cells.map((c, i) => {
         const { t, st, merged, failureKind, redTier, states, priorGraph, isStarved, phrase, channel, ctx, livePhase } = c;
         const word = statusWord(c);
@@ -695,7 +717,8 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
             (isStarved ? dot + fail("starved") : "") +
             (f.length ? dot + fail(f.join(", ")) : "") +
             (human ? dot + warn("awaiting approval") : "");
-        const taskLabel = `${t.id.padEnd(idW)} ${goals[i].padEnd(goalW)}  ${statusCell}`;
+        const taskTitle = titles[i];
+        const taskLabel = `${t.id.padEnd(idW)} ${taskTitle}${" ".repeat(titleW - cellWidth(taskTitle))}  ${statusCell}`;
         const line1 = livePhase
             ? `  ${(staleWorker ? warn : dim)(SPINNER[animationFrame % SPINNER.length])} ${taskLabel}`
             : `  ${statusRow(taskVerdict(c), taskLabel)}`;
@@ -718,9 +741,10 @@ const renderFrame = (cwd, now = Date.now(), animationFrame = 0, workerLiveness =
     };
 };
 export async function status(argv, cwd = process.cwd(), opts = {}) {
+    const namedRunId = positionalRunId(argv);
     // cockpit surface: banner + frame on a TTY (doctor's pattern); pipes get the bare frame
     if (!argv.includes("--watch")) {
-        const { content } = renderFrame(cwd, opts.now?.() ?? Date.now());
+        const { content } = renderFrame(cwd, opts.now?.() ?? Date.now(), 0, undefined, false, namedRunId);
         return visual() ? BANNER + content : content;
     }
     const eventStream = argv.some((arg) => arg === "--events" || arg === "--jsonl" || arg === "--decision-events");
@@ -782,7 +806,9 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
     let decisionRunId;
     let journalCursor = 0;
     const consumeDecisionEvents = () => {
-        const runId = Journal.latestRunId(cwd, { withJournal: true });
+        // A named run is followed, never re-resolved: --watch <runId> keeps reporting that run even as
+        // newer runs start. Only the no-argument form tracks latest, as before.
+        const runId = namedRunId ?? Journal.latestRunId(cwd, { withJournal: true });
         if (!runId)
             return [];
         if (decisionRunId !== runId) {
@@ -839,7 +865,7 @@ export async function status(argv, cwd = process.cwd(), opts = {}) {
                 }
             }
             else {
-                frame = renderFrame(cwd, nowMs, i, workerLiveness, true);
+                frame = renderFrame(cwd, nowMs, i, workerLiveness, true, namedRunId);
                 if (tty) {
                     updateTitle(frame.hotPhase, nowMs);
                     process.stdout.write(`\x1b[2J\x1b[H${BANNER}${frame.content}\n${legend(` watching · refresh ${REFRESH_MS / 1000}s · ^C to quit`)}`);

package/dist/compile/gsd.d.ts

@@ -1,3 +1,4 @@
-import { type RunGraph } from "../graph/schema.js";
+import { type AcceptanceItem, type RunGraph } from "../graph/schema.js";
 export declare function isGsdPhaseDir(dir: string): boolean;
+export declare function parseTruths(file: string, raw: unknown): AcceptanceItem[] | undefined;
 export declare function compileGsd(src: string, root?: string): RunGraph;