tickmarkr 1.40.0 → 1.41.0

package/dist/gates/baseline.js

@@ -6,20 +6,21 @@ import { sh } from "../run/git.js";
 // a pass-marker line is never a failure. [\d;#] covers raw ANSI and digit-normalized ANSI ("\x1b[#m") from
 // baselines stored by pre-hardening code.
 const ANSI_RE = /\x1b\[[\d;#]*[A-Za-z]/g;
-// ponytail: only leading ✓/✔ after optional "label:" prefixes (turbo/vitest) counts as a pass line — other
-// runners' pass markers (PASS, ok) stay fingerprintable; extend the regex when a real one bites
-const PASS_LINE_RE = /^\s*(?:[\w@./-]+:\s*)*[✓✔]/;
+// ponytail: only leading ✓/✔ after optional "label:" prefixes (turbo/vitest), or tickmarkr's own run
+// summary, counts as a pass line — other runners' pass markers (PASS, ok) stay fingerprintable
+const PASS_LINE_RE = /^\s*(?:(?:[\w@./-]+:\s*)*[✓✔]|(?:\[tickmarkr\]\s+)?(?:tickmarkr\s+[\w.-]+:\s+)?(?:\d+|#)\s+done,\s+(?:\d+|#)\s+failed(?:,\s+(?:\d+|#)\s+awaiting human)?\b)/;
 // HYG-08 (D-01, incident run-20260711-154920): a failing test went unnamed for 3 attempts because details
 // headlined benign fingerprint-diff noise. These anchors harvest the runner's OWN failure naming from fresh
 // output to headline it. \s is fine in a TS regex — the BSD [[:space:]] rule binds shell grep only.
-const FAIL_ANCHOR_RE = /^\s*FAIL\s+/; // vitest/jest: " FAIL  <file> > <suite> > <test>"
+// OBS-42: vitest's diagnostic failure headings are shared anchors for baseline and tip verification.
+const FAIL_ANCHOR_RE = /^\s*(?:FAIL\s+|[^\w]*(?:Unhandled Errors|Uncaught Exception)\b)/;
 const SUMMARY_FAIL_RE = /^\s*Tests?\s+(?:Files?\s+)?\d+\s+failed/; // " Tests  N failed | M passed (T)"
 const normalizeLine = (l) => l.replace(/\d+/g, "#").replace(/\s+/g, " ").trim();
 export function fingerprint(output) {
     const lines = output
         .split("\n")
         .map((l) => l.replace(ANSI_RE, ""))
-        .filter((l) => !PASS_LINE_RE.test(l) && /\b(error|fail(ed|ure|ing)?)\b/i.test(l))
+        .filter((l) => !PASS_LINE_RE.test(l) && (FAIL_ANCHOR_RE.test(l) || /\b(error|fail(ed|ure|ing)?)\b/i.test(l)))
         .map(normalizeLine);
     return [...new Set(lines)];
 }
@@ -84,7 +85,8 @@ export async function compareToBaseline(cwd, commands, baseline, enabled) {
         }
         const raw = (r.stdout + "\n" + r.stderr).split(cwd).join("");
         const known = new Set((baseline.commands[name]?.fingerprints ?? []).map(renormalize));
-        const fresh = fingerprint(raw).filter((f) => !known.has(f));
+        // OBS-42: diagnostic headings enrich fingerprints but cannot invalidate legacy baselines.
+        const fresh = fingerprint(raw).filter((f) => !known.has(f) && (!FAIL_ANCHOR_RE.test(f) || f.startsWith("FAIL ")));
         if (!fresh.length && (baseline.commands[name]?.exitCode ?? 1) === 0) {
             results.push({
                 gate: name,

package/dist/run/daemon.js

@@ -723,7 +723,7 @@ export async function runDaemon(repoRoot, opts = {}) {
         // OBS-34: post-merge integration-tip verify — strict exit codes, no baseline forgiveness.
         const lastMergedTask = [...journal.read()].reverse().find((e) => e.event === "merge" && e.taskId)?.taskId;
         if (summary.done.length > 0 && Object.keys(commands).length > 0) {
-            const tipResults = await verifyIntegrationTip(intWt, commands);
+            const tipResults = await verifyIntegrationTip(intWt, commands, journal.dir);
             let tipFailed = false;
             for (const r of tipResults) {
                 if (r.pass) {
@@ -735,6 +735,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                         cmd: r.cmd,
                         exitCode: r.exitCode,
                         fingerprints: r.fingerprints,
+                        artifact: r.artifact,
                         lastMergedTask,
                     });
                     tipFailed = true;

package/dist/run/git.d.ts

@@ -16,4 +16,5 @@ export declare function cleanupRunWorktrees(repo: string, branch: string, opts:
 }): Promise<void>;
 export declare function resolveIntegrationBranch(_repo: string, branch: string): Promise<string>;
 export declare function createWorktree(repo: string, branch: string, baseRef: string): Promise<string>;
+export declare function linkNodeModules(repo: string, dir: string): void;
 export declare function removeWorktree(repo: string, dir: string): Promise<void>;

package/dist/run/git.js

@@ -78,7 +78,7 @@ export async function createWorktree(repo, branch, baseRef) {
 }
 // best-effort: devDep-based gates (tsx, vitest) shell out root-anchored and ENOENT in a bare
 // fresh worktree (OBS-27); failure here must never fail worktree creation
-function linkNodeModules(repo, dir) {
+export function linkNodeModules(repo, dir) {
     const src = join(repo, "node_modules");
     const dest = join(dir, "node_modules");
     if (!existsSync(src) || existsSync(dest))

package/dist/run/merge.d.ts

@@ -6,6 +6,7 @@ export interface TipVerifyResult {
     exitCode: number;
     fingerprints: string[];
     details: string;
+    artifact?: string;
 }
 export declare function integrationBranch(cfg: TickmarkrConfig, runId: string): string;
 export declare function ensureIntegration(repo: string, branch: string, baseRef: string): Promise<string>;
@@ -18,4 +19,4 @@ export declare function mergeTask(intWt: string, taskBranch: string, message: st
         branchTip: string;
     };
 }>;
-export declare function verifyIntegrationTip(intWt: string, commands: Record<string, string>): Promise<TipVerifyResult[]>;
+export declare function verifyIntegrationTip(intWt: string, commands: Record<string, string>, runDir: string): Promise<TipVerifyResult[]>;

package/dist/run/merge.js

@@ -1,9 +1,9 @@
-import { existsSync } from "node:fs";
+import { existsSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { shq } from "../adapters/types.js";
 import { fingerprint } from "../gates/baseline.js";
 import { tickmarkrDir } from "../graph/graph.js";
-import { gitHead, resolveIntegrationBranch, sh, shOk } from "./git.js";
+import { gitHead, linkNodeModules, resolveIntegrationBranch, sh, shOk } from "./git.js";
 export function integrationBranch(cfg, runId) {
     return `${cfg.integrationBranchPrefix}${runId}`;
 }
@@ -11,15 +11,16 @@ const sanitize = (branch) => branch.replace(/[^\w.-]+/g, "-");
 export async function ensureIntegration(repo, branch, baseRef) {
     branch = await resolveIntegrationBranch(repo, branch);
     const dir = join(tickmarkrDir(repo), "worktrees", sanitize(branch));
-    if (existsSync(join(dir, ".git")))
-        return dir; // resume: keep existing tip
-    const exists = (await sh(`git rev-parse --verify refs/heads/${shq(branch)}`, repo)).code === 0;
-    if (exists) {
-        await shOk(`git worktree add ${shq(dir)} ${shq(branch)}`, repo);
-    }
-    else {
-        await shOk(`git worktree add -b ${shq(branch)} ${shq(dir)} ${shq(baseRef)}`, repo);
+    if (!existsSync(join(dir, ".git"))) {
+        const exists = (await sh(`git rev-parse --verify refs/heads/${shq(branch)}`, repo)).code === 0;
+        if (exists) {
+            await shOk(`git worktree add ${shq(dir)} ${shq(branch)}`, repo);
+        }
+        else {
+            await shOk(`git worktree add -b ${shq(branch)} ${shq(dir)} ${shq(baseRef)}`, repo);
+        }
     }
+    linkNodeModules(repo, dir);
     return dir;
 }
 export function integrationHead(intWt) {
@@ -44,18 +45,22 @@ export async function mergeTask(intWt, taskBranch, message, gatedCommit) {
     return { ok: false, conflict };
 }
 // OBS-34: strict exit-code verify on the integration tip — no baseline forgiveness.
-export async function verifyIntegrationTip(intWt, commands) {
+export async function verifyIntegrationTip(intWt, commands, runDir) {
     const results = [];
     for (const [gate, cmd] of Object.entries(commands)) {
         const r = await sh(cmd, intWt);
-        const raw = (r.stdout + "\n" + r.stderr).split(intWt).join("");
+        const raw = r.stdout + "\n" + r.stderr;
+        const artifact = r.code !== 0 ? join(runDir, `tip-verify-${gate}.log`) : undefined;
+        if (artifact)
+            writeFileSync(artifact, raw);
         results.push({
             gate,
             cmd,
             pass: r.code === 0,
             exitCode: r.code,
-            fingerprints: r.code !== 0 ? fingerprint(raw) : [],
+            fingerprints: r.code !== 0 ? fingerprint(raw.split(intWt).join("")) : [],
             details: r.code === 0 ? "exit 0" : `exit ${r.code}`,
+            ...(artifact ? { artifact } : {}),
         });
     }
     return results;

package/package.json

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

package/skills/tickmarkr-auto/SKILL.md

@@ -12,12 +12,16 @@ Use this to execute a requested sequence of repository specs. It is SDD-agnostic
 
 When working in a multi-agent terminal environment, decide your role before starting:
 
-- **Orchestrator:** your session was started to execute the mission. Rename your own tab/pane ORCHESTRATOR and run the loop below.
+- **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, spawn one child orchestration session with `--permission-mode bypassPermissions`, label its tab ORCHESTRATOR, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself.
+- **Primary session without an orchestrator:** rename your own tab `OVERSEER · <version>` and your agent `overseer`, spawn one child orchestration session with `--permission-mode bypassPermissions`, 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) and close its tab — the journal, records, and ledger hold the story; scrollback is disposable.
 
 Outside a multi-agent terminal environment, run the loop directly.
 
+## Stand-down (mission end and retirement)
+
+On each mission's terminal state, after the record commit and operator notification: the orchestrator stops every monitor and background task it started, prints one final stand-down line, and leaves nothing queued in its input box. A finished session with an armed watcher or pre-filled input is a loaded gun.
+
 ## Invariants
 
 - Never run two tickmarkr runs in the same repository concurrently.

package/skills/tickmarkr-loop/SKILL.md

@@ -11,9 +11,9 @@ Use this for any spec that `tickmarkr compile` accepts. It is SDD-agnostic: use
 
 When working in a multi-agent terminal environment, decide your role before starting:
 
-- **Orchestrator:** your session was started to execute the mission. Rename your own tab/pane ORCHESTRATOR and run the loop below.
+- **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, spawn one child orchestration session with `--permission-mode bypassPermissions`, label its tab ORCHESTRATOR, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself.
+- **Primary session without an orchestrator:** rename your own tab `OVERSEER · <version>` and your agent `overseer`, spawn one child orchestration session with `--permission-mode bypassPermissions`, 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.
 
 Outside a multi-agent terminal environment, run the loop directly.
 
@@ -50,6 +50,11 @@ Use one of:
 
 After sending, **confirm delivery** by reading the target pane and verifying the message landed (input empty, agent status `working`, or notification acknowledged). Never report "briefed" or "relayed" without read-back confirmation.
 
+## Stand-down (mission end and retirement)
+
+- **Orchestrator, on terminal state** (green, failed, or parked), after the record commit and operator notification: stop every monitor and background task you started, print one final stand-down line, and leave NOTHING queued in your input box. A finished session with an armed watcher or pre-filled input is a loaded gun — a retired v1.40 orchestrator sat idle with "merge … tag, publish" unsent in its input; one stray Enter would have shipped a duplicate release.
+- **Supervisor, when a mission completes** (and always before spawning the next orchestrator): verify the orchestrator stood down, then close its tab. The journal, execution record, OBS ledger, and memory hold the story; pane scrollback is disposable. Never leave a retired agent idle with watchers armed.
+
 ## The loop
 
 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.
@@ -57,4 +62,4 @@ After sending, **confirm delivery** by reading the target pane and verifying the
 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 event rather than repeatedly polling agents. 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 AND the tip verify is not "failed". 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** — write `tickmarkr report <runId> --md` beside the source spec and commit the execution record when the repository tracks those records.
+6. **Record** — write `tickmarkr report <runId> --md` beside the source spec and commit the execution record when the repository tracks those records. Then [stand down](#stand-down-mission-end-and-retirement).