tickmarkr 2.5.3 → 2.5.5

package/dist/cli/commands/init.js

@@ -1,6 +1,6 @@
 import { execFileSync } from "node:child_process";
-import { appendFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, writeFileSync } from "node:fs";
-import { join, relative } from "node:path";
+import { appendFileSync, cpSync, existsSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, writeFileSync } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 import { createInterface } from "node:readline/promises";
 import { parseArgs } from "node:util";
@@ -9,10 +9,11 @@ import { allAdapters, formatDoctorAgeForInit, formatDoctorReport, initDoctorReus
 import { configTemplate, DEFAULT_CONFIG, globalConfigDir, loadConfig } from "../../config/config.js";
 import { LEGACY_PREFIX, specTemplate } from "../../compile/native.js";
 import { BANNER, kvRow, legend, rule, statusRow, title } from "../../brand.js";
-import { tickmarkrDir } from "../../graph/graph.js";
+import { stateDirName, tickmarkrDir } from "../../graph/graph.js";
 import { orcaHostDetected } from "../../drivers/index.js";
+import { WORKTREES_DIR } from "../../run/git.js";
 import { Journal } from "../../run/journal.js";
-import { runLockRunId, runStatusLine } from "../../run/lock.js";
+import { runLockOwner, runLockRunId, runStatusLine } from "../../run/lock.js";
 import { doctor } from "./doctor.js";
 import { assembleFleetEditor } from "./fleet.js";
 const SCAFFOLD_SPEC = "tickmarkr.spec.md";
@@ -340,6 +341,191 @@ async function runInitWizard(cwd, input, output) {
         return null;
     return { overlay: result.overlay, installSkills: result.installSkills, installDocs: result.installDocs };
 }
+function realpathSafe(p) {
+    try {
+        return realpathSync(p);
+    }
+    catch {
+        const parent = dirname(p);
+        if (parent === p)
+            return p;
+        return join(realpathSafe(parent), basename(p));
+    }
+}
+function isPathInside(parentDir, candidatePath) {
+    const resolvedParent = realpathSafe(resolve(parentDir));
+    const resolvedCandidate = realpathSafe(resolve(candidatePath));
+    const rel = relative(resolvedParent, resolvedCandidate);
+    return rel !== "" && rel !== ".." && !rel.startsWith(`..${sep}`) && !isAbsolute(rel);
+}
+/**
+ * The ONLY way the --remove path runs git: GIT_DIR, GIT_WORK_TREE and GIT_COMMON_DIR are stripped so the repository acted on
+ * is always cwd's own, and LC_ALL=C keeps stderr parseable. Throws execFileSync's error (status, stderr) unchanged.
+ */
+function removeGit(cwd, args) {
+    const { GIT_DIR: _dir, GIT_WORK_TREE: _workTree, GIT_COMMON_DIR: _commonDir, ...env } = process.env;
+    return execFileSync("git", args, { cwd, env: { ...env, LC_ALL: "C" }, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+}
+function isLinkedWorktree(cwd) {
+    try {
+        const gitDir = removeGit(cwd, ["rev-parse", "--git-dir"]).trim();
+        const gitCommonDir = removeGit(cwd, ["rev-parse", "--git-common-dir"]).trim();
+        return resolve(cwd, gitDir) !== resolve(cwd, gitCommonDir);
+    }
+    catch {
+        return false;
+    }
+}
+function checkLiveLock(cwd) {
+    const localOwner = runLockOwner(cwd);
+    if (localOwner?.live)
+        return localOwner;
+    try {
+        const gitDir = removeGit(cwd, ["rev-parse", "--git-dir"]).trim();
+        const gitCommonDir = removeGit(cwd, ["rev-parse", "--git-common-dir"]).trim();
+        if (resolve(cwd, gitDir) !== resolve(cwd, gitCommonDir)) {
+            const mainRepo = dirname(resolve(cwd, gitCommonDir));
+            const mainOwner = runLockOwner(mainRepo);
+            if (mainOwner?.live)
+                return mainOwner;
+        }
+    }
+    catch {
+        // not a git repo
+    }
+    return undefined;
+}
+/**
+ * Only git's discovery answer — exit 128, stderr `fatal: not a git repository (or any of the parent directories)` — means false.
+ * Every other failure (explicit bad GIT_DIR, invalid gitfile, permission, missing binary) refuses: unregistration could not be verified.
+ */
+function isGitRepo(cwd) {
+    try {
+        removeGit(cwd, ["rev-parse", "--is-inside-work-tree"]);
+        return true;
+    }
+    catch (err) {
+        const e = err;
+        const stderr = String(e.stderr ?? "").trim();
+        if (e.status === 128 && stderr.startsWith("fatal: not a git repository (or any of the parent directories)"))
+            return false;
+        throw new Error(`cannot remove: git repository probe failed: ${stderr || e.message || "unknown error"}`);
+    }
+}
+/** Runs git and throws `message` plus git's stderr on failure — a remove never proceeds past a failed step. */
+function git(cwd, args, message) {
+    try {
+        return removeGit(cwd, args);
+    }
+    catch (err) {
+        const stderr = String(err.stderr ?? "").trim();
+        throw new Error(stderr ? `${message}: ${stderr}` : message);
+    }
+}
+function registeredWorktrees(cwd, worktreesDir) {
+    const out = git(cwd, ["worktree", "list", "--porcelain"], "cannot remove: git worktree list failed");
+    return out
+        .split("\n")
+        .filter((line) => line.startsWith("worktree "))
+        .map((line) => line.slice("worktree ".length).trim())
+        .filter((wt) => isPathInside(worktreesDir, wt));
+}
+function handleRemove(cwd) {
+    const owner = checkLiveLock(cwd);
+    if (owner?.live) {
+        const holder = typeof owner.pid === "number" ? `live pid ${owner.pid}` : (owner.pid ?? "unreadable payload");
+        throw new Error(`cannot remove: graph.lock held by ${holder}`);
+    }
+    if (isLinkedWorktree(cwd)) {
+        throw new Error("cannot remove from inside a linked worktree");
+    }
+    const notes = [];
+    const stateDir = join(cwd, stateDirName(cwd));
+    const worktreesDir = join(stateDir, WORKTREES_DIR);
+    // 1. Unregister every git worktree under stateDir/WORKTREES_DIR, and prove it, before deleting anything
+    if (isGitRepo(cwd)) {
+        for (const wt of registeredWorktrees(cwd, worktreesDir)) {
+            // double --force: git refuses a locked worktree (present or already deleted) with a single one
+            git(cwd, ["worktree", "remove", "--force", "--force", wt], `cannot remove: failed to unregister worktree ${wt}`);
+        }
+        git(cwd, ["worktree", "prune"], "cannot remove: git worktree prune failed");
+        const left = registeredWorktrees(cwd, worktreesDir);
+        if (left.length > 0) {
+            throw new Error(`cannot remove: worktrees still registered: ${left.join(", ")}`);
+        }
+    }
+    // 2. Delete .tickmarkr state directory
+    if (existsSync(stateDir)) {
+        rmSync(stateDir, { recursive: true, force: true });
+        notes.push(`deleted state directory ${stateDir}`);
+    }
+    // 3. Delete shipped skill directories at every host location
+    const targetSkillDirs = [
+        join(cwd, ".agents", "skills"),
+        join(cwd, ".claude", "skills"),
+    ];
+    for (const dir of targetSkillDirs) {
+        for (const skill of AGENT_SKILLS) {
+            const skillPath = join(dir, skill);
+            if (existsSync(skillPath)) {
+                rmSync(skillPath, { recursive: true, force: true });
+                notes.push(`deleted skill ${skillPath}`);
+            }
+        }
+    }
+    // 4. Delete marker-bounded guidance block in AGENTS.md and CLAUDE.md leaving every byte outside identical
+    const marked = new RegExp(`<!-- (?:tickmarkr|${LEGACY_PREFIX}):agent-docs begin -->[\\s\\S]*?`
+        + `<!-- (?:tickmarkr|${LEGACY_PREFIX}):agent-docs end -->`);
+    for (const doc of ["AGENTS.md", "CLAUDE.md"]) {
+        const docPath = join(cwd, doc);
+        if (existsSync(docPath)) {
+            const current = readFileSync(docPath, "utf8");
+            const m = current.match(marked);
+            if (m && m.index !== undefined) {
+                const before = current.slice(0, m.index);
+                const after = current.slice(m.index + m[0].length);
+                writeFileSync(docPath, before + after);
+                notes.push(`removed guidance block from ${docPath}`);
+            }
+        }
+    }
+    // 5. Delete scaffold spec only while it still equals the shipped template
+    const specPath = join(cwd, SCAFFOLD_SPEC);
+    if (existsSync(specPath)) {
+        const currentSpec = readFileSync(specPath, "utf8");
+        if (currentSpec === specTemplate()) {
+            rmSync(specPath, { force: true });
+            notes.push(`deleted scaffold spec ${specPath}`);
+        }
+        else {
+            notes.push(`kept edited spec ${specPath}`);
+        }
+    }
+    // 6. Query and print remaining branches and preserved refs
+    let branches = [];
+    try {
+        const out = removeGit(cwd, ["for-each-ref", "--format=%(refname:short)", "refs/heads/tickmarkr/"]);
+        branches = out.split("\n").map((b) => b.trim()).filter(Boolean);
+    }
+    catch {
+        // ignore
+    }
+    let preservedRefs = [];
+    try {
+        const out = removeGit(cwd, ["for-each-ref", "--format=%(refname)", "refs/tickmarkr/preserved/"]);
+        preservedRefs = out.split("\n").map((r) => r.trim()).filter(Boolean);
+    }
+    catch {
+        // ignore
+    }
+    for (const b of branches) {
+        notes.push(`left branch: ${b}`);
+    }
+    for (const r of preservedRefs) {
+        notes.push(`left ref: ${r}`);
+    }
+    return notes.join("\n");
+}
 export async function init(argv, cwd = process.cwd(), io = {}) {
     let bannerEmitted = false;
     const emitBanner = () => {
@@ -348,6 +534,8 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
             process.stdout.write(BANNER);
         }
     };
+    // banner at START on the visual surface — every init path, not just the wizard, and never trailing the probe (operator report 2026-07-17)
+    emitBanner();
     const { values } = parseArgs({
         args: argv,
         options: {
@@ -357,13 +545,15 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
             docs: { type: "boolean" },
             fresh: { type: "boolean" },
             yes: { type: "boolean" },
+            remove: { type: "boolean" },
         },
     });
-    // banner at START on the visual surface — every init path, not just the wizard, and never trailing the probe (operator report 2026-07-17)
-    emitBanner();
     if (packageName(cwd) === "tickmarkr") {
         throw new Error("OBS-584: tickmarkr init refuses to run inside the tickmarkr source repository");
     }
+    if (values.remove) {
+        return handleRemove(cwd);
+    }
     const gdir = values["global-dir"] ?? globalConfigDir();
     mkdirSync(gdir, { recursive: true });
     const notes = [];

package/dist/cli/commands/plan.js

@@ -1,4 +1,4 @@
-import { existsSync, readdirSync } from "node:fs";
+import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { parseArgs } from "node:util";
 import { allAdapters, doctorAgeMs, modelAuthExclusions, probeAll, readDoctor, rolePools, servableExclusions, servabilityLine } from "../../adapters/registry.js";
@@ -11,11 +11,11 @@ import { graphDefinitionHash, loadGraph, stateDirName } from "../../graph/graph.
 import { renderAcceptanceItem } from "../../graph/schema.js";
 import { resolveRunMode } from "../../run/daemon.js";
 import { disallowedBy, excludedChannels, exclusionLine, routingEntrySeatLines } from "../../route/preference.js";
-import { staffLedEvidence } from "../../route/profile.js";
+import { decayWeight, HALF_LIFE_RUNS, staffLedEvidence } from "../../route/profile.js";
 import { route, RoutingError } from "../../route/router.js";
 import { auditNamedTestOracles, listVitestTests } from "../../gates/acceptance.js";
 import { modelId, modelProvider, pickReviewer } from "../../gates/review.js";
-import { Journal, loadRoutingProfile, recordedGraphDefinitionHash } from "../../run/journal.js";
+import { Journal, loadRoutingProfile, readProfileCursor, recordedGraphDefinitionHash, RUNS_WINDOW } from "../../run/journal.js";
 import { harnessLine, resolveHarness } from "../harness.js";
 import { channelKey, shq } from "../../adapters/types.js";
 import { shGit } from "../../run/git.js";
@@ -292,6 +292,7 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
             }
         }
     }
+    lints.push(...tierEscalationAdvisories(cwd, cfg, g.tasks));
     for (const [role, sel] of [["judge", cfg.judge], ["consult", cfg.consult]]) {
         if (!health[sel.adapter]?.installed)
             lints.push(`${role}: ${sel.adapter}:${sel.model} not installed — that gate/consult will fail closed`);
@@ -437,3 +438,143 @@ export async function plan(argv, cwd = process.cwd(), adapters = allAdapters(),
         lines.push("", "scope lints:", ...scopeLints.map((l) => `  ! ${l}`));
     return stylizePlan(lines.join("\n"));
 }
+function extractClimb(event, taskShapeMap) {
+    if (event.event !== "tier-escalated")
+        return undefined;
+    const d = (event.data && typeof event.data === "object") ? event.data : {};
+    const shape = (typeof d.shape === "string" && d.shape)
+        || (typeof event.shape === "string" && event.shape)
+        || (typeof event.taskId === "string" ? taskShapeMap.get(event.taskId) : undefined)
+        || (typeof d.taskId === "string" ? taskShapeMap.get(d.taskId) : undefined);
+    if (!shape)
+        return undefined;
+    const beforeAssignment = (d.beforeAssignment && typeof d.beforeAssignment === "object") ? d.beforeAssignment : undefined;
+    const afterAssignment = (d.afterAssignment && typeof d.afterAssignment === "object") ? d.afterAssignment : undefined;
+    let fromTier = (typeof d.fromTier === "string" && d.fromTier)
+        || (typeof d.from === "string" && d.from)
+        || (typeof d.tierBefore === "string" && d.tierBefore)
+        || (typeof d.before === "string" && d.before)
+        || (typeof d.previousTier === "string" && d.previousTier)
+        || (typeof event.fromTier === "string" && event.fromTier)
+        || (typeof event.from === "string" && event.from)
+        || (typeof beforeAssignment?.tier === "string" && beforeAssignment.tier);
+    let toTier = (typeof d.toTier === "string" && d.toTier)
+        || (typeof d.to === "string" && d.to)
+        || (typeof d.tierAfter === "string" && d.tierAfter)
+        || (typeof d.after === "string" && d.after)
+        || (typeof d.nextTier === "string" && d.nextTier)
+        || (typeof d.tier === "string" && d.tier)
+        || (typeof event.toTier === "string" && event.toTier)
+        || (typeof event.to === "string" && event.to)
+        || (typeof afterAssignment?.tier === "string" && afterAssignment.tier);
+    if (!fromTier || !toTier) {
+        const text = [d.details, d.message, d.reason, d.summary, d.provenance].filter((s) => typeof s === "string").join(" ");
+        const m = /\b(cheap|mid|frontier)\s+to\s+(cheap|mid|frontier)\b/i.exec(text);
+        if (m) {
+            fromTier = fromTier || m[1].toLowerCase();
+            toTier = toTier || m[2].toLowerCase();
+        }
+    }
+    if (!fromTier || !toTier)
+        return undefined;
+    return { shape, fromTier, toTier };
+}
+function tierEscalationAdvisories(cwd, cfg, graphTasks) {
+    const runsRoot = join(cwd, stateDirName(cwd), "runs");
+    if (!existsSync(runsRoot))
+        return [];
+    let candidateRunIds;
+    try {
+        candidateRunIds = readdirSync(runsRoot)
+            .filter((d) => d.startsWith("run-") && existsSync(join(runsRoot, d, "journal.jsonl")))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+    const cursor = readProfileCursor(cwd);
+    if (cursor)
+        candidateRunIds = candidateRunIds.filter((id) => id > cursor);
+    const windowRunIds = candidateRunIds.slice(-RUNS_WINDOW);
+    if (!windowRunIds.length)
+        return [];
+    // Leg-2 T5 (OBS-971): task ids restart at T1 every spec, so a shape lookup is only valid against the
+    // graph the run actually executed. Fallback to the current graph only when the run left no snapshot.
+    const currentShapeMap = new Map(graphTasks.map((t) => [t.id, t.shape]));
+    const numDistinct = windowRunIds.length;
+    const ascIndex = new Map(windowRunIds.map((id, i) => [id, i]));
+    const halfLife = cfg.routing.learnedTuning?.halfLifeRuns ?? HALF_LIFE_RUNS;
+    const shapeClimbs = new Map();
+    for (const runId of windowRunIds) {
+        const journalPath = join(runsRoot, runId, "journal.jsonl");
+        let lines;
+        try {
+            lines = readFileSync(journalPath, "utf8").split("\n");
+        }
+        catch {
+            continue;
+        }
+        let taskShapeMap = currentShapeMap;
+        const runGraphPath = join(runsRoot, runId, "graph.json");
+        if (existsSync(runGraphPath)) {
+            try {
+                const runGraph = JSON.parse(readFileSync(runGraphPath, "utf8"));
+                if (Array.isArray(runGraph.tasks)) {
+                    taskShapeMap = new Map();
+                    for (const rt of runGraph.tasks) {
+                        if (typeof rt?.id === "string" && typeof rt?.shape === "string")
+                            taskShapeMap.set(rt.id, rt.shape);
+                    }
+                }
+            }
+            catch {
+                // unreadable snapshot: fall back to the current graph
+            }
+        }
+        const runClimbedShapes = new Map();
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!parsed || typeof parsed !== "object")
+                continue;
+            const event = parsed;
+            if (event.event !== "tier-escalated")
+                continue;
+            const climb = extractClimb(event, taskShapeMap);
+            if (climb) {
+                runClimbedShapes.set(climb.shape, { fromTier: climb.fromTier, toTier: climb.toTier });
+            }
+        }
+        const age = numDistinct - 1 - ascIndex.get(runId);
+        const w = decayWeight(age, halfLife);
+        for (const [shape, { fromTier, toTier }] of runClimbedShapes) {
+            let entry = shapeClimbs.get(shape);
+            if (!entry) {
+                entry = { fromTier, toTier, runs: new Set(), weighted: 0 };
+                shapeClimbs.set(shape, entry);
+            }
+            const tierRank = (t) => (t in TIER_RANK ? TIER_RANK[t] : 0);
+            if (tierRank(toTier) > tierRank(entry.toTier)) {
+                entry.toTier = toTier;
+            }
+            entry.runs.add(runId);
+            entry.weighted += w;
+        }
+    }
+    const advisories = [];
+    for (const shape of [...shapeClimbs.keys()].sort()) {
+        const info = shapeClimbs.get(shape);
+        const climbedRuns = info.runs.size;
+        const totalRuns = numDistinct;
+        const weightVal = Number.isInteger(info.weighted) ? info.weighted : Number(info.weighted.toFixed(2));
+        advisories.push(`${shape}: climbed from ${info.fromTier} to ${info.toTier} in ${climbedRuns} of ${totalRuns} runs (weighted ${weightVal}) — consider routing.floors.${shape}: ${info.toTier}`);
+    }
+    return advisories;
+}

package/dist/cli/commands/resume.js

@@ -1,10 +1,11 @@
 import { parseArgs } from "node:util";
 import { loadConfig } from "../../config/config.js";
-import { parseDriverOverride, pickDriver } from "../../drivers/index.js";
+import { classifyHost, parseDriverOverride, pickDriver, preflightHostDriver } from "../../drivers/index.js";
 import { loadGraph } from "../../graph/graph.js";
 import { formatSummary, runDaemon } from "../../run/daemon.js";
 import { denyPreferCollisionLine, denyPreferCollisions } from "../../route/preference.js";
 import { narrationSink, bindNarration } from "./run.js";
+import { assertRefsWritable } from "../../run/git.js";
 const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
     && s.tipVerify !== "failed";
 export async function resume(argv, cwd = process.cwd()) {
@@ -36,6 +37,9 @@ export async function resume(argv, cwd = process.cwd()) {
     if (collisions.length) {
         throw new Error(collisions.map(denyPreferCollisionLine).join("; "));
     }
+    await assertRefsWritable(cwd, "resume");
+    const host = classifyHost();
+    preflightHostDriver(cfg, driverOverride, host);
     const narrate = narrationSink(runId);
     const s = await runDaemon(cwd, {
         runId,
@@ -43,7 +47,7 @@ export async function resume(argv, cwd = process.cwd()) {
         graphChanged,
         retryFailed,
         // bound to the same sink the daemon gets, so a driver-journaled recovery reaches this rail too
-        driver: bindNarration(pickDriver(cfg, driverOverride), narrate),
+        driver: bindNarration(pickDriver(cfg, driverOverride, host), narrate),
         // v1.99 T2: the ONE narration sink — the quiet rail on a TTY, the raw journal formatter on a
         // pipe. A resumed run meets the same surface a fresh one does; printing the raw formatter here
         // would leave `resume` as the last place the old unfiltered dump survives. Bound to the run id

package/dist/cli/commands/run.js

@@ -1,7 +1,7 @@
 import { parseArgs } from "node:util";
 import { allAdapters, discoverChannels, probeAll, readDoctor } from "../../adapters/registry.js";
 import { ROUTING_MODES } from "../../config/config.js";
-import { parseDriverOverride, pickDriver } from "../../drivers/index.js";
+import { classifyHost, parseDriverOverride, pickDriver, preflightHostDriver } from "../../drivers/index.js";
 import { loadGraph, onDiskSpecHash, readCompileRefusal } from "../../graph/graph.js";
 import { formatSummary, resolveRunMode, runDaemon } from "../../run/daemon.js";
 import { isRunLockLive } from "../../run/lock.js";
@@ -10,6 +10,7 @@ import { formatJournalNarration, loadRoutingProfile, newRunId } from "../../run/
 import { normalizeGateOutcome } from "../../run/outcome.js";
 import { GLYPHS, LIVE } from "../../brand.js";
 import { cellWidth, fitCells } from "../../tui/cockpit/width.js";
+import { assertRefsWritable } from "../../run/git.js";
 // ── the operator event rail (v1.99 T2) ──────────────────────────────────────────────────────────
 // A run's TTY narration is an operator EVENT RAIL, not the journal dump it used to echo. The
 // repetitive worker-contact / worker-status polls and the ungated phase-start rows are the bulk of
@@ -61,10 +62,16 @@ export const RAIL_ROWS = {
     // run lifecycle
     "run-start": { label: "started", tone: "active" },
     "run-resume": { label: "resumed", tone: "active" },
+    "restore-rerouted": { label: "restore rerouted", tone: "attention" },
+    "tier-escalated": { label: "tier climbed", tone: "attention" },
     "resume-restore": { label: "restored", tone: "neutral" },
     // the operator's audited --graph-changed release: the resumed run journals it through this sink
     "graph-rehash": { label: "graph rehashed", tone: "attention" },
     "lock-reclaimed": { label: "lock reclaimed", tone: "neutral" },
+    // WB-1 (OBS-988): the daemon noticed its own cockpit die and what it did about it
+    "watch-board-lost": { label: "board lost", tone: "attention" },
+    "watch-board-reopened": { label: "board reopened", tone: "pass" },
+    "watch-board-reopen-failed": { label: "board reopen failed", tone: "fail" },
     "run-end": { label: "finished", tone: "neutral" },
     "tip-verify": { label: "tip verify", tone: "pass" },
     "tip-verify-failed": { label: "tip verify", tone: "fail" },
@@ -99,6 +106,7 @@ export const RAIL_ROWS = {
     "gate-fingerprint-cap": { label: "repeat capped", tone: "attention" },
     // a scope red every collateral prediction already named: the daemon parks the task WITHOUT
     // charging an attempt, which is the most consequential unchargeable decision it makes
+    "scope-request": { label: "scope requested", tone: "attention" },
     "scope-authoring": { label: "authoring defect", tone: "attention" },
     "session-reset": { label: "session reset", tone: "attention" },
     "worker-mode-fallback": { label: "dispatch mode", tone: "attention" },
@@ -124,6 +132,9 @@ export const RAIL_ROWS = {
     "phase-start": { label: "gate start", tone: "active" },
     "gate-result": { label: "gate", tone: "pass" },
     "baseline-wait": { label: "baseline wait", tone: "active" },
+    "suite-wait": { label: "suite wait", tone: "active" },
+    "suite-wait-ceiling": { label: "suite wait ceiling", tone: "attention" },
+    "worker-reaped-before-harvest": { label: "worker reaped", tone: "attention" },
     "suite-budget": { label: "suite budget", tone: "attention" },
     "gate-replayed": { label: "gate replayed", tone: "attention" },
     "gate-reused": { label: "gate reused", tone: "neutral" },
@@ -215,6 +226,8 @@ const RAIL_SALIENT = [
     // both journal `gates: string[]` and neither states a scalar the ladder can pick up
     { key: "gates", render: (v) => (Array.isArray(v) && v.length > 0 ? `gates ${v.join(", ")}` : undefined) },
     { key: "channel", render: (v) => (typeof v === "string" ? `channel ${v}` : undefined) },
+    // the pane a board was lost on or reopened in — nothing on the ladder names it
+    { key: "pane", render: (v) => (typeof v === "string" ? `pane ${v}` : undefined) },
     { key: "status", render: (v) => (typeof v === "string" ? `status ${v}` : undefined) },
     { key: "cause", render: (v) => (typeof v === "string" ? `cause ${v}` : undefined) },
     { key: "silentMs", render: (v) => (typeof v === "number" ? `silent ${Math.round(v / 1000)}s` : undefined) },
@@ -311,6 +324,7 @@ const RAIL_PROJECTION = {
         ? `to ${d.chosen}${typeof d.static === "string" ? ` over ${d.static}` : ""}`
         : undefined,
     // both rehash hashes: the ladder reaches `from` (null on an unbound journal) and never `to`
+    "scope-request": (d) => Array.isArray(d.paths) ? `files[]: ${d.paths.join(", ")}` : undefined,
     "graph-rehash": (d) => (typeof d.to === "string" ? `to ${d.to.slice(0, 12)}` : undefined),
     "repair-dispatch": (d) => typeof d.diffBytes === "number" ? `diff ${d.diffBytes}B${d.capped === true ? ", capped" : ""}` : undefined,
     "tip-moved": (d) => typeof d.gatedCommit === "string" && typeof d.branchTip === "string"
@@ -319,6 +333,8 @@ const RAIL_PROJECTION = {
     "trust-auto-answer": (d) => typeof d.adapter === "string" ? `${d.adapter}${typeof d.phase === "string" ? ` ${d.phase}` : ""}` : undefined,
     // SB-1: the census the ceiling released beside, and the budget the round ran under versus the one it
     // would have had on an empty census — none of `{count, occupancyCap, conservativeCap}` is on the ladder
+    "suite-wait": (d) => typeof d.count === "number" ? `waiting for ${d.count} command(s)` : undefined,
+    "suite-wait-ceiling": (d) => typeof d.count === "number" ? `${d.count} still live after ${d.waitedMs}ms` : undefined,
     "suite-budget": (d) => typeof d.count === "number" && typeof d.conservativeCap === "number" && typeof d.occupancyCap === "number"
         ? `beside ${d.count}, cap ${d.conservativeCap} not ${d.occupancyCap}`
         : undefined,
@@ -493,6 +509,9 @@ export async function run(argv, cwd = process.cwd()) {
             if (lints.length)
                 throw new Error(`--route-strict: routing lints present, refusing to dispatch:\n${lints.join("\n")}`);
         }
+        await assertRefsWritable(cwd, "run");
+        const host = classifyHost();
+        preflightHostDriver(cfg, driverOverride, host);
         // The run id is minted HERE rather than inside the daemon, because the narration sink has to know
         // which run it is narrating before the first event arrives (the daemon's `narrate` callback is
         // handed an event and nothing else, and `run-start` carries no run id). `runDaemon` uses the id
@@ -502,7 +521,7 @@ export async function run(argv, cwd = process.cwd()) {
         const s = await runDaemon(cwd, {
             runId,
             concurrency: values.concurrency ? Number(values.concurrency) : undefined,
-            driver: bindNarration(pickDriver(cfg, driverOverride), narrate),
+            driver: bindNarration(pickDriver(cfg, driverOverride, host), narrate),
             mode: flagMode,
             supersedes: values.supersedes,
             narrate,

package/dist/cli/commands/verify.js

@@ -306,7 +306,7 @@ export async function verify(argv, cwd = process.cwd()) {
         worktree: cwd, baseRef: mergeBase,
         result: { ok: true, summary: "standalone verify — no worker claims to trust", deviations: [], raw: "" },
         author, commands, baseline, channels, ...(judgeChannels ? { judgeChannels } : {}), adapters, cfg,
-        pipeline: "v185", artifactDir,
+        pipeline: "v185", verificationScope: "standalone", artifactDir, stateDir: join(stateRoot, ".tickmarkr"),
         onGate: (e) => {
             if (e.phase === "start")
                 console.error(`verify: → ${e.gate} (${e.index}/${e.total})`);

package/dist/cli/help.d.ts

@@ -15,6 +15,7 @@ export declare const COMMAND_HELP: {
             "--docs": string;
             "--fresh": string;
             "--yes": string;
+            "--remove": string;
         };
         examples: string[];
     };
@@ -160,6 +161,7 @@ export declare const COMMAND_HELP: {
         usage: string;
         description: string;
         options: {
+            "--files <glob,\u2026>": string;
             "--by <name>": string;
             "--reason <text>": string;
             "--waive": string;

package/dist/cli/help.js

@@ -10,7 +10,8 @@ export const COMMAND_HELP = {
             "--docs": "Include agent guidance documents with --agent.",
             "--fresh": "Force fresh adapter probes instead of reusing recent health.",
             "--yes": "Skip the interactive setup wizard and use defaults.",
-        }, examples: ["init --yes", "init --agent --force --docs"],
+            "--remove": "Reverse init without scaffolding: delete state, skills, docs block, unedited spec, and prune worktrees.",
+        }, examples: ["init --yes", "init --agent --force --docs", "init --remove"],
     },
     doctor: {
         usage: "doctor [options]", description: "Probe configured adapters and models and print diagnostics. Default probing may make model calls and refresh a stale catalog.",
@@ -128,6 +129,7 @@ export const COMMAND_HELP = {
     approve: {
         usage: "approve <run-id> <task-id> [options]", description: "Append a validated park decision. A running owner may enact it; a closed run requires a separate resume. Decisions cannot be undone.",
         options: {
+            "--files <glob,…>": "Extend files[] for a scope-request park with comma-separated repository-relative globs; required for scope approval.",
             "--by <name>": "Name the actor (default: current OS user).",
             "--reason <text>": "Record the decision reason.",
             "--waive": "Waive only the identified failed gate.",

package/dist/compile/collateral.d.ts

@@ -28,6 +28,8 @@ export declare function classifyScopeOffenders(taskId: string, hard: ReadonlyArr
 /**
  * Return human-readable scope-lint lines for plan output (no `!` prefix — plan owns that).
  * Each line names the task id and at least one missing collateral test path.
+ * OBS-971: uncapped — every predicted path is listed, with direct importers of an owned source
+ * sorted first, followed by the total count. The runtime map (collateralHits) remains unchanged.
  */
 export declare function collateralLints(tasks: ReadonlyArray<Pick<Task, "id" | "files">>, repoRoot: string): string[];
 /**