tickmarkr 1.40.0 → 1.42.0

package/README.md

@@ -1,4 +1,9 @@
-<p align="center"><img src="assets/wordmark-dark.png" alt="tickmarkr" width="640"></p>
+```
+              ▄▄████
+          ▄▄████▀▀
+████▄▄▄▄████▀▀     tickmarkr
+  ▀▀████▀▀         spec in, verified work out.
+```
 
 # tickmarkr
 

package/dist/brand.d.ts

@@ -1,2 +1,4 @@
 export declare const BANNER: string;
+/** ANSI-stripped, trailing-space-trimmed twin of BANNER — README hero and other plain surfaces. */
+export declare const PLAIN_BANNER: string;
 export declare function bannerShell(): string;

package/dist/brand.js

@@ -9,6 +9,8 @@ export const BANNER = [
     `  ${g(35, "▀▀████▀▀")}         spec in, verified work out.`,
     "",
 ].join("\n");
+/** ANSI-stripped, trailing-space-trimmed twin of BANNER — README hero and other plain surfaces. */
+export const PLAIN_BANNER = BANNER.replace(/\x1b\[[0-9;]*m/g, "").replace(/[ \t]+$/gm, "");
 // Shell one-liner that prints the banner inside a pane before a gate command runs. ESC bytes are
 // carried as printf %b escapes (never raw control bytes in a command string crossing the herdr socket).
 export function bannerShell() {

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

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

package/dist/cli/commands/doctor.js

@@ -1,6 +1,7 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { allAdapters, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
+import { BANNER } from "../../brand.js";
 import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
 import { modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
 import { DEFAULT_CONFIG, loadConfig, overlayPreferShapes } from "../../config/config.js";
@@ -30,7 +31,7 @@ function stylize(out) {
             .replace(/\bunauthed:/, color("unauthed:", 33));
     }).join("\n");
 }
-export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters()) {
+export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(), opts = {}) {
     const cfg = loadConfig(cwd);
     // stderr, live: auth probes are real LLM calls (up to 30s per configured model) and the CLI
     // otherwise prints nothing until the end — silence here reads as a hang (v1.33.1)
@@ -158,5 +159,6 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     const modelSummary = modelStatus.length || preferStatus.length
         ? `\nmodel status:\n${[...modelStatus, ...preferStatus].join("\n")}`
         : "";
-    return stylize(`tickmarkr doctor — capability matrix:\n${rows.join("\n")}${modelSummary}${drift}\nwrote ${stateDirName(cwd)}/doctor.json`);
+    const body = stylize(`tickmarkr doctor — capability matrix:\n${rows.join("\n")}${modelSummary}${drift}\nwrote ${stateDirName(cwd)}/doctor.json`);
+    return opts.banner !== false && visual() ? BANNER + body : body;
 }

package/dist/cli/commands/init.js

@@ -5,8 +5,10 @@ import { parseArgs } from "node:util";
 import { allAdapters, formatDoctorAgeForInit, formatDoctorReport, initDoctorReuse } from "../../adapters/registry.js";
 import { configTemplate, DEFAULT_CONFIG, globalConfigDir, loadConfig } from "../../config/config.js";
 import { LEGACY_PREFIX, specTemplate } from "../../compile/native.js";
+import { BANNER } from "../../brand.js";
 import { tickmarkrDir } from "../../graph/graph.js";
 import { doctor } from "./doctor.js";
+const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 const AGENT_SKILLS = ["tickmarkr-loop", "tickmarkr-auto"];
 const DOCS_BEGIN = "<!-- tickmarkr:agent-docs begin -->";
 const DOCS_END = "<!-- tickmarkr:agent-docs end -->";
@@ -138,6 +140,13 @@ async function runInitWizard(cwd) {
     }
 }
 export async function init(argv, cwd = process.cwd()) {
+    let bannerEmitted = false;
+    const emitBanner = () => {
+        if (visual() && !bannerEmitted) {
+            bannerEmitted = true;
+            process.stdout.write(BANNER);
+        }
+    };
     const { values } = parseArgs({
         args: argv,
         options: {
@@ -183,10 +192,11 @@ export async function init(argv, cwd = process.cwd()) {
     const { reuse, ageMs, health } = initDoctorReuse(cwd, fresh);
     const doc = reuse && health && ageMs !== null
         ? `using probe results from ${formatDoctorAgeForInit(ageMs)} ago — run tickmarkr doctor to refresh (or init --fresh)\n${formatDoctorReport(cwd, loadConfig(cwd), health, allAdapters(), { wrote: false })}`
-        : await doctor([], cwd);
+        : await doctor([], cwd, undefined, { banner: false });
     const interactive = process.stdin.isTTY === true && process.stdout.isTTY === true && !(values.yes ?? false);
     if (!repoConfigExists) {
         if (interactive) {
+            emitBanner();
             const wizard = await runInitWizard(cwd);
             writeFileSync(repoConfigPath, configTemplate(wizard.overlay));
             notes.push(`wrote ${repoConfigPath}`);
@@ -200,5 +210,8 @@ export async function init(argv, cwd = process.cwd()) {
     }
     if (values.agent)
         await installAgentFiles(cwd, values.force ?? false, values.docs ?? false, notes);
-    return `${notes.join("\n")}\n${doc}\nnext: edit tickmarkr.spec.md, then tickmarkr compile tickmarkr.spec.md && tickmarkr plan && tickmarkr run`;
+    const body = `${notes.join("\n")}\n${doc}\nnext: edit tickmarkr.spec.md, then tickmarkr compile tickmarkr.spec.md && tickmarkr plan && tickmarkr run`;
+    if (visual() && !bannerEmitted)
+        return BANNER + body;
+    return body;
 }

package/dist/drivers/herdr.js

@@ -202,11 +202,15 @@ export class HerdrDriver {
         const token = newest ? canonicalizeLegacyName(newest.name, "").taskId : undefined;
         const glyph = newest ? await this.glyphFor(newest) : "";
         const label = token ? `${entry.label} · ${token}${glyph}` : entry.label;
+        const cmd = `tab rename ${shq(entry.tabId)} ${shq(label)}`;
+        const ok = async () => (await this.herdr(cmd)).code === 0;
+        if (await ok() || await ok())
+            return;
         try {
-            await this.herdr(`tab rename ${shq(entry.tabId)} ${shq(label)}`);
+            await this.notify(`tickmarkr tab relabel failed: ${entry.tabId} → ${label}`);
         }
         catch {
-            /* cosmetic only — a relabel failure never blocks membership or teardown (v1.18 invariant) */
+            /* OBS-45: cosmetic only — a relabel failure never blocks membership or teardown (v1.18 invariant) */
         }
     }
     // VIS-13: at most one glyph on the hot token. ✋ wins — the driver observes the member blocked live

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,9 +1,21 @@
 {
   "name": "tickmarkr",
-  "version": "1.40.0",
+  "version": "1.42.0",
   "description": "Spec in, verified work out.",
   "type": "module",
   "license": "MIT",
+  "keywords": [
+    "ai",
+    "agents",
+    "orchestration",
+    "automation",
+    "cli"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/alzahrani-khalid/tickmarkr.git"
+  },
+  "homepage": "https://github.com/alzahrani-khalid/tickmarkr",
   "engines": {
     "node": ">=20"
   },

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).