tickmarkr 1.62.0 → 1.63.0

package/dist/cli/commands/status.js

@@ -103,14 +103,27 @@ const daemonPid = (events) => {
     }
     return undefined;
 };
+const terminalFailureCause = (events) => {
+    for (let i = events.length - 1; i >= 0; i--) {
+        const e = events[i];
+        if (e.event !== "run-end" || typeof e.data.error !== "string")
+            continue;
+        const phase = typeof e.data.phase === "string" && e.data.phase.trim()
+            ? `${e.data.phase.trim()} failed`
+            : "run failed";
+        return `${phase}: ${e.data.error.replace(/\s+/g, " ").trim()}`;
+    }
+    return undefined;
+};
 const liveness = (events) => {
     const last = events.at(-1);
     if (!last)
         return "last event unknown · daemon pid unknown";
     const age = fmtAge(Date.now() - Date.parse(last.ts));
     const pid = daemonPid(events);
+    const cause = terminalFailureCause(events);
     if (pid === undefined)
-        return `last event ${age} ago · daemon pid unknown`;
+        return `last event ${age} ago · daemon pid unknown${cause ? ` · ${cause}` : ""}`;
     // a dead pid after run-end is a clean exit, not a crash — "dead" is only alarming (red) while
     // the run is still incomplete (operator's crash indicator)
     const ended = events.some((e) => e.event === "run-end");
@@ -122,7 +135,7 @@ const liveness = (events) => {
     catch (k) {
         state = k.code === "ESRCH" ? (ended ? "finished" : "dead") : "alive";
     } // EPERM ⇒ alive
-    return `last event ${age} ago · daemon pid ${pid} ${state}`;
+    return `last event ${age} ago · daemon pid ${pid} ${state}${cause ? ` · ${cause}` : ""}`;
 };
 const renderFrame = (cwd) => {
     const g = loadGraph(cwd);

package/dist/compile/native.js

@@ -21,6 +21,10 @@ export function compileNative(file) {
     if (!existsSync(file))
         throw new CompileError(`no such native spec file: ${file}`);
     const content = readFileSync(file, "utf8");
+    // Exact shared-template check: init writes specTemplate(), and any edit changes the body.
+    if (content === specTemplate()) {
+        throw new CompileError(`${file} is the unedited tickmarkr init scaffold. Edit ${file} before compiling.`);
+    }
     const drafts = [];
     let plainCount = 0; // v1.19: plain-string acceptance items compiled as judge oracles (compat) — warn once
     let specMode;

package/dist/gates/baseline.d.ts

@@ -4,7 +4,14 @@ export interface Baseline {
     commands: Record<string, {
         exitCode: number;
         fingerprints: string[];
+        missingCommand?: boolean;
     }>;
+    warnings?: BaselineWarning[];
+}
+export interface BaselineWarning {
+    kind: "wrong-environment";
+    commands: string[];
+    reason: string;
 }
 export declare function fingerprint(output: string): string[];
 export declare function detectGateCommands(repoRoot: string, cfg: TickmarkrConfig): Record<string, string>;

package/dist/gates/baseline.js

@@ -41,12 +41,45 @@ export function detectGateCommands(repoRoot, cfg) {
     }
     return out;
 }
+const shellToken = (cmd) => {
+    for (const raw of cmd.trim().split(/\s+/)) {
+        if (!raw || /^[A-Za-z_][A-Za-z0-9_]*=/.test(raw))
+            continue;
+        if (raw === "env")
+            continue;
+        return raw.replace(/^['"]|['"]$/g, "");
+    }
+    return undefined;
+};
+const reEscape = (s) => s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+function missingConfiguredCommand(cmd, result) {
+    if (result.code !== 127)
+        return false;
+    const token = shellToken(cmd);
+    if (!token)
+        return false;
+    const output = `${result.stdout}\n${result.stderr}`;
+    return new RegExp(`(?:^|[:\\s])${reEscape(token)}:\\s+(?:command not found|No such file or directory)`, "i").test(output);
+}
 export async function captureBaseline(cwd, commands) {
     const base = { commands: {} };
     for (const [name, cmd] of Object.entries(commands)) {
         const r = await sh(cmd, cwd);
         // ponytail: strip the executing cwd so repo-root capture and worktree compare fingerprint identically; /private-vs-/tmp symlink variance is out of scope
-        base.commands[name] = { exitCode: r.code, fingerprints: fingerprint((r.stdout + "\n" + r.stderr).split(cwd).join("")) };
+        base.commands[name] = {
+            exitCode: r.code,
+            fingerprints: fingerprint((r.stdout + "\n" + r.stderr).split(cwd).join("")),
+            missingCommand: missingConfiguredCommand(cmd, r),
+        };
+    }
+    const names = Object.keys(commands);
+    const missing = names.filter((name) => base.commands[name]?.missingCommand === true);
+    if (names.length > 0 && missing.length === names.length) {
+        base.warnings = [{
+                kind: "wrong-environment",
+                commands: missing,
+                reason: `wrong environment: every configured baseline command was missing (${missing.join(", ")})`,
+            }];
     }
     return base;
 }

package/dist/run/daemon.js

@@ -109,6 +109,10 @@ export async function runDaemon(repoRoot, opts = {}) {
     // v1.54 T2: declared before the try so the finally can always deregister (a throw before
     // registration leaves it undefined — the guard below covers that path).
     let onTermination;
+    let journal;
+    let runStarted = false;
+    let taskLoopStarted = false;
+    let branch = "";
     try {
         let graph = loadGraph(repoRoot);
         // v1.51 T2: the routing mode resolves BEFORE any routing input is built — run flag > spec front-matter
@@ -184,12 +188,12 @@ export async function runDaemon(repoRoot, opts = {}) {
         };
         process.on("SIGINT", onTermination);
         process.on("SIGTERM", onTermination);
-        const journal = opts.resume ? Journal.open(repoRoot, runId, opts.narrate) : Journal.create(repoRoot, runId, opts.narrate);
+        journal = opts.resume ? Journal.open(repoRoot, runId, opts.narrate) : Journal.create(repoRoot, runId, opts.narrate);
         const branchEvent = opts.resume
             ? [...journal.read()].reverse().find((e) => (e.event === "run-start" || e.event === "run-end" || e.event === "merge") && typeof e.data.branch === "string")
             : undefined;
         const recordedBranch = typeof branchEvent?.data.branch === "string" ? branchEvent.data.branch : undefined;
-        const branch = recordedBranch
+        branch = recordedBranch
             ? branchEvent.event === "merge" ? recordedBranch.slice(0, recordedBranch.lastIndexOf("--")) : recordedBranch
             : integrationBranch(cfg, runId);
         if (lock.reclaimed)
@@ -249,9 +253,12 @@ export async function runDaemon(repoRoot, opts = {}) {
             baseline = await captureBaseline(repoRoot, commands);
             writeFileSync(join(journal.dir, "baseline.json"), JSON.stringify(baseline, null, 2));
             journal.append("run-start", undefined, { pid: process.pid, baseRef, commands, channels: channels.map(channelKey), branch, graphDefinitionHash: graphDefinitionHash(graph), mode: rm.mode.mode, modeSource: rm.source, ...(prior ? { supersedes: prior.runId } : {}) }); // graphDefinitionHash: T3 engagement identity (status+resume share it); pid: v1.13 (VIS-11) liveness; mode/modeSource: v1.51 T2; supersedes: v1.53 T5
+            runStarted = true;
             // v1.53 T5: mark the prior run AFTER this run's run-start exists, so the prior journal never
             // names a successor that has no journal. Append-only — the prior journal is never rewritten.
             prior?.append("superseded", undefined, { by: runId });
+            for (const warning of baseline.warnings ?? [])
+                journal.append("baseline-warning", undefined, { ...warning });
         }
         // T6: open the narrator AFTER run-start/run-resume is journaled so the watch surface has a run to
         // show. driver.narrator is undefined on subprocess → no-op (subprocess spawns nothing). Swallowed:
@@ -979,6 +986,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                 return;
             }
         };
+        taskLoopStarted = true;
         const inflight = new Map();
         while (true) {
             // v1.54 T2: a signal that landed while nothing was racing `aborted` (empty inflight window)
@@ -1069,6 +1077,23 @@ export async function runDaemon(repoRoot, opts = {}) {
         await driver.notify(`tickmarkr ${runId}: ${summary.done.length} done, ${summary.failed.length} failed, ${summary.human.length} awaiting human, ${summary.blocked.length} blocked, ${summary.pending.length} pending${attribution ? ` (${attribution})` : ""}${tipFail} — integration branch ${branch} (merge to main is yours)`, { tier: summary.tipVerify === "failed" ? "attention" : "routine" });
         return summary;
     }
+    catch (err) {
+        if (runStarted && !taskLoopStarted && !journal.read().some((e) => e.event === "run-end")) {
+            journal.append("run-end", undefined, {
+                runId,
+                branch,
+                done: [],
+                failed: [],
+                human: [],
+                blocked: [],
+                pending: [],
+                phase: "setup",
+                fatal: true,
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        throw err;
+    }
     finally {
         // v1.54 T2: deregister on EVERY exit (normal run end, throw, termination unwind) — the daemon
         // test suite runs runDaemon dozens of times in one process; a leaked handler would close a

package/package.json

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

package/skills/tickmarkr-auto/SKILL.md

@@ -16,7 +16,8 @@ When working in a multi-agent terminal environment, decide your role before star
 - **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 --ask-for-approval never --sandbox workspace-write`
+  - **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.
+  - **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

@@ -15,7 +15,8 @@ When working in a multi-agent terminal environment, decide your role before star
 - **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 --ask-for-approval never --sandbox workspace-write`
+  - **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.
+  - **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 --ask-for-approval never --sandbox workspace-write` (add `--model <m>` to specify the model). Workers you never spawn — tickmarkr spawns its own visible worker panes.
+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`.
 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: