tickmarkr 1.74.0 → 1.76.0

package/dist/adapters/claude-code.d.ts

@@ -1,4 +1,5 @@
-import { type AuthHealth, type WorkerAdapter } from "./types.js";
+import { type AuthHealth, type TrustDialog, type WorkerAdapter } from "./types.js";
+export declare const CLAUDE_TRUST_DIALOG: TrustDialog;
 export declare function claudeSlug(real: string): string;
 export declare function probeVersion(bin: string): AuthHealth;
 export declare const claudeCode: WorkerAdapter;

package/dist/adapters/claude-code.js

@@ -20,6 +20,12 @@ import { channelsFromConfig, shq, TokenUsageSchema } from "./types.js";
 // Phase 18's operator-price × tokens derivation, not a CLI claim.
 const MAX_SESSION_FILES = 20; // newest-first; a long-lived project dir can hold many sessions
 const MAX_SESSION_BYTES = 8_000_000; // per-file cap; a runaway JSONL cannot make the read unbounded
+// v1.75 T2 / OBS-137: current Claude Code workspace-trust prompt (2.1.218). The full question
+// distinguishes this startup gate from routine agent text; Enter accepts the selected trust option.
+export const CLAUDE_TRUST_DIALOG = {
+    fingerprint: "Quick safety check: Is this a project you created or one you trust?",
+    key: "Enter",
+};
 export function claudeSlug(real) {
     return real.replace(/[^A-Za-z0-9]/g, "-");
 }
@@ -54,13 +60,11 @@ export const claudeCode = {
     // and --mcp-config is VARIADIC — a positional after it is eaten as a config-file path, so another
     // flag must always follow the value, never the prompt.
     headlessCommand: (promptFile, model) => `claude -p "$(cat ${shq(promptFile)})" --model ${shq(model)} --permission-mode bypassPermissions --strict-mcp-config --mcp-config '{"mcpServers":{}}' --output-format text`,
-    // HYG-03: the residual first-entry dialog on an interactive TUI is the workspace TRUST dialog (not MCP
-    // config loading) — CLI-imposed, no flag to pre-accept, only store is claude's global last-writer-wins
-    // ~/.claude.json keyed on the exact path. Closed WON'T-FIX (decision B, 2026-07-10): tickmarkr writes nothing
-    // to that file (a seed races claude's own writes, nondeterministically). Amortizes to one operator dismissal
-    // per stable worktree path; blocked-pane paging surfaces it. Do NOT change this command to "fix" the dialog —
-    // see .planning/REQUIREMENTS.md HYG-03 and 21-02-LIVE-CHECK.md. Revisit if upstream ships a --trust flag.
+    // HYG-03 / OBS-137: the residual first-entry dialog is workspace trust, not MCP config loading.
+    // Claude's only store is global last-writer-wins ~/.claude.json, so tickmarkr still does not seed it;
+    // the daemon safely answers only the exact adapter-declared dialog once per slot.
     interactiveCommand: (promptFile, model) => `claude --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
+    trustDialog: CLAUDE_TRUST_DIALOG,
     resumeCommand: (sessionId, promptFile, model) => `claude -r ${shq(sessionId)} --model ${shq(model)} --strict-mcp-config --mcp-config '{"mcpServers":{}}' --permission-mode bypassPermissions "$(cat ${shq(promptFile)})"`,
     invoke(task, _cwd, a, ctx) {
         return { command: this.headlessCommand(ctx.promptFile, a.model) };

package/dist/adapters/codex.d.ts

@@ -1,8 +1,9 @@
-import { type TrustVerdict, type WorkerAdapter } from "./types.js";
+import { type TrustDialog, type TrustVerdict, type WorkerAdapter } from "./types.js";
 export declare function readCodexModelsCache(path?: string): {
     models: string[];
     fetchedAt?: string;
 };
+export declare const CODEX_TRUST_DIALOG: TrustDialog;
 export declare function seedCodexTrust(repoRoot: string, configPath?: string): TrustVerdict;
 export declare function hasCodexTrustedProject(text: string, root: string): boolean;
 export declare function codexConfigMcpServerNames(configPath?: string): string[];

package/dist/adapters/codex.js

@@ -89,6 +89,12 @@ const GITDIR_WRITABLE = `-c "sandbox_workspace_write.writable_roots=[\\"$(git re
 // -s/--sandbox workspace-write sandbox (deliberately NOT --dangerously-bypass-approvals-and-sandbox,
 // which would drop the sandbox). Listed by `codex --help` and `codex exec --help` (verified 2026-07-23).
 const CODEX_HOOK_TRUST = "--dangerously-bypass-hook-trust";
+// v1.75 T2 / OBS-137: current Codex workspace-trust prompt (0.144.6). The exact heading
+// is distinct from normal agent output; Enter accepts the selected "Yes, continue" option.
+export const CODEX_TRUST_DIALOG = {
+    fingerprint: "Do you trust the contents of this directory?",
+    key: "Enter",
+};
 // v1.22 T5 / OBS-16: codex keys trust on absolute path under [projects."<root>"] trust_level="trusted"
 // in ~/.codex/config.toml (CODEX_HOME relocates the dir). Worktrees inherit parent-project trust when
 // the REPO ROOT is trusted — seed the root once, cover every future worktree. Idempotent: a second
@@ -196,6 +202,7 @@ export const codex = {
     // v1.22 T5: seed [projects."<repoRoot>"] trust_level="trusted" so fresh worktrees never stall on
     // "Do you trust this directory?" (OBS-16). doctor-only side effect.
     trust: (repoRoot) => seedCodexTrust(repoRoot),
+    trustDialog: CODEX_TRUST_DIALOG,
     // v1.5 MODEL-01: file read only (no `codex models` subcommand exists, verified 2026-07-10).
     // Already fails OPEN to [] internally — advisory detection, unlike gates' fail-closed.
     listModels: async () => readCodexModelsCache().models,

package/dist/adapters/kimi.d.ts

@@ -3,6 +3,11 @@ import { type Assignment, type WorkerAdapter, type WorkerResult } from "./types.
 export declare function kimiAuthed(credentialsText: string, nowMs: number): boolean;
 export declare function parseKimiModels(raw: string): string[];
 export declare function parseKimiResult(raw: string, nonce: string): WorkerResult;
+export interface KimiDoctorTurnResult {
+    ok: boolean;
+    evidence: string;
+}
+export declare function probeKimiDoctorTurn(cwd: string): Promise<KimiDoctorTurnResult>;
 export declare function kimiSessionId(output: string): string | undefined;
 export declare function kimiBannerModel(banner: string): string | undefined;
 export declare function kimiBannerSessionId(banner: string): string | undefined;
@@ -20,6 +25,7 @@ export interface KimiInteractiveSeedResult {
     seedError?: string;
     sessionId?: string;
 }
+export declare const KIMI_INPUT_BOX: import("./types.js").InputBox;
 export declare function runKimiInteractiveSeed(opts: {
     driver: Pick<ExecutorDriver, "run" | "waitOutput" | "read">;
     slot: Slot;

package/dist/adapters/kimi.js

@@ -5,7 +5,7 @@ import { probeVersion } from "./claude-code.js";
 import { parseWorkerResult } from "./prompt.js";
 import { runInteractiveSeed } from "../run/interactive-seed.js";
 import { sh } from "../run/git.js";
-import { channelsFromConfig, MODEL_ID_RE, shq, TokenUsageSchema } from "./types.js";
+import { channelsFromConfig, declareInputBox, MODEL_ID_RE, shq, TokenUsageSchema } from "./types.js";
 // KIMI-03 → v1.58 T5: the "no harness-readable counter" block (research F-6, 2026-07-17) is
 // LIFTED for collectUsage — kimi 0.27.0 writes a wire journal per agent at
 // ~/.kimi-code/sessions/<wd>/session_<uuid>/agents/<agent>/wire.jsonl, and ~/.kimi-code/
@@ -64,6 +64,28 @@ export function parseKimiResult(raw, nonce) {
     const stripped = raw.split("\n").map((l) => l.replace(/^[\s]*[•*-]\s+/, "")).join("\n");
     return parseWorkerResult(stripped, nonce);
 }
+const KIMI_DOCTOR_TURN_MODEL = "kimi-code/k3";
+const KIMI_DOCTOR_TURN_PROMPT = "Reply with exactly OK and nothing else.";
+const KIMI_DOCTOR_TURN_TIMEOUT_MS = 60000;
+// OBS-141: intentionally separate from probe() so plan/run remain free file checks. Only doctor
+// calls this one-turn contract probe; its test seam stubs sh and never launches a real agent CLI.
+export async function probeKimiDoctorTurn(cwd) {
+    const command = `kimi -p ${shq(KIMI_DOCTOR_TURN_PROMPT)} --model ${shq(KIMI_DOCTOR_TURN_MODEL)} --output-format text`;
+    const r = await sh(command, cwd, KIMI_DOCTOR_TURN_TIMEOUT_MS);
+    if (r.timedOut) {
+        return { ok: false, evidence: `turn timed out after ${KIMI_DOCTOR_TURN_TIMEOUT_MS}ms` };
+    }
+    const output = `${r.stderr}\n${r.stdout}`.trim().replace(/\s+/g, " ");
+    if (r.code !== 0) {
+        return { ok: false, evidence: output || `turn exited ${r.code}` };
+    }
+    const returnedOk = r.stdout.split("\n")
+        .map((line) => line.replace(/^[\s]*[•*-]\s+/, "").trim())
+        .includes("OK");
+    return returnedOk
+        ? { ok: true, evidence: `model turn returned OK with ${KIMI_DOCTOR_TURN_MODEL}` }
+        : { ok: false, evidence: `turn returned no exact OK answer${output ? `: ${output}` : ""}` };
+}
 // v1.53 T3: session-id capture from the run-output trailer — every `kimi -p` run (fresh or resumed)
 // ends with `To resume this session: kimi -r session_<uuid>` (live probe 2026-07-18). Anchored full
 // line only: prompt/model prose can contain lookalike text, and the anchored charset keeps a
@@ -89,23 +111,20 @@ export function kimiSessionId(output) {
     }
     return id;
 }
-// v1.69 T6: the native TUI takes -m <alias>, where config.toml aliases are the bare model suffix of
-// the tickmarkr channel id (live probe 2026-07-22). Keep the mapping explicit and localized.
-function kimiAlias(model) {
-    return model.replace(/^kimi-code\//, "");
-}
 // v1.69 T7: the cold-start banner prints the model alias and session id. Parse them from the
-// banner text already captured for the readiness match — no new probe, no extra dispatch.
+// banner text already captured for the readiness match — no new probe, no extra dispatch. Kimi
+// 0.29.0 may print either the full config key or its display suffix; normalize both idempotently
+// to the full channel identifier routing uses.
 const BANNER_MODEL_RE = /^Model:\s*(.+)$/m;
 const BANNER_SESSION_RE = /^Session:\s*(session_[0-9a-f-]+)$/m;
 export function kimiBannerModel(banner) {
     const m = BANNER_MODEL_RE.exec(banner);
     if (!m)
         return undefined;
-    const alias = m[1].trim();
-    if (!alias)
+    const printedModel = m[1].trim();
+    if (!printedModel)
         return undefined;
-    return `kimi-code/${alias}`;
+    return printedModel.startsWith("kimi-code/") ? printedModel : `kimi-code/${printedModel}`;
 }
 export function kimiBannerSessionId(banner) {
     return BANNER_SESSION_RE.exec(banner)?.[1];
@@ -118,10 +137,16 @@ export function confirmKimiSeedBanner(banner, assignedModel) {
     }
     return { ok: true, sessionId: kimiBannerSessionId(banner) };
 }
+// v1.75 T1 / OBS-136: this readiness line is rendered inside Kimi Code's bordered steady-state
+// input box. The adapter owns the fingerprint; the driver only consults declarations generically.
+export const KIMI_INPUT_BOX = declareInputBox("kimi", {
+    fingerprint: "Send /help for help information.",
+});
 // Shared launch-then-seed surface (T6) + banner confirm (T7/T2). One definition so the adapter
 // property and the daemon's generic runInteractiveSeed path cannot drift.
 const KIMI_SEED = {
-    launch: (model) => `kimi -y -m ${shq(kimiAlias(model))}`,
+    // v1.76 T2 / OBS-141: 0.29.0 resolves only the full config.toml model key on the first turn.
+    launch: (model) => `kimi -y -m ${shq(model)}`,
     readinessMatch: "Send /help for help information.",
     seedLine: (promptFile) => `Read ${promptFile} and do exactly what it says.`,
     confirmBanner: confirmKimiSeedBanner,
@@ -165,6 +190,7 @@ export const kimi = {
     // prompt as one user turn. Banner model/session confirmation runs on the daemon's generic
     // runInteractiveSeed path via confirmBanner on KIMI_SEED (not a separate dispatch helper).
     interactiveSeed: KIMI_SEED,
+    inputBox: KIMI_INPUT_BOX,
     // v1.53 T3 resume — live-probed 2026-07-18: `-p` + `-S <id>` compose cleanly (no OBS-67-class
     // flag rejection) and the resumed session carries prior conversation state. `-S <id>` is the
     // deterministic form; `-c` rejected as primary — cwd-keyed, nondeterministic under worktree

package/dist/adapters/types.d.ts

@@ -82,6 +82,12 @@ export interface TrustDialog {
     key: string;
 }
 export declare function matchesTrustDialog(paneText: string, dialog: TrustDialog): boolean;
+export interface InputBox {
+    fingerprint: string;
+}
+export declare function declareInputBox(adapterId: string, inputBox: InputBox): InputBox;
+export declare function declaredInputBoxForWorkerName(workerName: string): InputBox | undefined;
+export declare function matchesInputBox(paneText: string, inputBox: InputBox): boolean;
 export interface WorkerAdapter {
     id: string;
     vendor: string;
@@ -105,6 +111,7 @@ export interface WorkerAdapter {
     contextUsage?(session: SessionRef): ContextUsage | null;
     trust?(repoRoot: string): TrustVerdict;
     trustDialog?: TrustDialog;
+    inputBox?: InputBox;
     hardcodedFlags?: {
         binary: string;
         flags: string[];

package/dist/adapters/types.js

@@ -30,6 +30,18 @@ export function modelAuthed(health, model, allowUnverifiedModels = false) {
 export function matchesTrustDialog(paneText, dialog) {
     return paneText.includes(dialog.fingerprint);
 }
+const inputBoxes = new Map();
+export function declareInputBox(adapterId, inputBox) {
+    inputBoxes.set(adapterId, inputBox);
+    return inputBox;
+}
+export function declaredInputBoxForWorkerName(workerName) {
+    const adapterId = /^.+-worker-(.+)-a\d+-.+$/.exec(workerName)?.[1];
+    return adapterId === undefined ? undefined : inputBoxes.get(adapterId);
+}
+export function matchesInputBox(paneText, inputBox) {
+    return paneText.includes(inputBox.fingerprint);
+}
 export function channelsFromConfig(adapterId, cfg) {
     const e = cfg.tiers[adapterId];
     if (!e)

package/dist/cli/commands/doctor.d.ts

@@ -1,5 +1,7 @@
 import type { WorkerAdapter } from "../../adapters/types.js";
+import { type KimiDoctorTurnResult } from "../../adapters/kimi.js";
 export type DoctorOpts = {
     banner?: boolean;
+    kimiTurnProbe?: (cwd: string) => Promise<KimiDoctorTurnResult>;
 };
 export declare function doctor(_argv: string[], cwd?: string, adapters?: WorkerAdapter[], opts?: DoctorOpts): Promise<string>;

package/dist/cli/commands/doctor.js

@@ -6,6 +6,7 @@ import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
 import { declaredModelWindow, hasWindowsConfig, modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
 import { DEFAULT_CONFIG, loadConfig, overlayPreferShapes } from "../../config/config.js";
 import { HerdrDriver } from "../../drivers/herdr.js";
+import { kimi, probeKimiDoctorTurn } from "../../adapters/kimi.js";
 import { denyPreferCollisionLine, denyPreferCollisions, disallowedBy, excludedChannels, exclusionLine, preferRanks } from "../../route/preference.js";
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 const alignedStatusRow = (verdict, key, value) => `  ${statusRow(verdict, kvRow(key, value).slice(2))}`;
@@ -20,6 +21,26 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     console.error("probing installed agent CLIs — one short LLM call per configured model, may take a minute...");
     const probeProgressTTY = process.stderr.isTTY === true;
     const health = await probeAll(adapters, { cwd });
+    const kimiAdapter = adapters.find((a) => a.id === kimi.id);
+    const kimiTurnEnabled = kimiAdapter !== undefined
+        && (kimiAdapter === kimi || opts.kimiTurnProbe !== undefined);
+    if (kimiTurnEnabled) {
+        const h = health.kimi;
+        if (h.installed && h.authed) {
+            let turn;
+            try {
+                turn = await (opts.kimiTurnProbe ?? probeKimiDoctorTurn)(cwd);
+            }
+            catch (e) {
+                turn = { ok: false, evidence: e instanceof Error ? e.message : String(e) };
+            }
+            health.kimi = {
+                ...h,
+                authed: turn.ok,
+                note: `${h.note ? `${h.note}; ` : ""}${turn.ok ? turn.evidence : `model turn failed: ${turn.evidence}`}`,
+            };
+        }
+    }
     // MODEL-02: detect models where the adapter exposes a list surface, BEFORE writing doctor.json (write once, below).
     // Fail OPEN — the inverse of gates' fail-closed: detection is advisory, so a broken list surface NEVER fails doctor.
     for (const a of adapters) {
@@ -35,14 +56,20 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         }
         catch { /* fail open: leave models as-is, doctor stays healthy */ }
     }
-    await probeModels(cfg, cwd, adapters, health, probeProgressTTY
+    // A free Kimi auth failure or failed earned-green turn must not spend more probes. Every other
+    // adapter keeps the exact existing model-sweep path.
+    const modelProbeAdapters = kimiTurnEnabled && health.kimi.authed === false
+        ? adapters.filter((a) => a !== kimiAdapter)
+        : adapters;
+    await probeModels(cfg, cwd, modelProbeAdapters, health, probeProgressTTY
         ? (adapter, model, status, durationMs) => console.error(`  ${adapter}:${model} ${status} (${(durationMs / 1000).toFixed(1)}s)`)
         : undefined);
     writeDoctor(cwd, health);
     const rows = adapters.map((a) => {
         const h = health[a.id];
         const state = !h.installed ? "not installed" : `${h.version ?? "installed"}${h.note ? ` (${h.note})` : ""}`;
-        return alignedStatusRow(h.installed ? "pass" : "fail", a.id, state);
+        const healthy = h.installed && (a.id !== kimi.id || h.authed);
+        return alignedStatusRow(healthy ? "pass" : "fail", a.id, state);
     });
     // v1.48 T1: advisory sweep for known agent CLIs with no adapter — never written to doctor.json health.
     rows.push(...detectCandidateClis().map(({ binary, version }) => alignedStatusRow("warn", binary, `detected: ${version ?? "version unknown"} (no tickmarkr adapter — not routable)`)));

package/dist/cli/commands/fleet.js

@@ -57,6 +57,14 @@ function withModeLine(yaml, mode) {
         return yaml.replace(/^routing:$/m, `routing:\n  mode: ${mode}`);
     return `routing:\n  mode: ${mode}\n${yaml}`;
 }
+function formatFleetSteering(cfg) {
+    const blocks = [];
+    if (cfg.review.prefer?.length)
+        blocks.push(`review:\n  prefer: ${JSON.stringify(cfg.review.prefer)}`);
+    if (cfg.consult.prefer?.length)
+        blocks.push(`consult:\n  prefer: ${JSON.stringify(cfg.consult.prefer)}`);
+    return blocks.length ? `${blocks.join("\n")}\n` : "";
+}
 // v1.51 T4: one gloss per routing mode on the fleet mode screen — mirrors the preset compiler.
 const MODE_GLOSS = {
     "partner-led": "every shape frontier · explore off",
@@ -83,7 +91,9 @@ export async function fleet(argv, cwd = process.cwd(), adapters = allAdapters(),
         const rm = resolveRunMode(cwd, { globalDir });
         const body = formatFleetPrint(cwd, { globalDir });
         const nl = body.indexOf("\n");
-        return `${body.slice(0, nl)}\n# mode: ${rm.mode.mode} (${rm.source})${body.slice(nl)}`;
+        // Steering comes from the same resolved config snapshot the editor consumes below,
+        // 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)
         return { out: NON_TTY_MSG, code: 1 };

package/dist/drivers/herdr.d.ts

@@ -14,6 +14,7 @@ export declare class HerdrDriver implements ExecutorDriver {
     private deliverySerial;
     private dispatchLeases;
     private deliveredPanes;
+    private inputBoxes;
     private ws;
     private callerPane;
     private watches;
@@ -23,6 +24,7 @@ export declare class HerdrDriver implements ExecutorDriver {
     private reserveDispatch;
     private verifyPaneIdentityBinding;
     private deliveryMatches;
+    private submissionRegistered;
     static available(): boolean;
     private herdr;
     private namedPaneId;
@@ -39,6 +41,7 @@ export declare class HerdrDriver implements ExecutorDriver {
     private joinGroup;
     run(slot: Slot, cmd: string): Promise<void>;
     private deliver;
+    private submitVerifiedDelivery;
     private settleDeliveryLine;
     private deliveryReadMatches;
     private waitOk;

package/dist/drivers/herdr.js

@@ -1,4 +1,4 @@
-import { shq } from "../adapters/types.js";
+import { declaredInputBoxForWorkerName, matchesInputBox, shq } from "../adapters/types.js";
 import { PANE_IDENTITY_ENV, paneIdentityLine } from "../brand.js";
 import { createWorktree, sh } from "../run/git.js";
 import { herdrSealShellPrefix } from "./subprocess.js";
@@ -8,6 +8,7 @@ export const TRAILER_SAFE_FLOOR_COLS = 108;
 export const TRAILER_WIDTH_MARGIN = 2; // cols below (floor + margin) refuse a rightward first split
 // OBS-85 verified delivery: bounded type→read-back→enter attempts before failing closed.
 export const DELIVERY_ATTEMPTS = 3;
+const DELIVERY_SUBMIT_ATTEMPTS = 2; // initial Enter + one evidence-backed re-press (OBS-140)
 const DELIVERY_VERIFY_TIMEOUT_MS = 2000; // per attempt — a paste that hasn't rendered in 2s is retyped
 const DELIVERY_READ_LINES = 80;
 const DELIVERY_SETTLE_READ_ATTEMPTS = 6;
@@ -32,6 +33,7 @@ export class HerdrDriver {
     deliverySerial = Promise.resolve();
     dispatchLeases = new WeakMap();
     deliveredPanes = new WeakMap();
+    inputBoxes = new WeakMap();
     // VIS-10: the run's workspace id, captured once at construction (the daemon inherits it from the
     // operator's env before the driver is built). Required at slot() time, never in the constructor —
     // pickDriver and its unit test construct HerdrDriver without env, so slot() is the trust gate.
@@ -94,6 +96,22 @@ export class HerdrDriver {
         const needle = norm(cmd);
         return needle.length > 0 && hay.includes(needle);
     }
+    // Submission succeeds when the typed prompt disappears, or when it has moved above a fresh
+    // adapter-declared input box (the prompt is now transcript, not input). Shell-line delivery uses
+    // the same normalized seam: a prompt still at the bottom ends the pane text; output/a fresh prompt
+    // after it proves Enter registered. No adapter-specific fingerprint lives in the driver.
+    submissionRegistered(transcript, cmd, inputBox) {
+        const norm = (s) => s.replace(/\s+/g, "");
+        const hay = norm(transcript);
+        const needle = norm(cmd);
+        const promptAt = hay.lastIndexOf(needle);
+        if (needle.length === 0 || promptAt < 0)
+            return true;
+        if (inputBox && matchesInputBox(transcript, inputBox)) {
+            return hay.lastIndexOf(norm(inputBox.fingerprint)) > promptAt;
+        }
+        return promptAt + needle.length < hay.length;
+    }
     static available() {
         return process.env.HERDR_ENV === "1";
     }
@@ -142,6 +160,7 @@ export class HerdrDriver {
         }
     }
     async slot(cwd, name, opts) {
+        const inputBox = declaredInputBoxForWorkerName(name);
         // T1 ownership contract: `opts.owned` (T2 call sites) names the pane canonically —
         // tickmarkr:<role>:<taskId>:<attempt>:<runId>. Without it, `name` passes through byte-identical
         // (today's legacy daemon/gates/consult shapes) — canonicalizeLegacyName (types.ts) is what lets
@@ -154,12 +173,13 @@ export class HerdrDriver {
         // Production dispatch names are canonical even when the gate call site supplies the already-
         // formatted name rather than SlotOpts.owned. Hold one lease across slot() → run(); legacy/manual
         // slots retain their existing allocation-only semantics for compatibility.
-        if (parseOwnedName(resolved))
-            return this.reserveDispatch(allocate);
+        const slot = parseOwnedName(resolved) ? await this.reserveDispatch(allocate) : await allocate();
+        if (inputBox)
+            this.inputBoxes.set(slot, inputBox);
         // group wins if both are set (a group tab is already stage-labeled; passing both is a caller bug).
         // label (without group) → dedicated labeled tab via tabSlot's third param: no groups-map entry, no
         // refcount, no groupSerial, no degrade latch — dedicated tabs have no shared state to guard (SUP-01).
-        return allocate(); // label undefined → defaults to name (today's behavior)
+        return slot; // label undefined → defaults to name (today's behavior)
     }
     // today's per-slot tab path, plus the VIS-04 orphan reap
     // label defaults to the slot name; group tabs pass the STAGE name instead — a first-member label
@@ -397,25 +417,26 @@ export class HerdrDriver {
                 // line only after two consecutive pane reads agree; an already-stable frame returns on the
                 // first fresh read without a timer. A changing pane is bounded and preserves OBS-85's
                 // fail-closed error instead of guessing from an adapter fingerprint.
-                const settled = await this.settleDeliveryLine(pane, slot.cwd, transcript);
+                const settled = await this.settleDeliveryLine(pane, slot.cwd, transcript, this.inputBoxes.get(slot));
                 transcript = settled.transcript;
                 if (!settled.ok) {
                     throw new Error(`herdr delivery clear failed — refusing to retype onto a corrupted line (OBS-85); pane transcript:\n${transcript}`);
                 }
-                // Clear the corrupted input line before retyping; a failed clear must NOT be retyped onto —
-                // corrupt-prefix + clean-retype would concatenate and false-verify by containment.
-                const cleared = await this.herdr(`pane send-keys ${shq(pane)} C-u`, slot.cwd);
-                if (cleared.code !== 0)
-                    throw new Error(`herdr delivery clear failed — refusing to retype onto a corrupted line (OBS-85); pane transcript:\n${transcript}`);
+                if (!settled.recognizedInputBox) {
+                    // Clear the corrupted shell input line before retyping; a failed clear must NOT be retyped
+                    // onto — corrupt-prefix + clean-retype would concatenate and false-verify by containment.
+                    // A stable adapter-declared input box is already an empty legitimate delivery target.
+                    const cleared = await this.herdr(`pane send-keys ${shq(pane)} C-u`, slot.cwd);
+                    if (cleared.code !== 0)
+                        throw new Error(`herdr delivery clear failed — refusing to retype onto a corrupted line (OBS-85); pane transcript:\n${transcript}`);
+                }
             }
             const typed = await this.herdr(`pane send-text ${shq(pane)} ${shq(cmd)}`, slot.cwd);
             if (typed.code !== 0)
                 throw new Error(`herdr pane send-text failed: ${typed.stderr || typed.stdout}`);
             const back = await this.herdr(`pane wait-output ${shq(pane)} --match ${shq(cmd)} --timeout ${DELIVERY_VERIFY_TIMEOUT_MS}`, slot.cwd, DELIVERY_VERIFY_TIMEOUT_MS + 15_000);
             if (this.waitOk(back.code, back.stdout) || await this.deliveryReadMatches(pane, cmd, slot.cwd)) {
-                const enter = await this.herdr(`pane send-keys ${shq(pane)} Enter`, slot.cwd);
-                if (enter.code !== 0)
-                    throw new Error(`herdr pane send-keys Enter failed: ${enter.stderr || enter.stdout}`);
+                await this.submitVerifiedDelivery(slot, cmd, pane);
                 return;
             }
             // capture the corrupted delivery BEFORE clearing it — the OBS-85 byte-level evidence
@@ -423,20 +444,52 @@ export class HerdrDriver {
         }
         throw new Error(`herdr delivery corrupted after ${DELIVERY_ATTEMPTS} attempts — enter never pressed (OBS-85); pane transcript:\n${transcript}`);
     }
-    async settleDeliveryLine(pane, cwd, initialTranscript) {
+    async submitVerifiedDelivery(slot, cmd, pane) {
+        let transcript = "";
+        const inputBox = this.inputBoxes.get(slot);
+        for (let attempt = 0; attempt < DELIVERY_SUBMIT_ATTEMPTS; attempt++) {
+            const enter = await this.herdr(`pane send-keys ${shq(pane)} Enter`, slot.cwd);
+            if (enter.code !== 0)
+                throw new Error(`herdr pane send-keys Enter failed: ${enter.stderr || enter.stdout}`);
+            // Reuse the existing settle-read window. A first-read success returns before any timer; only
+            // a prompt that still occupies the delivery target spends the bounded settle window. This
+            // verification always completes before a possible re-press, so a slow submit cannot duplicate.
+            const settled = await this.settleDeliveryLine(pane, slot.cwd, transcript, inputBox, (candidate) => this.submissionRegistered(candidate, cmd, inputBox));
+            transcript = settled.transcript;
+            if (settled.ok)
+                return;
+            if (settled.readFailed) {
+                throw new Error(`herdr delivery corrupted — submission verification failed, refusing to re-press Enter (OBS-140); pane transcript:\n${transcript}`);
+            }
+        }
+        throw new Error(`herdr delivery corrupted after ${DELIVERY_SUBMIT_ATTEMPTS} submit attempts — submission never registered (OBS-140); pane transcript:\n${transcript}`);
+    }
+    async settleDeliveryLine(pane, cwd, initialTranscript, inputBox, accept) {
         let transcript = initialTranscript;
         for (let readAttempt = 0; readAttempt < DELIVERY_SETTLE_READ_ATTEMPTS; readAttempt++) {
             const read = await this.herdr(`pane read ${shq(pane)} --source recent-unwrapped --lines ${DELIVERY_READ_LINES}`, cwd);
             if (read.code !== 0)
-                return { ok: false, transcript: read.stdout || transcript };
-            if (read.stdout === transcript)
-                return { ok: true, transcript };
+                return { ok: false, transcript: read.stdout || transcript, recognizedInputBox: false, readFailed: true };
+            if (accept?.(read.stdout)) {
+                return {
+                    ok: true,
+                    transcript: read.stdout,
+                    recognizedInputBox: inputBox !== undefined && matchesInputBox(read.stdout, inputBox),
+                };
+            }
+            if (accept === undefined && read.stdout === transcript) {
+                return {
+                    ok: true,
+                    transcript,
+                    recognizedInputBox: inputBox !== undefined && matchesInputBox(transcript, inputBox),
+                };
+            }
             transcript = read.stdout;
             if (readAttempt < DELIVERY_SETTLE_READ_ATTEMPTS - 1) {
                 await new Promise((resolve) => setTimeout(resolve, DELIVERY_SETTLE_POLL_MS));
             }
         }
-        return { ok: false, transcript };
+        return { ok: false, transcript, recognizedInputBox: false };
     }
     async deliveryReadMatches(pane, cmd, cwd) {
         const read = await this.herdr(`pane read ${shq(pane)} --source recent-unwrapped --lines ${DELIVERY_READ_LINES}`, cwd);

package/dist/run/daemon.js

@@ -24,7 +24,7 @@ import { acquireRunLock, releaseRunLock } from "./lock.js";
 import { ensureIntegration, integrationBranch, integrationHead, mergeTask, verifyIntegrationTip } from "./merge.js";
 import { nextChannel, route } from "../route/router.js";
 import { desiredPanes } from "./reconcile.js";
-import { normalizeStallSnapshot } from "./stall.js";
+import { StallProgressTracker } from "./stall.js";
 const MODE_RANK = { "staff-led": 0, "risk-based": 1, "partner-led": 2 };
 // An override (flag/spec) re-resolves through loadConfigWithMode itself, via a synthesized repo overlay
 // carrying routing.mode — floors, explore, lints, and provenance all come from config.ts's preset
@@ -795,13 +795,13 @@ export async function runDaemon(repoRoot, opts = {}) {
                 // single site, so a test can reason about it; keep Date.now() out of profile.ts (still pure) and
                 // out of adapter module scope (the cursor is a parameter, threaded from the daemon).
                 const attemptStart = Date.now();
-                // v1.23 T2: once-per-attempt latch for context threshold crossing. Sample ONLY at existing poll
-                // seams (interactive wait slices) — never a new timer loop. null/unknown usage fails OPEN
+                // v1.23 T2: once-per-attempt latch for context threshold crossing. Sample ONLY at existing worker
+                // wait slices — never a new timer loop. null/unknown usage fails OPEN
                 // (never treated as over-threshold). Journal + notify fire at most once while the value stays high.
                 let contextWarned = false;
                 let contextTokens;
                 const sampleContext = async () => {
-                    if (contextWarned || !adapter.contextUsage)
+                    if (!adapter.contextUsage)
                         return;
                     let usage = null;
                     try {
@@ -814,7 +814,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     if (!usage || typeof usage.tokens !== "number" || !Number.isFinite(usage.tokens))
                         return;
                     contextTokens = usage.tokens; // last known valid sample, including under-threshold resume candidates
-                    if (usage.tokens < cfg.contextWarnTokens)
+                    if (contextWarned || usage.tokens < cfg.contextWarnTokens)
                         return;
                     contextWarned = true;
                     lastContextTokens = usage.tokens;
@@ -862,15 +862,15 @@ export async function runDaemon(repoRoot, opts = {}) {
                         // OBS-54: reaping keys on new pane output, not dispatch wall clock. Poll at least twice per
                         // stall window (and at the existing 30s cadence for normal windows) so an active worker resets it.
                         const stallWindowMs = taskTimeoutMinutes * 60_000;
-                        // OBS-82: the stall clock compares NORMALIZED snapshots so a spinner glyph/elapsed-time
-                        // repaint is silence, not activity. ONLY this inactivity compare sees normalized text —
-                        // trailer detection, harvest, paging, and quota checks all read the raw pane.
+                        // v1.76: only monotonic work (seed submission, transcript growth, or context growth) resets
+                        // the stall clock. Raw pane differences are terminal chrome until proven otherwise.
                         let everHadOutput = output.length > 0;
-                        let lastStallSnapshot = normalizeStallSnapshot(output);
-                        let lastOutputAt = Date.now();
-                        while (Date.now() - lastOutputAt < stallWindowMs) {
+                        const stallProgress = new StallProgressTracker();
+                        stallProgress.observe({ paneText: output, seedSubmitted: true, contextTokens });
+                        let lastProgressAt = Date.now();
+                        while (Date.now() - lastProgressAt < stallWindowMs) {
                             const sliceStart = Date.now();
-                            const remaining = stallWindowMs - (sliceStart - lastOutputAt);
+                            const remaining = stallWindowMs - (sliceStart - lastProgressAt);
                             let slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
                             if (!everHadOutput) {
                                 const earlyLeft = earlyLaunchLivenessMs - (sliceStart - attemptStart);
@@ -893,11 +893,6 @@ export async function runDaemon(repoRoot, opts = {}) {
                             const paneText = await driver.read(slot, 1000);
                             if (paneText.length > 0)
                                 everHadOutput = true;
-                            const currentStallSnapshot = normalizeStallSnapshot(paneText);
-                            if (currentStallSnapshot !== lastStallSnapshot) {
-                                lastStallSnapshot = currentStallSnapshot;
-                                lastOutputAt = Date.now();
-                            }
                             // OBS-117 (v1.71 T6): zero raw output by the early-launch deadline is a dead channel now.
                             if (!everHadOutput && Date.now() - attemptStart >= earlyLaunchLivenessMs) {
                                 earlyLaunchDead = true;
@@ -906,6 +901,8 @@ export async function runDaemon(repoRoot, opts = {}) {
                             }
                             // v1.23 T2: piggyback on this poll slice — same cadence as blocked/idle checks, no new timer.
                             await sampleContext();
+                            if (stallProgress.observe({ paneText, contextTokens }))
+                                lastProgressAt = Date.now();
                             // page on "idle" too: herdr's blocked-scrape is strict and proved flaky for TUI dialogs
                             // (live check: cursor's trust dialog scraped as idle). "unknown" never pages — that's just
                             // a pane the scraper can't read (subprocess, dead pane); the task timeout covers those.
@@ -943,7 +940,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         }
                         if (!finished && exitCode === null) {
                             // timed out (or only ever saw false positives): harvest whatever the pane holds now
-                            timedOut = Date.now() - lastOutputAt >= stallWindowMs;
+                            timedOut = Date.now() - lastProgressAt >= stallWindowMs;
                             output = await driver.read(slot, 1000);
                             finished = new RegExp(trailerPattern(nonce)).test(output);
                             const exit = exitRe.exec(output);
@@ -981,16 +978,16 @@ export async function runDaemon(repoRoot, opts = {}) {
                 else {
                     await driver.run(slot, paneDispatchCommand(dispatchScript));
                     // OBS-54: headless workers have the same output-inactivity budget as visible panes.
-                    // OBS-82: same normalized-snapshot compare as the interactive site — spinner-only repaints
-                    // exhaust the budget here too; harvest below still reads the raw pane.
+                    // v1.76: same monotonic-progress measure as the interactive site; harvest stays raw.
                     const stallWindowMs = taskTimeoutMinutes * 60_000;
                     const initialPane = await driver.read(slot, 500);
                     let everHadOutput = initialPane.length > 0;
-                    let lastStallSnapshot = normalizeStallSnapshot(initialPane);
-                    let lastOutputAt = Date.now();
+                    const stallProgress = new StallProgressTracker();
+                    stallProgress.observe({ paneText: initialPane, seedSubmitted: true, contextTokens });
+                    let lastProgressAt = Date.now();
                     finished = false;
-                    while (Date.now() - lastOutputAt < stallWindowMs) {
-                        const remaining = stallWindowMs - (Date.now() - lastOutputAt);
+                    while (Date.now() - lastProgressAt < stallWindowMs) {
+                        const remaining = stallWindowMs - (Date.now() - lastProgressAt);
                         let slice = Math.min(BLOCKED_POLL_MS, Math.max(100, Math.min(stallWindowMs / 2, remaining)));
                         if (!everHadOutput) {
                             const earlyLeft = earlyLaunchLivenessMs - (Date.now() - attemptStart);
@@ -1004,19 +1001,17 @@ export async function runDaemon(repoRoot, opts = {}) {
                         const paneText = await driver.read(slot, 500);
                         if (paneText.length > 0)
                             everHadOutput = true;
-                        const currentStallSnapshot = normalizeStallSnapshot(paneText);
-                        if (currentStallSnapshot !== lastStallSnapshot) {
-                            lastStallSnapshot = currentStallSnapshot;
-                            lastOutputAt = Date.now();
-                        }
                         if (!everHadOutput && Date.now() - attemptStart >= earlyLaunchLivenessMs) {
                             earlyLaunchDead = true;
                             break;
                         }
+                        await sampleContext();
+                        if (stallProgress.observe({ paneText, contextTokens }))
+                            lastProgressAt = Date.now();
                     }
                     output = await driver.read(slot, 500);
                     exitCode = Number(exitRe.exec(output)?.[1] ?? 1);
-                    timedOut = !finished && Date.now() - lastOutputAt >= stallWindowMs;
+                    timedOut = !finished && Date.now() - lastProgressAt >= stallWindowMs;
                 }
                 // SPEND-01 interactive metering race: the harvest loop breaks on the trailer, but the worker
                 // shell may still be running post-trailer bookkeeping (session-store flush, fake usage stamp,

package/dist/run/stall.d.ts

@@ -1,8 +1,25 @@
-/** Normalize one pane snapshot for the stall-inactivity compare (trailer parsing, harvest,
- * waitOutput, and paging read the raw text; the LLM transcript filter below reuses this to
- * CLASSIFY presentation-only lines, never to rewrite kept bytes). Two snapshots that normalize
- * equal are the same frame modulo spinner presentation; any other byte difference is activity. */
+/** Normalize presentation tokens for transcript extent and LLM-noise classification. Trailer
+ * parsing, harvest, waitOutput, and paging always read the raw text. */
 export declare function normalizeStallSnapshot(text: string): string;
+export interface StallProgressSample {
+    paneText: string;
+    seedSubmitted?: boolean;
+    contextTokens?: number;
+}
+/**
+ * Monotonic worker-progress measure for the stall watchdog.
+ *
+ * Terminal chrome is allowed to repaint arbitrary bytes in place, so byte differences are not
+ * evidence of work. A rendered transcript is only known to have grown when it occupies more
+ * non-empty rows than any prior sample. Same-row rewrites are deliberately ambiguous and do not
+ * advance the clock: a recoverable early consult is safer than silencing the watchdog forever.
+ */
+export declare class StallProgressTracker {
+    private transcriptRows;
+    private seedSubmitted;
+    private contextTokens;
+    observe(sample: StallProgressSample): boolean;
+}
 /** Filter transcript text bound for an LLM prompt (consult dossiers, gate prompts). The classify
  * seam exists for fault injection in tests only — production callers pass text alone. */
 export declare function filterLlmTranscript(text: string, classify?: (t: string) => string): string;

package/dist/run/stall.js

@@ -1,12 +1,9 @@
-// OBS-82: codex's MCP-startup spinner repaints a braille glyph + elapsed-time cell forever, so the
-// daemon's raw snapshot compare reads a wedged pane as active and the stall clock never fires.
-// This normalizer deletes ONLY presentation tokens from a closed allowlist — ANSI/VT escape
-// sequences, braille-range spinner glyphs, and elapsed-time tokens bound to time-unit suffixes.
-// Every other byte passes through identical: words, paths, server names, and progress counts
-// (a five-of-seven counter change IS activity) all remain change-sensitive. The asymmetry is the
-// design: an allowlist MISS degrades to today's recoverable no-reap behavior, while an over-broad
-// deletion would reap a healthy worker — a new failure class. Grow the allowlist only with
-// captured evidence (tests/fixtures/codex-mcp-spinner/).
+// OBS-82: normalize known presentation tokens before measuring transcript extent or filtering an
+// LLM-bound transcript. This remains a closed allowlist — ANSI/VT escapes, braille-range spinner
+// glyphs, and elapsed-time tokens bound to time-unit suffixes. Every other byte passes through
+// identical. v1.76 deliberately stopped treating arbitrary normalized byte changes as progress:
+// StallProgressTracker below requires monotonic evidence, so an unknown repaint fails closed toward
+// a recoverable consult instead of holding the watchdog silent.
 // CSI (with intermediates), OSC (BEL- or ST-terminated), DCS/SOS/PM/APC strings, single-char
 // escapes, and charset selection — the raw-pty forms; herdr pane reads are already rendered.
 // eslint-disable-next-line no-control-regex
@@ -16,13 +13,46 @@ const SPINNER_RE = /[⠀-⣿]/g;
 // A digit run (optionally decimal) bound directly to a time-unit suffix, standing alone as a
 // word: 9s, 41s, 3m, 1h, 800ms. Never bare digits — "(6/7)" and "5 of 7" stay change-sensitive.
 const ELAPSED_RE = /(?<![\w.])\d+(?:\.\d+)?(?:ms|[hms])(?!\w)/g;
-/** Normalize one pane snapshot for the stall-inactivity compare (trailer parsing, harvest,
- * waitOutput, and paging read the raw text; the LLM transcript filter below reuses this to
- * CLASSIFY presentation-only lines, never to rewrite kept bytes). Two snapshots that normalize
- * equal are the same frame modulo spinner presentation; any other byte difference is activity. */
+/** Normalize presentation tokens for transcript extent and LLM-noise classification. Trailer
+ * parsing, harvest, waitOutput, and paging always read the raw text. */
 export function normalizeStallSnapshot(text) {
     return text.replace(ANSI_RE, "").replace(SPINNER_RE, "").replace(ELAPSED_RE, "");
 }
+/**
+ * Monotonic worker-progress measure for the stall watchdog.
+ *
+ * Terminal chrome is allowed to repaint arbitrary bytes in place, so byte differences are not
+ * evidence of work. A rendered transcript is only known to have grown when it occupies more
+ * non-empty rows than any prior sample. Same-row rewrites are deliberately ambiguous and do not
+ * advance the clock: a recoverable early consult is safer than silencing the watchdog forever.
+ */
+export class StallProgressTracker {
+    transcriptRows = 0;
+    seedSubmitted = false;
+    contextTokens;
+    observe(sample) {
+        let advanced = false;
+        const rows = normalizeStallSnapshot(sample.paneText)
+            .split("\n")
+            .filter((line) => line.trim().length > 0)
+            .length;
+        if (rows > this.transcriptRows) {
+            this.transcriptRows = rows;
+            advanced = true;
+        }
+        if (sample.seedSubmitted && !this.seedSubmitted) {
+            this.seedSubmitted = true;
+            advanced = true;
+        }
+        const tokens = sample.contextTokens;
+        if (tokens !== undefined && Number.isFinite(tokens)) {
+            if (tokens > (this.contextTokens ?? 0))
+                advanced = true;
+            this.contextTokens = Math.max(this.contextTokens ?? 0, tokens);
+        }
+        return advanced;
+    }
+}
 // ─── v1.65 T2: LLM-bound transcript filter ──────────────────────────────────────────────────────
 // Consult dossiers and gate prompts pay tokens per transcript byte, so LLM-bound text runs through
 // a per-line classifier: carriage-return overwrite churn keeps only the final paint, lines that are

package/package.json

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

package/skills/tickmarkr-auto/SKILL.md

@@ -15,8 +15,9 @@ When working in a multi-agent terminal environment, decide your role before star
 - **Orchestrator:** your session was started to execute the mission. Rename your own tab/pane `ORCH · <version>` (short labels: ≤20 chars, `ROLE · token`) and run the loop below.
 - **Supervisor with a live orchestrator:** do not start a second run. Relay the mission to the existing orchestrator with a [verified handoff](#verified-handoffs-agent-to-agent-messaging), then supervise it as OVERSEER.
 - **Primary session without an orchestrator:** rename your own tab `OVERSEER · <version>` and your agent `overseer`, spawn one child orchestration session with your host's launch form, label its tab `ORCH · <version>` and name its agent, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself. Before spawning, confirm any PREVIOUS orchestrator has stood down (monitors stopped, input box empty — dim ghost-text suggestions are UI, not queued input; ANSI-verify before alarming) and close its tab — the journal, records, and ledger hold the story; scrollback is disposable.
-  - **Claude Code:** `herdr agent start orchestrator --cwd <repo> --no-focus -- claude --permission-mode bypassPermissions`
-  - **Codex:** `herdr agent start orchestrator --cwd <repo> --no-focus -- codex --dangerously-bypass-approvals-and-sandbox` — the unsandboxed flag is REQUIRED, not optional: codex's `workspace-write` sandbox keeps `.git` refs read-only, so a sandboxed orchestrator's `tickmarkr run` dies at integration-branch creation (`git worktree add` cannot lock the ref). Do not downgrade this flag; the herdr pane and repo scope are the containment.
+  - **Spawning on current herdr is two-step** — the one-shot `agent start --cwd/--tab/--no-focus` form was removed in the herdr CLI redesign and now fails with `unknown option` (OBS-138). First create the pane: `herdr tab create --workspace <ws> --cwd <repo> --label "ORCH · <version>"` (tab create does not steal focus unless `--focus` is passed; parse `result.root_pane.pane_id` from its JSON), then start the agent in it:
+  - **Claude Code:** `herdr agent start orchestrator --kind claude --pane <root-pane-id> -- --permission-mode bypassPermissions`
+  - **Codex:** `herdr agent start orchestrator --kind codex --pane <root-pane-id> -- --dangerously-bypass-approvals-and-sandbox` — the unsandboxed flag is REQUIRED, not optional: codex's `workspace-write` sandbox keeps `.git` refs read-only, so a sandboxed orchestrator's `tickmarkr run` dies at integration-branch creation (`git worktree add` cannot lock the ref). Do not downgrade this flag; the herdr pane and repo scope are the containment.
   - **Auxiliary agents you spawn (consultants, reviewers, scouts) follow the same forms.** Never launch a claude session in plan mode or default permission mode for autonomous work — both stall on per-command approval prompts nobody is watching; claude is always `--permission-mode bypassPermissions` (tickmarkr's own adapter uses exactly this for workers, judges, and consults). A read-only codex consultant may use `--sandbox read-only`; any codex session that must touch git needs the unsandboxed flag above.
 
 Outside a multi-agent terminal environment, run the loop directly.

package/skills/tickmarkr-loop/SKILL.md

@@ -14,8 +14,9 @@ When working in a multi-agent terminal environment, decide your role before star
 - **Orchestrator:** your session was started to execute the mission. Rename your own tab/pane `ORCH · <version>` (short labels: ≤20 chars, `ROLE · token`) and run the loop below.
 - **Supervisor with a live orchestrator:** do not start a second run. Relay the mission to the existing orchestrator with a [verified handoff](#verified-handoffs-agent-to-agent-messaging), then supervise it as OVERSEER.
 - **Primary session without an orchestrator:** rename your own tab `OVERSEER · <version>` and your agent `overseer`, spawn one child orchestration session with your host's launch form, label its tab `ORCH · <version>` and name its agent, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself. Before spawning, confirm any PREVIOUS orchestrator has [stood down](#stand-down-mission-end-and-retirement) and close its tab.
-  - **Claude Code:** `herdr agent start orchestrator --cwd <repo> --no-focus -- claude --permission-mode bypassPermissions`
-  - **Codex:** `herdr agent start orchestrator --cwd <repo> --no-focus -- codex --dangerously-bypass-approvals-and-sandbox` — the unsandboxed flag is REQUIRED, not optional: codex's `workspace-write` sandbox keeps `.git` refs read-only, so a sandboxed orchestrator's `tickmarkr run` dies at integration-branch creation (`git worktree add` cannot lock the ref). Do not downgrade this flag; the herdr pane and repo scope are the containment.
+  - **Spawning on current herdr is two-step** — the one-shot `agent start --cwd/--tab/--no-focus` form was removed in the herdr CLI redesign and now fails with `unknown option` (OBS-138). First create the pane: `herdr tab create --workspace <ws> --cwd <repo> --label "ORCH · <version>"` (tab create does not steal focus unless `--focus` is passed; parse `result.root_pane.pane_id` from its JSON), then start the agent in it:
+  - **Claude Code:** `herdr agent start orchestrator --kind claude --pane <root-pane-id> -- --permission-mode bypassPermissions`
+  - **Codex:** `herdr agent start orchestrator --kind codex --pane <root-pane-id> -- --dangerously-bypass-approvals-and-sandbox` — the unsandboxed flag is REQUIRED, not optional: codex's `workspace-write` sandbox keeps `.git` refs read-only, so a sandboxed orchestrator's `tickmarkr run` dies at integration-branch creation (`git worktree add` cannot lock the ref). Do not downgrade this flag; the herdr pane and repo scope are the containment.
   - **Auxiliary agents you spawn (consultants, reviewers, scouts) follow the same forms.** Never launch a claude session in plan mode or default permission mode for autonomous work — both stall on per-command approval prompts nobody is watching; claude is always `--permission-mode bypassPermissions` (tickmarkr's own adapter uses exactly this for workers, judges, and consults). A read-only codex consultant may use `--sandbox read-only`; any codex session that must touch git needs the unsandboxed flag above.
 
 Outside a multi-agent terminal environment, run the loop directly.

package/skills/tickmarkr-overseer/SKILL.md

@@ -29,7 +29,7 @@ Requires `HERDR_ENV=1`; if unset, say so and stop.
    main name plus at most ONE hot-state token. Vocabulary: ORCH carries the milestone and progress
    fraction (`ORCH · v1.19 4/5`, updated on every task-done); WORKERS carries the task token (tickmarkr
    updates it). Never long context strings or ✓-chains.
-2. **Orchestrator**: Launch the orchestrator with your agent host. For Claude Code, use `herdr agent start orchestrator --cwd <repo> --no-focus -- claude --permission-mode bypassPermissions` (pin a strong model with `--model <m>` if the operator has a policy). For Codex, use `herdr agent start orchestrator --cwd <repo> --no-focus -- codex --dangerously-bypass-approvals-and-sandbox` (add `--model <m>` to specify the model). The unsandboxed flag is REQUIRED: codex's `workspace-write` sandbox keeps `.git` refs read-only, so a sandboxed orchestrator's `tickmarkr run` dies at integration-branch creation — do not downgrade it. Workers you never spawn — tickmarkr spawns its own visible worker panes. Auxiliary agents you do spawn (consultants, reviewers, scouts) follow the same forms: never launch a claude session in plan mode or default permission mode for autonomous work — both stall on per-command approval prompts nobody is watching; claude is always `--permission-mode bypassPermissions`, and a read-only codex consultant may use `--sandbox read-only`.
+2. **Orchestrator**: Launch the orchestrator with your agent host. Spawning on current herdr is two-step — the one-shot `agent start --cwd` form was removed in the herdr CLI redesign and now fails with `unknown option` (OBS-138): first create the pane with `herdr tab create --workspace <ws> --cwd <repo> --label "ORCH · <version>"` and parse `result.root_pane.pane_id` from its JSON, then start the agent in it. For Claude Code, use `herdr agent start orchestrator --kind claude --pane <root-pane-id> -- --permission-mode bypassPermissions` (append `--model <m>` after the `--` if the operator has a policy). For Codex, use `herdr agent start orchestrator --kind codex --pane <root-pane-id> -- --dangerously-bypass-approvals-and-sandbox` (add `--model <m>` to specify the model). The unsandboxed flag is REQUIRED: codex's `workspace-write` sandbox keeps `.git` refs read-only, so a sandboxed orchestrator's `tickmarkr run` dies at integration-branch creation — do not downgrade it. Workers you never spawn — tickmarkr spawns its own visible worker panes. Auxiliary agents you do spawn (consultants, reviewers, scouts) follow the same forms: never launch a claude session in plan mode or default permission mode for autonomous work — both stall on per-command approval prompts nobody is watching; claude is always `--permission-mode bypassPermissions`, and a read-only codex consultant may use `--sandbox read-only`.
 3. **Standing instructions travel as a brief FILE, never as pane text** — PTY input truncates at ~1024B and a
    truncated brief silently drops policy. Write the full brief to `<repo>/.tickmarkr/overseer/ORCH-BRIEF.md`
    (inside the tickmarkr state dir — already self-gitignored, no exclude step needed), then send one line: