tickmarkr 2.5.2 → 2.5.4

package/dist/run/git.d.ts

@@ -179,3 +179,28 @@ export type BaseContainment = {
  */
 export declare function declaredBaseContainment(cwd: string, declaredRef: string, targetRef?: string): Promise<BaseContainment>;
 export declare function removeWorktree(repo: string, dir: string): Promise<void>;
+export declare const REFS_PREFLIGHT_PREFIX = "refs/tickmarkr/preflight";
+export declare const REFS_PROBE_REMEDY = "run from the main repository or a full clone; a sandbox that denies writes under that path cannot host a run";
+export interface RefsProbeOk {
+    ok: true;
+    path: string;
+    refsDir: string;
+}
+export interface RefsProbeRefusal {
+    ok: false;
+    path: string;
+    refsDir: string;
+    error: string;
+}
+export type RefsProbeResult = RefsProbeOk | RefsProbeRefusal;
+export declare function refsRefusalMessage(action: "run" | "resume", path: string, error: string): string;
+/**
+ * OBS-983/984: prove the repository's common git directory accepts a ref write before starting
+ * the daemon. In a linked worktree, git resolves refs to the main repository's git directory.
+ * Creates and deletes a real ref under refs/tickmarkr/preflight/ through git itself, leaving
+ * nothing behind on success.
+ */
+export declare function probeRefsWritable(cwd?: string): Promise<RefsProbeResult>;
+export declare const probeRefs: typeof probeRefsWritable;
+export declare const refsProbe: typeof probeRefsWritable;
+export declare function assertRefsWritable(cwd?: string, action?: "run" | "resume"): Promise<RefsProbeResult>;

package/dist/run/git.js

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from "node:async_hooks";
 import { spawn } from "node:child_process";
-import { existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readlinkSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, mkdtempSync, readdirSync, readFileSync, readlinkSync, realpathSync, rmSync, symlinkSync, writeFileSync } from "node:fs";
 import { availableParallelism, tmpdir } from "node:os";
 import { join, resolve } from "node:path";
 import { StringDecoder } from "node:string_decoder";
@@ -565,3 +565,70 @@ export async function removeWorktree(repo, dir) {
     await shGit(`rm -rf ${shq(dir)}`, repo);
     await shGit("git worktree prune", repo);
 }
+export const REFS_PREFLIGHT_PREFIX = "refs/tickmarkr/preflight";
+export const REFS_PROBE_REMEDY = "run from the main repository or a full clone; a sandbox that denies writes under that path cannot host a run";
+export function refsRefusalMessage(action, path, error) {
+    return `refusing to ${action}: repository refs directory ${path} is not writable (${error}). `
+        + `Remedy: ${REFS_PROBE_REMEDY}.`;
+}
+/**
+ * OBS-983/984: prove the repository's common git directory accepts a ref write before starting
+ * the daemon. In a linked worktree, git resolves refs to the main repository's git directory.
+ * Creates and deletes a real ref under refs/tickmarkr/preflight/ through git itself, leaving
+ * nothing behind on success.
+ */
+export async function probeRefsWritable(cwd = process.cwd()) {
+    const refsPathRes = await shGit("git rev-parse --git-path refs", cwd);
+    if (refsPathRes.code !== 0) {
+        const error = (refsPathRes.stderr || refsPathRes.stdout).trim() || "git rev-parse --git-path refs failed";
+        return { ok: false, path: "", refsDir: "", error };
+    }
+    const raw = refsPathRes.stdout.trim();
+    let refsDir = resolve(cwd, raw);
+    try {
+        refsDir = realpathSync(refsDir);
+    }
+    catch {
+        // keep resolved path if realpath fails
+    }
+    const headRes = await shGit("git rev-parse HEAD", cwd);
+    const target = headRes.code === 0 && headRes.stdout.trim()
+        ? headRes.stdout.trim()
+        : "4b825dc642cb6eb9a060e54bf8d69288fbee4904";
+    const probeId = `probe-${process.pid}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+    const ref = `${REFS_PREFLIGHT_PREFIX}/${probeId}`;
+    const createRes = await shGit(`git update-ref ${shq(ref)} ${shq(target)}`, cwd);
+    if (createRes.code !== 0) {
+        const error = (createRes.stderr || createRes.stdout).trim() || `git update-ref failed (${createRes.code})`;
+        return { ok: false, path: refsDir, refsDir, error };
+    }
+    const delRes = await shGit(`git update-ref -d ${shq(ref)}`, cwd);
+    if (delRes.code !== 0) {
+        const error = (delRes.stderr || delRes.stdout).trim() || `git update-ref -d failed (${delRes.code})`;
+        return { ok: false, path: refsDir, refsDir, error };
+    }
+    // Clean up empty directories left behind by git
+    try {
+        const preflightDir = join(refsDir, "tickmarkr", "preflight");
+        if (existsSync(preflightDir) && readdirSync(preflightDir).length === 0) {
+            rmSync(preflightDir, { recursive: true, force: true });
+        }
+        const tmDir = join(refsDir, "tickmarkr");
+        if (existsSync(tmDir) && readdirSync(tmDir).length === 0) {
+            rmSync(tmDir, { recursive: true, force: true });
+        }
+    }
+    catch {
+        // best-effort cleanup of empty dirs
+    }
+    return { ok: true, path: refsDir, refsDir };
+}
+export const probeRefs = probeRefsWritable;
+export const refsProbe = probeRefsWritable;
+export async function assertRefsWritable(cwd = process.cwd(), action = "run") {
+    const probe = await probeRefsWritable(cwd);
+    if (!probe.ok) {
+        throw new Error(refsRefusalMessage(action, probe.path, probe.error));
+    }
+    return probe;
+}

package/dist/run/journal.js

@@ -949,18 +949,27 @@ export function gateResultJournalData(gate, pass, details, meta = {}) {
     const signalBasis = deriveSignalBasis(gate, pass, details, meta);
     return { gate, pass, details, ...meta, signalBasis, signalQuality: signalQualityFromBasis(signalBasis) };
 }
-// T3 (Sol #2 / Fable F2): one canonical engagement identity, shared by status AND resume. The run-start
-// event records graphDefinitionHash (over compiled task definitions only — see graph.graphDefinitionHash);
-// this is the single field both consumers read, and the single comparator below is the single place the
-// journal↔graph join is decided. unbound (no recorded definition hash, e.g. a pre-v1.44 journal) and
+// T3 (Sol #2 / Fable F2) + OBS-978: one canonical engagement identity, shared by status, plan, the operator
+// fold AND resume. The run-start event records graphDefinitionHash (over compiled task definitions only — see
+// graph.graphDefinitionHash); each audited graph-rehash row (resume --graph-changed) then moves the identity to
+// its `to`, so the recorded hash is the last audited rehash, else run-start. A row is audited when its `from`
+// names the identity it replaced, or the run-start one (all pre-OBS-978 daemons wrote); a row auditing neither
+// binds nothing — the journal is unbound until a release from null. unbound (also a pre-v1.44 journal) and
 // mismatch are both not-comparable — status renders the notice either way; resume refuses either way and
 // distinguishes the reason only for its message and the --graph-changed release event.
 export function recordedGraphDefinitionHash(events) {
+    const start = events.find((e) => e.event === "run-start");
+    if (!start)
+        return undefined;
+    const origin = typeof start.data.graphDefinitionHash === "string" ? start.data.graphDefinitionHash : null;
+    let recorded = origin;
     for (const e of events) {
-        if (e.event === "run-start" && typeof e.data.graphDefinitionHash === "string")
-            return e.data.graphDefinitionHash;
+        if (e.event !== "graph-rehash")
+            continue;
+        const audited = e.data.from === recorded || e.data.from === origin;
+        recorded = audited && typeof e.data.to === "string" ? e.data.to : null;
     }
-    return undefined;
+    return recorded ?? undefined;
 }
 // THE shared comparator (criterion: status and resume decide through one comparator). status reads
 // .comparable; resume reads .comparable plus .reason/.recorded for its refusal message and the release.

package/dist/run/operator-state.d.ts

@@ -57,7 +57,7 @@ export declare class OperatorStateFold {
     private tasks;
     private start?;
     private startEvent?;
-    private latestGraphRehash?;
+    private rehashes;
     private end?;
     private active;
     private approved;

package/dist/run/operator-state.js

@@ -10,7 +10,7 @@ export class OperatorStateFold {
     tasks = new Map();
     start;
     startEvent;
-    latestGraphRehash;
+    rehashes = [];
     end;
     active = false;
     approved = false;
@@ -34,7 +34,7 @@ export class OperatorStateFold {
             this.tipFailed = false;
         }
         if (e.event === "graph-rehash")
-            this.latestGraphRehash = { ...e, data: { from: e.data.from, to: e.data.to } };
+            this.rehashes = [...this.rehashes, { ...e, data: { from: e.data.from, to: e.data.to } }];
         if (e.event === "tip-verify-failed" || (e.event === "tip-verify" && e.data.pass === false))
             this.tipFailed = true;
         if (e.event === "run-end") {
@@ -146,13 +146,9 @@ export class OperatorStateFold {
     comparableTo(hash) {
         if (!hash)
             return false;
-        const events = [this.startEvent, this.latestGraphRehash].filter((e) => e !== undefined);
-        const baseline = engagementComparable(events, hash);
-        if (this.latestGraphRehash) {
-            const from = baseline.comparable ? baseline.recorded : baseline.reason === "mismatch" ? baseline.recorded : null;
-            return this.latestGraphRehash.data.to === hash && this.latestGraphRehash.data.from === from;
-        }
-        return baseline.comparable;
+        // The shared comparator audits the rehash chain; the fold keeps only the rows it reads.
+        const events = [this.startEvent, ...this.rehashes].filter((e) => e !== undefined);
+        return engagementComparable(events, hash).comparable;
     }
 }
 /** C1/C6 share this pure reader; callers supply the same observation and journal snapshot. */

package/dist/tui/cockpit/live-runtime.js

@@ -467,18 +467,20 @@ export async function runConsolidatedCockpit(options) {
         const reader = createPointerReportReader();
         const stdin = new Proxy(input, { get(target, property) {
                 if (property === "read")
-                    return (...args) => {
+                    return () => {
                         try {
-                            const chunk = target.read(...args);
-                            if (chunk == null)
-                                return null;
-                            const result = reader(String(chunk));
                             let keys = "";
-                            for (const token of result.tokens) {
-                                if (token.type === "pointer")
-                                    pointer(token.report);
-                                else
-                                    keys += token.bytes;
+                            // OBS-965: drain until the stream itself says empty. A real tty (highWaterMark 0) stops its
+                            // handle after every chunk and only a read() that finds the buffer EMPTY restarts it; Ink's
+                            // loop stops at the first null, so returning null after ONE pointer-only chunk left that
+                            // empty read unmade and every later key queued in the kernel — the deaf board.
+                            for (let chunk = target.read(); chunk != null; chunk = target.read()) {
+                                for (const token of reader(String(chunk)).tokens) {
+                                    if (token.type === "pointer")
+                                        pointer(token.report);
+                                    else
+                                        keys += token.bytes;
+                                }
                             }
                             // A standalone Escape is unambiguous after Ink's own input grace.
                             if (reader.pending() === "\x1b")

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tickmarkr",
-  "version": "2.5.2",
+  "version": "2.5.4",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",

package/skills/tickmarkr-auto/SKILL.md

@@ -92,7 +92,7 @@ After sending, **confirm delivery** by reading the target pane and verifying the
 1. **Prepare** — confirm the target list. Run the [binary preflight](#binary-preflight-before-compile-or-run). Check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
 2. **Compile** — run `tickmarkr compile <spec-or-directory>`. Fix source-spec defects instead of editing the generated graph.
 3. **Plan** — run `tickmarkr plan`. Review routes, capability-floor warnings, and human gates before execution.
-4. **Run** — run `tickmarkr run`. Watch the run journal for its terminal events rather than polling agents, using the shipped watcher — `.claude/skills/tickmarkr-overseer/scripts/watch-journal.sh <state-dir>/runs 20 28800` — which takes a line baseline at arm time, then wakes ONCE on `run-end`, `task-human`, `task-failed` or `consult-verdict` and grades the run-end summary against every green clause for you. Re-arm after every wake. ⛔ Never `tail -F | grep -m1` (run-end is the journal's last line, so tail never notices the broken pipe and the watcher hangs forever) and never a pane-level done wait (it fires on every agent turn end, not mission end). ⚠ A bare whole-file `grep -q '"event":"run-end"'` is the trap the watcher exists to avoid: on a resume it matches the PREVIOUS run's run-end and returns instantly, so a re-armed watcher reads as coverage that does not exist. Resolve blocked interactions in the relevant agent session.
+4. **Run** — run `tickmarkr run`. A watch ending the seat's turn is no watch: keep a **blocking journal consumer** alive for the run's terminal events — the shipped watcher below, or a foreground `until grep` on the run's terminal events — and ensure it is re-armed at most every twenty minutes. Never rely on a `Monitor`-only wake. Watch the run journal rather than polling agents, using the shipped watcher — `.claude/skills/tickmarkr-overseer/scripts/watch-journal.sh <state-dir>/runs 20 28800` — which takes a line baseline at arm time, then wakes ONCE on `run-end`, `task-human`, `task-failed` or `consult-verdict` and grades the run-end summary against every green clause for you. Re-arm after every wake. ⛔ Never `tail -F | grep -m1` (run-end is the journal's last line, so tail never notices the broken pipe and the watcher hangs forever) and never a pane-level done wait (it fires on every agent turn end, not mission end). ⚠ A bare whole-file `grep -q '"event":"run-end"'` is the trap the watcher exists to avoid: on a resume it matches the PREVIOUS run's run-end and returns instantly, so a re-armed watcher reads as coverage that does not exist. Resolve blocked interactions in the relevant agent session.
 5. **Verify and consolidate** — continue only after a green run. A run is green when the run-end event exists in the journal, the tip verify is not "failed", and the summary's `failed`, `human`, `blocked` and `pending` buckets are all empty — a run with a parked task is partial, not green. Tickmarkr consolidates accepted work on `tickmarkr/<runId>` and never signs off to the main branch. A human controls any later release merge.
 6. **Record** — `tickmarkr report <runId> --md` prints Markdown to stdout; redirect explicitly beside the spec (for example `tickmarkr report <runId> --md > feature.record.md`) and commit the execution record when the repository tracks those records.
 7. **Continue** — move to the next requested target. If a target fails or is parked, stop with the journal evidence rather than silently skipping it.

package/skills/tickmarkr-loop/SKILL.md

@@ -88,7 +88,7 @@ When spawning consultants (agents gathering synthesis input for decisions like S
 1. **Prepare** — start from the requested spec. Run the [binary preflight](#binary-preflight-before-compile-or-run). Check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
 2. **Compile** — run `tickmarkr compile <spec>`. Correct compilation errors in the spec, never in the generated graph.
 3. **Plan** — run `tickmarkr plan`. Review the routing table, capability-floor warnings, and every human gate, including work that each gate blocks.
-4. **Run** — run `tickmarkr run`. Watch the run journal for its terminal events rather than polling agents, using the shipped watcher — `.claude/skills/tickmarkr-overseer/scripts/watch-journal.sh <state-dir>/runs 20 28800` — which takes a line baseline at arm time, then wakes ONCE on `run-end`, `task-human`, `task-failed` or `consult-verdict` and grades the run-end summary against every green clause for you. Re-arm after every wake. ⛔ Never `tail -F | grep -m1` (run-end is the journal's last line, so tail never notices the broken pipe and the watcher hangs forever) and never a pane-level done wait (it fires on every agent turn end, not mission end). ⚠ A bare whole-file `grep -q '"event":"run-end"'` is the trap the watcher exists to avoid: on a resume it matches the PREVIOUS run's run-end and returns instantly, so a re-armed watcher reads as coverage that does not exist. Resolve blocked interactions in the agent session; do not turn them into proxy questions.
+4. **Run** — run `tickmarkr run`. A watch ending the seat's turn is no watch: keep a **blocking journal consumer** alive for the run's terminal events — the shipped watcher below, or a foreground `until grep` on the run's terminal events — and ensure it is re-armed at most every twenty minutes. Never rely on a `Monitor`-only wake. Watch the run journal rather than polling agents, using the shipped watcher — `.claude/skills/tickmarkr-overseer/scripts/watch-journal.sh <state-dir>/runs 20 28800` — which takes a line baseline at arm time, then wakes ONCE on `run-end`, `task-human`, `task-failed` or `consult-verdict` and grades the run-end summary against every green clause for you. Re-arm after every wake. ⛔ Never `tail -F | grep -m1` (run-end is the journal's last line, so tail never notices the broken pipe and the watcher hangs forever) and never a pane-level done wait (it fires on every agent turn end, not mission end). ⚠ A bare whole-file `grep -q '"event":"run-end"'` is the trap the watcher exists to avoid: on a resume it matches the PREVIOUS run's run-end and returns instantly, so a re-armed watcher reads as coverage that does not exist. Resolve blocked interactions in the agent session; do not turn them into proxy questions.
 5. **Verify and consolidate** — accept only a green run. A run is green when the run-end event exists in the journal, the tip verify is not "failed", and the summary's `failed`, `human`, `blocked` and `pending` buckets are all empty — a run with a parked task is partial, not green. Tickmarkr consolidates accepted task work on `tickmarkr/<runId>`; it never signs off to the main branch. A human may later merge that integration branch through the repository's normal release process.
 6. **Record** — `tickmarkr report <runId> --md` prints Markdown to stdout. Redirect it explicitly beside the source spec (for example `tickmarkr report <runId> --md > feature.record.md`) and commit the execution record when the repository tracks those records. Then [stand down](#stand-down-mission-end-and-retirement).
 

package/skills/tickmarkr-overseer/SKILL.md

@@ -149,6 +149,35 @@ through brief lineage. **An executor choice nobody made is still an executor cho
    guidance belongs in the memory file or the shipped docs.
 4. Arm the watcher and your own supervision beat (Supervision). Report the hierarchy map (pane ids + names) to the user.
 
+### Restart, seat identity, and verified launch law
+
+These rules apply after **ANY restart**, whether the overseer itself or Herdr restarted. First re-read the
+overseer's own pane id from Herdr; never continue with an id remembered before the restart. Then re-announce
+that fresh pane id to **every live seat** and re-arm **every watcher** with it, verifying each announcement and
+arm by reading back the resulting pane/process state. A live seat must never keep a pre-restart overseer pane id.
+When briefing a seat, take the overseer's address from the handoff file; never hardcode a pane id in a
+brief or command template.
+
+The orchestrator's run log, handoff, and plan live inside its sandbox root and are artifacts of that orchestrator.
+The overseer reads them from there, using the path the orchestrator reports; do not substitute the
+overseer's repository or a machine-global planning directory. The orchestrator brief must say: if the seat's
+sandbox denies writes under `.git`, report the denial to the overseer and stop; the overseer launches the daemon itself;
+and the daemon host is never sandboxed.
+
+After every `agent start`, wait for and read the model banner. Only then deliver the brief with `pane run`,
+then read the transcript back and verify that the brief's first words are present before any deadline is armed.
+That read-back proves the brief was sent; a brief absent from the transcript was not sent. Every Claude
+seat is started with `--effort high` and has its banner read. Inventories retain the **full suite log**, not a
+tail or summary, and no one runs `git checkout` in a clone while that clone's suite is running.
+
+### Seat-spawn and Leg-2 recipes
+
+Every mission to a Claude or Grok seat is delivered only with `herdr pane run <pane> "<message>"` and
+verified by reading the pane back; never use `agent prompt` for mission delivery. Launch a Grok seat with
+`herdr agent start <seat> --kind grok --pane <pane> -- -m grok-4.6`. For Leg-2, a Codex reviewer under
+`workspace-write` must be briefed with an in-worktree verdict path such as
+`<repo>/.tickmarkr/overseer/verdicts/<task>.md`, and its verdict must be written there before it is read.
+
 ## Supervising tickmarkr as the executor — WHO DOES WHAT
 
 When the mission runs `/tickmarkr-auto` (tickmarkr dispatches the workers), supervision changes shape —
@@ -204,6 +233,9 @@ journal tail to decide what happens next, or sweeping orphans — you have taken
 - **The journal is the source of truth**, not panes. Watchers go on `run-end` / `task-human` /
   `task-failed` / `consult-verdict`; never sleep-poll inside an agent turn. **Never key a watcher on an
   agent's `done`** — that is turn end and fires the moment a seat finishes acknowledging you.
+  A watch ending the seat's turn is no watch: keep a **blocking journal consumer** alive for those terminal
+  events — the shipped watcher below, or a foreground `until grep` on the run's terminal events — and
+  ensure it is re-armed at most every twenty minutes. Never rely on a `Monitor`-only wake.
   **All four are covered by one shipped instrument** — `scripts/watch-journal.sh <runs-dir> [poll] [cap]
   [events-csv]` — which arms on a line baseline, wakes once, and grades a `run-end` against every green
   clause. `scripts/watch-parks.sh` stays the park-specific wake for THIS seat (it counts parks and speaks
@@ -476,6 +508,52 @@ number — an unmeasured budget is not a small budget.
 .claude/skills/tickmarkr-overseer/scripts/watch-context.sh overseer <overseer-agent-or-pane> 50 50 <handoff-file>
 ```
 
+### A GO has a deadline — arm `watch-launch.sh` in the same act as the GO
+
+A GO that produces no run is a silent failure until someone notices; on 2026-09-11 an orchestrator's codex
+sandbox was rooted at the main repo, the spec worktree was outside its writable roots, it stopped at the
+denial without reporting, the overseer's 10-minute wake expired un-re-armed, and three hours passed.
+Two rules close that hole:
+
+- **Every orchestrator seat is sandbox-rooted at the worktree it will run in** (`cd <worktree>` before
+  `herdr agent start … --sandbox workspace-write`), and its brief says: *a denied path or refused command
+  is reported to the overseer pane within 60 s — never a silent stop.*
+- **The overseer arms the launch watcher in the SAME act as the GO**, with the lock path the run will
+  create, and treats `LAUNCH_OVERDUE` as a first-class event (read the orchestrator pane, fix the seat,
+  re-issue the GO):
+
+```bash
+.claude/skills/tickmarkr-overseer/scripts/watch-launch.sh <worktree>/.tickmarkr/graph.lock 900 <overseer-pane> &
+```
+
+It prints `LAUNCH_OK` with the lock's contents when the run starts (exit 0) and, past the deadline, delivers
+`LAUNCH OVERDUE …` to the overseer pane AND as an OS notification (exit 3). Any wake you arm yourself with
+a cap (a background `until` loop) must be RE-ARMED on every expiry; an expired wake is not a watch.
+
+
+### A GO has a deadline — arm `watch-launch.sh` in the same act as the GO
+
+A GO that produces no run is a silent failure until someone notices; on 2026-09-11 an orchestrator's codex
+sandbox was rooted at the main repo, the spec worktree was outside its writable roots, it stopped at the
+denial without reporting, the overseer's 10-minute wake expired un-re-armed, and three hours passed.
+Two rules close that hole:
+
+- **Every orchestrator seat is sandbox-rooted at the worktree it will run in** (`cd <worktree>` before
+  `herdr agent start … --sandbox workspace-write`), and its brief says: *a denied path or refused command
+  is reported to the overseer pane within 60 s — never a silent stop.*
+- **The overseer arms the launch watcher in the SAME act as the GO**, with the lock path the run will
+  create, and treats `LAUNCH_OVERDUE` as a first-class event (read the orchestrator pane, fix the seat,
+  re-issue the GO):
+
+```bash
+.claude/skills/tickmarkr-overseer/scripts/watch-launch.sh <worktree>/.tickmarkr/graph.lock 900 <overseer-pane> &
+```
+
+It prints `LAUNCH_OK` with the lock's contents when the run starts (exit 0) and, past the deadline, delivers
+`LAUNCH OVERDUE …` to the overseer pane AND as an OS notification (exit 3). Any wake you arm yourself with
+a cap (a background `until` loop) must be RE-ARMED on every expiry; an expired wake is not a watch.
+
+
 The first argument chooses the closed per-seat tier (`orchestrator-context` or `overseer-context`),
 and every beat names the second argument as that tier's seat. The watcher beats only after reading a
 rendered percentage, keeps beating on the supervision cadence even when its requested poll is slower,
@@ -580,9 +658,9 @@ they are left implicit:
   Send only when the seat is idle and the ANSI prompt line is empty or dim-only (the Esc/SGR discriminator
   separates an autosuggest ghost from typed input), then read back activity or an ACK; presence is not
   delivery. If a stale draft must be replaced, supersede it explicitly with
-  `agent prompt " <-- disregard … ACTUAL: …"` instead of stacking another instruction behind it.
+  `herdr pane run <pane> "<-- disregard … ACTUAL: …"` instead of stacking another instruction behind it.
 - **A MESSAGE TO A WORKING SEAT IS A QUEUED MESSAGE, AND THE QUEUE DRAINS ONLY AT TURN BOUNDARIES.**
-  Delivery is not arrival: `agent prompt` to a `working` claude seat lands in its queue (`Press up to
+  Delivery is not arrival: a message sent to a `working` claude seat lands in its queue (`Press up to
   edit queued messages` on the seat's prompt line is the tell) and is READ only when the current turn
   ends — and with in-process teammates a turn runs 20–40 minutes, so steering latency equals subagent
   runtime. Measured 2026-08-17/18 (P98 leg 1): a FREEZE HOLD and a checker-release directive stacked
@@ -622,7 +700,7 @@ they are left implicit:
 - **AGENT NAMES ARE GLOBAL ACROSS WORKSPACES — verify a seat you spawned by PANE ID, never by name.**
   Names must be unique among live agents *everywhere*, not within your workspace, so another workspace can
   already hold `opus`, `sol`, `reviewer` or `orch`. When it does, your `agent start` **fails**, your pane
-  is left a bare shell, and `agent list` / `agent read` / `agent prompt` for that name then resolve to the
+  is left a bare shell, and `agent list` / `agent read` for that name then resolve to the
   **stranger's seat**. Measured 2026-08-06 (OBS-392): a spawn of `fable` collided with a live seat in
   another workspace; `agent list` reported `fable -> blocked` and it was read as *this* seat coming up
   blocked. It was an operator research session sitting on a *"Resume full session?"* prompt. One more
@@ -644,7 +722,7 @@ they are left implicit:
   Re-arm name-keyed watchers in the same act as the rename; file-keyed artifact watchers are
   unaffected (one more reason to prefer them).
 - Stale typed input is unclearable via CLI — supersede it:
-  `pane run "<-- disregard everything before this arrow (stale draft). ACTUAL: <message>"`.
+  `herdr pane run <pane> "<-- disregard everything before this arrow (stale draft). ACTUAL: <message>"`.
   **But DISCRIMINATE before you supersede or file it: text on an idle seat's prompt line has FOUR
   authors** — the seat's own draft, an operator, another agent's `agent send` (writes WITHOUT Enter),
   and claude-code's AUTOSUGGEST, which renders context-plausible ghost text BYTE-IDENTICAL to a typed

package/skills/tickmarkr-overseer/scripts/watch-launch.sh

@@ -0,0 +1,38 @@
+#!/usr/bin/env bash
+# watch-launch.sh — a GO that produced no run is a silent failure until someone notices. This watcher
+# notices. Arm it in the SAME act as the GO (orchestrator briefed to compile → plan → run) and it waits
+# for the run's lock; when the lock has not appeared by the deadline it delivers LAUNCH OVERDUE to the
+# overseer's pane AND as an OS notification, so the wake reaches a seat instead of a log nobody reads.
+#
+# Why it exists (2026-09-11): an orchestrator's codex sandbox was rooted at the main repo, the spec
+# worktree was outside its writable roots, it stopped at the denial without reporting, and the overseer's
+# own 10-minute wake expired un-re-armed. Three hours passed before anyone looked. A launch has a
+# deadline; silence past it is the event.
+#
+# usage: watch-launch.sh <lock-path> <deadline-s> <overseer-pane> [poll-s]
+#   <lock-path>      the run's .tickmarkr/graph.lock in the worktree the run will be launched in
+#   <deadline-s>     seconds from now by which the lock must exist (a compile+plan+launch takes minutes,
+#                    never hours; 900 is a generous default for a 7-task spec)
+#   <overseer-pane>  the pane that must hear about it (herdr pane id), e.g. wZ:p18S
+#   [poll-s]         poll interval, default 15
+# exit 0 LAUNCH_OK (lock seen; prints its contents) · exit 3 LAUNCH_OVERDUE (delivered) · exit 64 usage
+set -u
+LOCK="${1:-}"; DEADLINE="${2:-}"; PANE="${3:-}"; POLL="${4:-15}"
+[ -n "$LOCK" ] && [ -n "$DEADLINE" ] && [ -n "$PANE" ] || { echo "usage: watch-launch.sh <lock-path> <deadline-s> <overseer-pane> [poll-s]" >&2; exit 64; }
+start=$(date +%s)
+while :; do
+  if [ -f "$LOCK" ]; then
+    printf 'LAUNCH_OK %s %s\n' "$(date -u +%H:%M:%SZ)" "$(cat "$LOCK" 2>/dev/null | tr -d '\n')"
+    exit 0
+  fi
+  now=$(date +%s)
+  if [ $((now - start)) -ge "$DEADLINE" ]; then
+    msg="LAUNCH OVERDUE $(date -u +%H:%M:%SZ): no lock at $LOCK after ${DEADLINE}s — read the orchestrator pane NOW (sandbox denial? preflight refusal? unsubmitted GO?)"
+    echo "LAUNCH_OVERDUE $msg"
+    # Both deliveries, always: a pane the overseer reads AND a notification the operator sees.
+    herdr pane run "$PANE" "$msg" >/dev/null 2>&1 || echo "  (pane delivery failed — the notification is the only path)"
+    herdr notification show "$msg" >/dev/null 2>&1 || true
+    exit 3
+  fi
+  sleep "$POLL"
+done