tickmarkr 1.90.1 → 1.90.3

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

@@ -9,31 +9,35 @@ export type DoctorOpts = {
     catalog?: CatalogReadResult;
     catalogNow?: () => Date;
 };
+export declare function runnerIgnoreFinding(cwd: string): {
+    verdict: "pass" | "warn";
+    detail: string;
+} | undefined;
 /**
- * Q122s (TRIAL T-OBS-3): tickmarkr provisions run worktrees INSIDE the repo
- * (.tickmarkr/worktrees.noindex/). A target repo whose test runner collects with
- * repo-wide globs (jest's default `**​/__tests__/**` shape, vitest's default include)
- * scans every suite once per live worktree — duplicate-suite interference red the
- * baseline AND tip-verify on SentioQ's first external run, a class invisible to
- * dogfooding (this repo's own includes are rooted at tests/).
- *
- * Q130s (TRIAL T-OBS-6): the ignore must be <rootDir>-anchored. Jest
- * testPathIgnorePatterns are REGEXES matched against the ABSOLUTE test path; an
- * unanchored "/.tickmarkr/" also matches every suite INSIDE a worktree provisioned at
- * <repo>/.tickmarkr/worktrees.noindex/… — jest discovers nothing there and the whole
- * gate battery fails closed (SentioQ run 2: 10 dispatches, 0 merges). Anchored
- * patterns resolve <rootDir> to the worktree itself and stay inert. Vitest
- * include/exclude globs match root-relative paths, so they cannot self-match, but the
- * prescribed shape is root-anchored anyway.
+ * Q134s (doctor --fix): the WRITE half of Q122s/Q130s. Doctor's advisory row cost two
+ * repos a hand-edit (SentioQ run 2 paid a whole run first); --fix applies the ignore
+ * where a safe textual edit exists and refuses loudly otherwise.
  *
- * Text-level heuristic, advisory only — never enters health/doctor.json or routing.
- * ponytail: ceilings — comments are stripped before judgment, but an include built
- * from variables is still judged by its literal text, and a pattern string containing
- * `//` would be truncated by the line-comment strip. Each costs one advisory row,
- * nothing more.
+ * Safety contract: only three write shapes, each verified by re-running
+ * runnerIgnoreFinding afterward — a write that does not turn the row green is
+ * REVERTED and reported as manual. Never touches package.json (jest block → manual).
+ * ponytail: text-level edits, same ceilings as the finding; the verify-then-revert
+ * loop is what makes them safe to ship.
  */
-export declare function runnerIgnoreFinding(cwd: string): {
-    verdict: "pass" | "warn";
+export declare function applyRunnerIgnore(cwd: string): {
+    action: "none" | "wrote" | "manual";
+    detail: string;
+};
+/**
+ * Q140s(b) / operator directive (D-OBS-10): the repo's package manager must resolve in
+ * THIS process's environment — the same class of environment the daemon spawns gates
+ * into. Dossier run 1: pnpm lived only in the operator's interactive PATH; every gate
+ * died on `Unable to find package manager binary` / `spawnSync pnpm ENOENT`, the reds
+ * were baseline-forgiven, and no suite ever ran. A which(1)-grade check at doctor time
+ * turns that into preflight information.
+ */
+export declare function packageManagerFinding(cwd: string, probe?: (pm: string) => boolean): {
+    verdict: "pass" | "fail";
     detail: string;
 } | undefined;
 export declare function doctor(_argv: string[], cwd?: string, adapters?: WorkerAdapter[], opts?: DoctorOpts): Promise<string>;

package/dist/cli/commands/doctor.js

@@ -1,6 +1,8 @@
 import { writeFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
+import { detectPackageManager } from "../../gates/baseline.js";
 import { allAdapters, binaryShadowWarnings, detectCandidateClis, flagDriftWarnings, modelAliasExclusions, modelAliasLine, probeAll, probeModels, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
 import { CLAUDE_ALIAS_IDENTITY_STAMPS, claudeCode, resolveClaudeAliasIdentity } from "../../adapters/claude-code.js";
 import { BANNER, dim, fail, kvRow, legend, ok, rule, statusRow, title } from "../../brand.js";
@@ -14,47 +16,49 @@ import { readCachedCatalog, refreshCatalogCommand } from "../../adapters/catalog
 const visual = () => process.stdout.isTTY === true && process.env.NO_COLOR === undefined;
 const alignedStatusRow = (verdict, key, value) => `  ${statusRow(verdict, kvRow(key, value).slice(2))}`;
 const attentionRow = (text) => `  ${statusRow("warn", text)}`;
-/**
- * Q122s (TRIAL T-OBS-3): tickmarkr provisions run worktrees INSIDE the repo
- * (.tickmarkr/worktrees.noindex/). A target repo whose test runner collects with
- * repo-wide globs (jest's default `**​/__tests__/**` shape, vitest's default include)
- * scans every suite once per live worktree — duplicate-suite interference red the
- * baseline AND tip-verify on SentioQ's first external run, a class invisible to
- * dogfooding (this repo's own includes are rooted at tests/).
- *
- * Q130s (TRIAL T-OBS-6): the ignore must be <rootDir>-anchored. Jest
- * testPathIgnorePatterns are REGEXES matched against the ABSOLUTE test path; an
- * unanchored "/.tickmarkr/" also matches every suite INSIDE a worktree provisioned at
- * <repo>/.tickmarkr/worktrees.noindex/… — jest discovers nothing there and the whole
- * gate battery fails closed (SentioQ run 2: 10 dispatches, 0 merges). Anchored
- * patterns resolve <rootDir> to the worktree itself and stay inert. Vitest
- * include/exclude globs match root-relative paths, so they cannot self-match, but the
- * prescribed shape is root-anchored anyway.
- *
- * Text-level heuristic, advisory only — never enters health/doctor.json or routing.
- * ponytail: ceilings — comments are stripped before judgment, but an include built
- * from variables is still judged by its literal text, and a pattern string containing
- * `//` would be truncated by the line-comment strip. Each costs one advisory row,
- * nothing more.
- */
-export function runnerIgnoreFinding(cwd) {
+function detectRunner(cwd) {
     const readIf = (p) => (existsSync(join(cwd, p)) ? readFileSync(join(cwd, p), "utf8") : "");
-    const pkgText = readIf("package.json");
     let pkg = {};
     try {
-        pkg = JSON.parse(pkgText || "{}");
+        pkg = JSON.parse(readIf("package.json") || "{}");
     }
     catch { /* unparseable manifest: judge config files alone */ }
     const jestConfig = ["jest.config.js", "jest.config.cjs", "jest.config.mjs", "jest.config.ts", "jest.config.json"].find((p) => existsSync(join(cwd, p)));
     const vitestConfig = ["vitest.config.ts", "vitest.config.js", "vitest.config.mts", "vitest.config.mjs", "vitest.config.cts"].find((p) => existsSync(join(cwd, p)));
     const testScript = pkg.scripts?.test ?? "";
-    const isJest = jestConfig !== undefined || pkg.jest !== undefined || /\bjest\b/.test(testScript);
-    const isVitest = !isJest && (vitestConfig !== undefined || /\bvitest\b/.test(testScript));
-    if (!isJest && !isVitest)
+    if (jestConfig !== undefined || pkg.jest !== undefined || /\bjest\b/.test(testScript)) {
+        return { kind: "jest", configPath: jestConfig, pkgJestBlock: pkg.jest !== undefined };
+    }
+    if (vitestConfig !== undefined || /\bvitest\b/.test(testScript)) {
+        return { kind: "vitest", configPath: vitestConfig, pkgJestBlock: false };
+    }
+    return undefined;
+}
+export function runnerIgnoreFinding(cwd) {
+    const readIf = (p) => (existsSync(join(cwd, p)) ? readFileSync(join(cwd, p), "utf8") : "");
+    const runner = detectRunner(cwd);
+    if (!runner)
         return undefined;
-    // Comments are stripped before judgment: a commented-out ignore must not false-pass,
-    // and a prose comment mentioning .tickmarkr must not false-warn the anchor probe.
-    const stripComments = (s) => s.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/[^\n]*/g, "");
+    const isJest = runner.kind === "jest";
+    const jestConfig = isJest ? runner.configPath : undefined;
+    const vitestConfig = isJest ? undefined : runner.configPath;
+    let pkg = {};
+    try {
+        pkg = JSON.parse(readIf("package.json") || "{}");
+    }
+    catch { /* judged above */ }
+    // Comment LINES are stripped before judgment: a commented-out ignore must not
+    // false-pass, and a prose comment mentioning .tickmarkr must not false-warn the
+    // anchor probe. Stripping is LINE-granular on purpose: in-line regex stripping ate
+    // glob strings — `'**/*.d.ts'` contains `/*` and later globs contain `*/`, so a
+    // naive block-comment regex deleted the middle of real configs and false-PASSED a
+    // repo-wide vitest include (caught on Intl-Dossier's config; shipped briefly in
+    // 1.90.1). Trailing same-line comments survive — acceptable: they can only make the
+    // probe more conservative on lines that also carry code.
+    const stripComments = (s) => s.split("\n").filter((l) => {
+        const t = l.trimStart();
+        return !(t.startsWith("//") || t.startsWith("/*") || t.startsWith("*"));
+    }).join("\n");
     const configText = stripComments(isJest
         ? `${jestConfig ? readIf(jestConfig) : ""}${pkg.jest ? JSON.stringify(pkg.jest) : ""}`
         : vitestConfig ? readIf(vitestConfig) : "");
@@ -85,6 +89,87 @@ export function runnerIgnoreFinding(cwd) {
         detail: `${isJest ? "jest" : "vitest"} collects repo-wide and will scan .tickmarkr/ run worktrees (duplicate suites, false reds) — ${remedy}`,
     };
 }
+/**
+ * Q134s (doctor --fix): the WRITE half of Q122s/Q130s. Doctor's advisory row cost two
+ * repos a hand-edit (SentioQ run 2 paid a whole run first); --fix applies the ignore
+ * where a safe textual edit exists and refuses loudly otherwise.
+ *
+ * Safety contract: only three write shapes, each verified by re-running
+ * runnerIgnoreFinding afterward — a write that does not turn the row green is
+ * REVERTED and reported as manual. Never touches package.json (jest block → manual).
+ * ponytail: text-level edits, same ceilings as the finding; the verify-then-revert
+ * loop is what makes them safe to ship.
+ */
+export function applyRunnerIgnore(cwd) {
+    const finding = runnerIgnoreFinding(cwd);
+    if (!finding)
+        return { action: "none", detail: "no recognized test runner" };
+    if (finding.verdict === "pass")
+        return { action: "none", detail: finding.detail };
+    const runner = detectRunner(cwd);
+    if (!runner?.configPath) {
+        // package.json jest block, or a runner detected only via the test script: hand edit.
+        return { action: "manual", detail: finding.detail };
+    }
+    const file = join(cwd, runner.configPath);
+    const original = readFileSync(file, "utf8");
+    let text = original;
+    if (runner.kind === "jest") {
+        // 1) Replace unanchored poison entries in place (the SentioQ run-2 shape).
+        text = text.replace(/(["'])\/?\.tickmarkr\/?\1/g, '"<rootDir>/\\\\.tickmarkr/"');
+        if (text === original && !/\.tickmarkr/.test(text)) {
+            const arr = /testPathIgnorePatterns(["']?)\s*:\s*\[/;
+            if (arr.test(text)) {
+                // 2) Existing ignore array: prepend the anchored entry.
+                text = text.replace(arr, (m) => `${m}"<rootDir>/\\\\.tickmarkr/", `);
+                if (runner.configPath.endsWith(".json"))
+                    text = text.replace(/,(\s*)\]/g, "$1]");
+            }
+            else {
+                // 3) No array: add the property, preserving jest's default /node_modules/ ignore.
+                const anchor = /(module\.exports\s*=\s*\{|export\s+default\s+\{|export\s+default\s+defineConfig\(\{)/g;
+                if ((text.match(anchor) ?? []).length === 1) {
+                    text = text.replace(anchor, (m) => `${m}\n  testPathIgnorePatterns: ["/node_modules/", "<rootDir>/\\\\.tickmarkr/"],`);
+                }
+            }
+        }
+    }
+    else if (!/\.tickmarkr/.test(text)) {
+        // vitest: add the glob to every exclude array — test.exclude is the target;
+        // coverage.exclude gaining it is correct behavior, not collateral.
+        const arr = /exclude\s*:\s*\[/g;
+        if (arr.test(text))
+            text = text.replace(arr, (m) => `${m}'.tickmarkr/**', `);
+    }
+    if (text === original)
+        return { action: "manual", detail: finding.detail };
+    writeFileSync(file, text);
+    const after = runnerIgnoreFinding(cwd);
+    if (after?.verdict === "pass") {
+        return { action: "wrote", detail: `wrote ${runner.configPath} — ${after.detail}` };
+    }
+    writeFileSync(file, original); // verify failed: never leave a half-fix behind
+    return { action: "manual", detail: finding.detail };
+}
+/**
+ * Q140s(b) / operator directive (D-OBS-10): the repo's package manager must resolve in
+ * THIS process's environment — the same class of environment the daemon spawns gates
+ * into. Dossier run 1: pnpm lived only in the operator's interactive PATH; every gate
+ * died on `Unable to find package manager binary` / `spawnSync pnpm ENOENT`, the reds
+ * were baseline-forgiven, and no suite ever ran. A which(1)-grade check at doctor time
+ * turns that into preflight information.
+ */
+export function packageManagerFinding(cwd, probe = (pm) => spawnSync(pm, ["--version"], { stdio: "ignore", shell: false }).error === undefined) {
+    if (!existsSync(join(cwd, "package.json")))
+        return undefined;
+    const pm = detectPackageManager(cwd);
+    if (probe(pm))
+        return { verdict: "pass", detail: `${pm} (detected) resolves in this environment` };
+    return {
+        verdict: "fail",
+        detail: `repo uses ${pm} but the binary does not resolve in this environment — every auto-detected gate command will die before running any suite (fix: corepack enable, or install ${pm} on the daemon's PATH)`,
+    };
+}
 export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(), opts = {}) {
     if (_argv.length === 1 && _argv[0] === "--refresh-catalog") {
         const refreshed = await refreshCatalogCommand({ repoRoot: cwd, now: opts.catalogNow });
@@ -163,9 +248,23 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     const herdr = HerdrDriver.available();
     rows.push(alignedStatusRow(herdr ? "pass" : "fail", "herdr", herdr ? "driver available (HERDR_ENV=1)" : "not detected — subprocess driver will be used"));
     // Q122s: the target repo's runner must not scan tickmarkr's own worktrees (advisory row).
+    // Q134s: `doctor --fix` writes the ignore when a safe edit exists (verified, else reverted).
     const runnerIgnore = runnerIgnoreFinding(cwd);
-    if (runnerIgnore)
-        rows.push(alignedStatusRow(runnerIgnore.verdict, "test-runner", runnerIgnore.detail));
+    if (runnerIgnore) {
+        if (_argv.includes("--fix") && runnerIgnore.verdict === "warn") {
+            const fixed = applyRunnerIgnore(cwd);
+            rows.push(fixed.action === "wrote"
+                ? alignedStatusRow("pass", "test-runner", fixed.detail)
+                : alignedStatusRow("warn", "test-runner", `--fix could not edit safely — apply by hand: ${fixed.detail}`));
+        }
+        else {
+            rows.push(alignedStatusRow(runnerIgnore.verdict, "test-runner", runnerIgnore.detail));
+        }
+    }
+    // Q140s(b): the repo's package manager must resolve where gates spawn (D-OBS-10).
+    const pmRow = packageManagerFinding(cwd);
+    if (pmRow)
+        rows.push(alignedStatusRow(pmRow.verdict, "package-manager", pmRow.detail));
     // v1.22 T5: workspace-trust pre-flight — per installed adapter: trusted | seeded | action-required | n/a.
     // action-required names the exact one-time command (or dialog) the operator must run once.
     rows.push(legend("workspace trust:"));

package/dist/cli/index.d.ts

@@ -5,7 +5,7 @@ export type CommandResult = string | {
 };
 export type CommandMap = Record<string, (argv: string[]) => Promise<CommandResult>>;
 export declare const COMMANDS: CommandMap;
-export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  eval          run checked-in fixtures against every channel in isolated temp repos\n  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\n  verify        run the gate battery standalone against merge-base(--base, HEAD)..HEAD \u2014 no daemon, one verdict (--base main --criteria <file> | --task <id> [--files <glob>] [--author adapter:model] [--no-review] [--json])\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  release a park (--uphold sides with the reviewer and funds a fixed attempt; --by <name> --reason <text>); takes effect on resume";
+export declare const USAGE = "tickmarkr \u2014 spec-driven orchestration harness for AI coding agents\nusage: tickmarkr <command>\n  init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs\n  doctor        re-probe adapters, herdr, auth; print capability matrix (--fix writes the test-runner ignore when a safe edit exists)\n  fleet         interactive fleet editor (fleet --print for CI drift checks)\n  compile <src> spec \u2192 .tickmarkr/graph.json (fails without acceptance criteria)\n  scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)\n  plan          dry-run routing table + cost estimate + floor lints\n  eval          run checked-in fixtures against every channel in isolated temp repos\n  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\n  verify        run the gate battery standalone against merge-base(--base, HEAD)..HEAD \u2014 no daemon, one verdict (--base main --criteria <file> | --task <id> [--files <glob>] [--author adapter:model] [--no-review] [--json])\n  resume <id>   continue a run from its journal\n  report <id>   cost/quality report (--md for committable execution record)\n  profile       show learned routing profile (profile reset = forget history via cursor, keeps telemetry)\n  ui            open the Fleet Studio TUI (full-screen tabbed cockpit)\n  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  release a park (--uphold sides with the reviewer and funds a fixed attempt; --by <name> --reason <text>); takes effect on resume";
 export declare function dispatch(cmd: string | undefined, argv: string[], commands?: CommandMap): Promise<{
     out: string;
     code: number;

package/dist/cli/index.js

@@ -28,7 +28,7 @@ import { BANNER } from "../brand.js";
 export const USAGE = `tickmarkr — spec-driven orchestration harness for AI coding agents
 usage: tickmarkr <command>
   init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs
-  doctor        re-probe adapters, herdr, auth; print capability matrix
+  doctor        re-probe adapters, herdr, auth; print capability matrix (--fix writes the test-runner ignore when a safe edit exists)
   fleet         interactive fleet editor (fleet --print for CI drift checks)
   compile <src> spec → .tickmarkr/graph.json (fails without acceptance criteria)
   scope <intent> draft a compiled native spec beside an answered intent (--force to overwrite)

package/dist/gates/baseline.d.ts

@@ -37,6 +37,15 @@ export declare function freshFailures(entry: BaselineCommand | undefined, raw: s
     failing: string[];
     unreadable: boolean;
 };
+export type PackageManager = "npm" | "pnpm" | "yarn" | "bun";
+/**
+ * Operator directive 2026-08-12 (D-OBS-10): tickmarkr is package-manager agnostic.
+ * The `packageManager` field is authoritative (corepack's own contract); lockfiles
+ * break ties; npm is only the LAST resort. Dossier exhibit: auto-detected
+ * `npm run -s test` on a repo whose engines said `"npm": "please-use-pnpm"` — turbo
+ * then failed to resolve pnpm and every gate died on environment, not code.
+ */
+export declare function detectPackageManager(repoRoot: string): PackageManager;
 export declare function detectGateCommands(repoRoot: string, cfg: TickmarkrConfig): Record<string, string>;
 /**
  * The ceiling a battery runs under: whichever is larger of the shipped constant and the slack applied

package/dist/gates/baseline.js

@@ -123,17 +123,50 @@ export function freshFailures(entry, raw) {
     const fresh = current.filter((f) => !known.has(f) && (!FAIL_ANCHOR_RE.test(f) || f.startsWith("FAIL ")));
     return { failing: fresh.filter((f) => f !== UNRECOGNIZED_FAILURE), unreadable: current.includes(UNRECOGNIZED_FAILURE) };
 }
+/**
+ * Operator directive 2026-08-12 (D-OBS-10): tickmarkr is package-manager agnostic.
+ * The `packageManager` field is authoritative (corepack's own contract); lockfiles
+ * break ties; npm is only the LAST resort. Dossier exhibit: auto-detected
+ * `npm run -s test` on a repo whose engines said `"npm": "please-use-pnpm"` — turbo
+ * then failed to resolve pnpm and every gate died on environment, not code.
+ */
+export function detectPackageManager(repoRoot) {
+    const pkgPath = join(repoRoot, "package.json");
+    try {
+        const pm = JSON.parse(readFileSync(pkgPath, "utf8")).packageManager;
+        const name = pm?.split("@")[0];
+        if (name === "pnpm" || name === "yarn" || name === "bun" || name === "npm")
+            return name;
+    }
+    catch { /* no or unparseable manifest: lockfiles decide */ }
+    if (existsSync(join(repoRoot, "pnpm-lock.yaml")))
+        return "pnpm";
+    if (existsSync(join(repoRoot, "yarn.lock")))
+        return "yarn";
+    if (existsSync(join(repoRoot, "bun.lock")) || existsSync(join(repoRoot, "bun.lockb")))
+        return "bun";
+    return "npm";
+}
+// Silent where the manager supports it everywhere (npm -s; pnpm's global -s), bare
+// where a flag would break a major version (yarn berry rejects run -s; bun is quiet).
+const RUN_PREFIX = {
+    npm: "npm run -s",
+    pnpm: "pnpm -s run",
+    yarn: "yarn run",
+    bun: "bun run",
+};
 export function detectGateCommands(repoRoot, cfg) {
     const out = {};
     const pkgPath = join(repoRoot, "package.json");
     const scripts = existsSync(pkgPath)
         ? (JSON.parse(readFileSync(pkgPath, "utf8")).scripts ?? {})
         : {};
+    const runPrefix = RUN_PREFIX[detectPackageManager(repoRoot)];
     for (const name of ["build", "test", "lint"]) {
         if (cfg.gates[name])
             out[name] = cfg.gates[name];
         else if (scripts[name])
-            out[name] = `npm run -s ${name}`;
+            out[name] = `${runPrefix} ${name}`;
     }
     return out;
 }

package/package.json

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