tickmarkr 2.5.1 → 2.5.3

package/dist/adapters/qwen.d.ts

@@ -1,5 +1,6 @@
 import { type ClassifiedWorkerResult } from "./prompt.js";
 import { type WorkerAdapter } from "./types.js";
 export declare const QWEN_VERSION_IDENTITY: RegExp;
+export declare const QWEN_HARNESS_BANNER_ROWS: readonly ["⚠ SAFE MODE — all customizations disabled (hooks, extensions, skills, MCP servers, QWEN.md). Restart without --safe-mode to resume normal operation.", "Warning: running headless with --yolo / approval-mode=yolo and no sandbox. All tool calls (shell, write, edit) auto-execute at this process's privilege level. Enable a sandbox via --sandbox / QWEN_SANDBOX, or set QWEN_CODE_SUPPRESS_YOLO_WARNING=1 to silence this notice."];
 export declare function parseQwenResult(raw: string, nonce: string): ClassifiedWorkerResult;
 export declare const qwen: WorkerAdapter;

package/dist/adapters/qwen.js

@@ -3,6 +3,13 @@ import { parseWorkerResult } from "./prompt.js";
 import { channelsFromConfig, shq, } from "./types.js";
 export const QWEN_VERSION_IDENTITY = /^\d+\.\d+\.\d+/;
 const QWEN_SKIP_UPDATE = "QWEN_CODE_SKIP_UPDATE_CHECK_ONCE=true";
+// Verbatim stderr from tests/fixtures/qwen/safe-mode.stderr (qwen 0.21.15). These bytes are launch
+// harness, not evidence that a reviewer took a turn. Keep the declaration closed and row-shaped so
+// llm.ts can sweep partial terminal paints without a broad SAFE MODE/warning regex.
+export const QWEN_HARNESS_BANNER_ROWS = [
+    "⚠ SAFE MODE — all customizations disabled (hooks, extensions, skills, MCP servers, QWEN.md). Restart without --safe-mode to resume normal operation.",
+    "Warning: running headless with --yolo / approval-mode=yolo and no sandbox. All tool calls (shell, write, edit) auto-execute at this process's privilege level. Enable a sandbox via --sandbox / QWEN_SANDBOX, or set QWEN_CODE_SUPPRESS_YOLO_WARNING=1 to silence this notice.",
+];
 function decodeQwenEvents(events) {
     const text = [];
     let failed = false;
@@ -136,6 +143,7 @@ export const qwen = {
     channels: (cfg) => channelsFromConfig("qwen", cfg),
     hardcodedFlags: { binary: "qwen", flags: ["--safe-mode", "--approval-mode", "-m", "-o", "-p"] },
     headlessCommand: (promptFile, model) => `${QWEN_SKIP_UPDATE} qwen --safe-mode --approval-mode yolo -m ${shq(model)} -o json -p '' < ${shq(promptFile)}`,
+    harnessBannerRows: QWEN_HARNESS_BANNER_ROWS,
     // OBS-905: qwen has NO interactive form. The `-i "$(cat prompt)"` TUI launch put the whole prompt in
     // argv (the OBS-889 leak-and-census shape) and produced a rendered transcript the JSON decoder above
     // can never read — under the herdr driver every qwen task read "unparseable" and merged only by harvest.

package/dist/adapters/types.d.ts

@@ -171,6 +171,7 @@ export interface WorkerAdapter {
     probe(): Promise<AuthHealth>;
     channels(cfg: TickmarkrConfig): BillingChannel[];
     headlessCommand(promptFile: string, model: string): string;
+    harnessBannerRows?: readonly string[];
     interactiveCommand(promptFile: string, model: string): string | null;
     interactiveSeed?: InteractiveSeed;
     resumeCommand?(sessionId: string, promptFile: string, model: string): string;

package/dist/cli/commands/approve.js

@@ -114,7 +114,7 @@ export function approvalRunOwner(cwd, runId) {
 /** The one sentence that says who enacts this release and what it buys. */
 export function approvalEnactment(token, run) {
     if (run.live) {
-        return `the live daemon enacts this at its next task boundary — it will ${APPROVAL_ENACTS[token]}`;
+        return `the live daemon enacts this at its next task boundary — it will ${APPROVAL_ENACTS[token]}, including in the approval window or by cancelling an in-progress tip verify`;
     }
     if (run.blockingRunId) {
         return `release recorded; live run \`${run.blockingRunId}\` holds the repository lock, so resume \`${run.runId}\` after it ends to ${APPROVAL_ENACTS[token]}`;

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

@@ -8,6 +8,12 @@ import { type VitestListResult } from "../../gates/acceptance.js";
  *  concatenation and publishes no index, so the release listing is the only enumerable surface. */
 export declare const LIVEBENCH_RELEASES_URL = "https://api.github.com/repos/LiveBench/livebench.github.io/contents/public";
 export declare const LIVEBENCH_TABLE_MAX_AGE_DAYS = 90;
+type ReviewDemotionSummary = {
+    reviewer: string;
+    count: number;
+    causes: Record<string, number>;
+};
+export declare function recentReviewDemotions(cwd: string, lastRuns?: number): ReviewDemotionSummary[];
 export type DoctorOpts = {
     banner?: boolean;
     kimiTurnProbe?: (cwd: string) => Promise<KimiDoctorTurnResult>;
@@ -162,6 +168,7 @@ export declare function doctorProbePreflight(cwd?: string, cfg?: {
     gates: {
         build?: string | undefined;
         test?: string | undefined;
+        tipTest?: string | undefined;
         lint?: string | undefined;
         diffCap?: number | undefined;
         byShape?: Partial<Record<"plan" | "spec" | "implement" | "tests" | "docs" | "migration" | "ui" | "refactor" | "chore", {
@@ -278,6 +285,7 @@ export declare function cachedDoctorDiagnostics(cwd?: string, adapters?: WorkerA
     gates: {
         build?: string | undefined;
         test?: string | undefined;
+        tipTest?: string | undefined;
         lint?: string | undefined;
         diffCap?: number | undefined;
         byShape?: Partial<Record<"plan" | "spec" | "implement" | "tests" | "docs" | "migration" | "ui" | "refactor" | "chore", {

package/dist/cli/commands/doctor.js

@@ -1,6 +1,6 @@
 import { writeFileSync } from "node:fs";
 import { spawnSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { detectPackageManager, turboContinueFindings } from "../../gates/baseline.js";
 import { version } from "./version.js";
@@ -26,6 +26,46 @@ const initialFetch = globalThis.fetch;
 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)}`;
+// Use the routing profile's established 50-run recency horizon without importing journal machinery
+// into doctor. Torn/malformed rows are ignored one at a time: diagnostics must survive a killed write.
+export function recentReviewDemotions(cwd, lastRuns = 50) {
+    const runs = join(cwd, stateDirName(cwd), "runs");
+    if (!existsSync(runs))
+        return [];
+    const grouped = new Map();
+    const ids = readdirSync(runs, { withFileTypes: true })
+        .filter((entry) => entry.isDirectory() && entry.name.startsWith("run-")
+        && existsSync(join(runs, entry.name, "journal.jsonl")))
+        .map((entry) => entry.name).sort().slice(-lastRuns);
+    for (const id of ids) {
+        const lines = readFileSync(join(runs, id, "journal.jsonl"), "utf8").split("\n");
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            let row;
+            try {
+                row = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!row || typeof row !== "object")
+                continue;
+            const event = row;
+            if (event.event !== "review-pool-demotion" || !event.data || typeof event.data !== "object")
+                continue;
+            const data = event.data;
+            if (typeof data.reviewer !== "string" || !data.reviewer.trim())
+                continue;
+            const cause = typeof data.cause === "string" && data.cause.trim() ? data.cause : "unknown";
+            const summary = grouped.get(data.reviewer) ?? { reviewer: data.reviewer, count: 0, causes: {} };
+            summary.count++;
+            summary.causes[cause] = (summary.causes[cause] ?? 0) + 1;
+            grouped.set(data.reviewer, summary);
+        }
+    }
+    return [...grouped.values()].sort((a, b) => a.reviewer.localeCompare(b.reviewer));
+}
 const ORCA_HOOK_ADAPTERS = {
     claude: "claude-code",
     "claude-code": "claude-code",
@@ -581,6 +621,15 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         const healthy = h.installed && (a.id !== kimi.id || h.authed);
         return alignedStatusRow(healthy ? "pass" : "fail", a.id, state);
     });
+    const reviewDemotions = recentReviewDemotions(cwd);
+    if (reviewDemotions.length) {
+        rows.push(legend("recent review-seat demotions:"));
+        for (const demotion of reviewDemotions) {
+            const causes = Object.entries(demotion.causes)
+                .map(([cause, count]) => `${cause}${count === demotion.count ? "" : ` ×${count}`}`).join(", ");
+            rows.push(alignedStatusRow("warn", demotion.reviewer, `${demotion.count} review seat${demotion.count === 1 ? "" : "s"} demoted · cause ${causes}`));
+        }
+    }
     if (existsSync(graphPath(cwd))) {
         try {
             const graph = loadGraph(cwd);

package/dist/cli/commands/init.js

@@ -114,7 +114,7 @@ A run is green only when ALL of these hold: the run-end event exists in the jour
 
 ### Verified handoffs
 
-When relaying missions between agents, never use bare send-text (\`herdr agent send\` / pane send-text) — it omits Enter. Use \`herdr pane run <pane> "<message>"\` or \`herdr notification show "<message>"\`. Confirm delivery by reading the target pane afterward; never report "relayed" without read-back.
+When relaying missions between agents, never use bare send-text (\`herdr agent send\` / pane send-text) — it omits Enter. Use \`herdr pane run <pane> "<message>"\` or \`herdr notification show "<message>"\`. Confirm delivery by reading the TARGET composer afterward; if the sent text still sits unsubmitted after ~15 s, send-keys enter to that pane once and read again (OBS-975); never report "relayed" without read-back.
 
 ### Orient before you act — this block may be the ONLY guidance your host loaded
 

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

@@ -4,6 +4,11 @@ import { type JournalEvent } from "../../run/journal.js";
  *  it is a phase counter, while a phase-start CARRYING a gate is the gate start the rail draws. */
 export declare const TTY_NOISE_EVENTS: readonly ["worker-contact", "worker-status"];
 type RailTone = "pass" | "fail" | "attention" | "active" | "neutral";
+/** Approval-close lifecycle labels extend the established closed rail vocabulary. */
+export declare const APPROVAL_RAIL_ROWS: Record<string, {
+    label: string;
+    tone: RailTone;
+}>;
 /** Closed retained set: the short operator label and the row's default tone. Labels are the rail's
  *  own vocabulary — a raw journal event name is what this surface exists to stop printing. A `pass`
  *  or `ok` datum on the event overrides the default tone, so one gate row can read either way.

package/dist/cli/commands/run.js

@@ -33,6 +33,13 @@ const RAIL_TONES = {
     active: { glyph: GLYPHS.pointer, paint: LIVE.running },
     neutral: { glyph: GLYPHS.neutral, paint: LIVE.chrome },
 };
+/** Approval-close lifecycle labels extend the established closed rail vocabulary. */
+export const APPROVAL_RAIL_ROWS = {
+    "end-condition-held": { label: "close held", tone: "attention" },
+    "approval-window-start": { label: "approval window", tone: "attention" },
+    "approval-window-expired": { label: "approval window expired", tone: "attention" },
+    "tip-verify-cancelled": { label: "tip verify cancelled", tone: "attention" },
+};
 /** Closed retained set: the short operator label and the row's default tone. Labels are the rail's
  *  own vocabulary — a raw journal event name is what this surface exists to stop printing. A `pass`
  *  or `ok` datum on the event overrides the default tone, so one gate row can read either way.
@@ -116,6 +123,9 @@ export const RAIL_ROWS = {
     // gate starts and verdicts
     "phase-start": { label: "gate start", tone: "active" },
     "gate-result": { label: "gate", tone: "pass" },
+    "baseline-wait": { label: "baseline wait", tone: "active" },
+    "suite-budget": { label: "suite budget", tone: "attention" },
+    "gate-replayed": { label: "gate replayed", tone: "attention" },
     "gate-reused": { label: "gate reused", tone: "neutral" },
     "judge-retry": { label: "judge retry", tone: "attention" },
     "review-no-verdict": { label: "review unavailable", tone: "attention" },
@@ -307,6 +317,11 @@ const RAIL_PROJECTION = {
         ? `gated ${d.gatedCommit.slice(0, 12)}, tip ${d.branchTip.slice(0, 12)}`
         : undefined,
     "trust-auto-answer": (d) => typeof d.adapter === "string" ? `${d.adapter}${typeof d.phase === "string" ? ` ${d.phase}` : ""}` : undefined,
+    // SB-1: the census the ceiling released beside, and the budget the round ran under versus the one it
+    // would have had on an empty census — none of `{count, occupancyCap, conservativeCap}` is on the ladder
+    "suite-budget": (d) => typeof d.count === "number" && typeof d.conservativeCap === "number" && typeof d.occupancyCap === "number"
+        ? `beside ${d.count}, cap ${d.conservativeCap} not ${d.occupancyCap}`
+        : undefined,
 };
 // The row's text: the formatter's detail first, then the salient fields that detail could not carry.
 // Appending (never prefixing) keeps the operator's prose at the front of the row, so the clip a
@@ -333,7 +348,7 @@ const clipCells = (text, cells) => cells <= 0 ? "" : cellWidth(text) <= cells ?
 export function narrationRow(event, runId, columns = process.stdout.columns ?? 80) {
     if (TTY_NOISE_EVENTS.includes(event.event))
         return null;
-    const row = RAIL_ROWS[event.event];
+    const row = APPROVAL_RAIL_ROWS[event.event] ?? RAIL_ROWS[event.event];
     if (!row)
         return null;
     if (event.event === "phase-start" && typeof event.data.gate !== "string")

package/dist/cli/commands/status.js

@@ -825,23 +825,17 @@ const liveness = (events, daemon, now = Date.now()) => {
     const state = daemon.state === "alive" ? "alive" : ended ? "finished" : "dead";
     return `last event ${age} ago · daemon pid ${daemon.pid} ${state}${cause ? ` · ${cause}` : ""}`;
 };
-// Resume's shared comparator remains the fail-closed baseline. Status may additionally accept the
-// daemon's audited graph-rehash release, but only when its `from` names that baseline identity (or
-// null for an explicitly released legacy journal) and its `to` names the graph loaded now.
+// OBS-978: the one comparator resume, plan and the operator fold read decides the join — it already
+// audits the rehash chain. When it binds and the journal holds a graph-rehash, the newest row is the
+// audit that bound the loaded graph; rehashAt marks the facts recorded against a prior graph.
 const statusEngagement = (events, loadedHash) => {
-    const baseline = engagementComparable(events, loadedHash);
+    if (!engagementComparable(events, loadedHash).comparable)
+        return { comparable: false };
     for (let i = events.length - 1; i >= 0; i--) {
-        const event = events[i];
-        if (event.event !== "graph-rehash")
-            continue;
-        const auditsBaseline = baseline.comparable || baseline.reason === "mismatch"
-            ? event.data.from === baseline.recorded
-            : event.data.from === null;
-        return event.data.to === loadedHash && auditsBaseline
-            ? { comparable: true, rehashAt: i }
-            : { comparable: false };
+        if (events[i].event === "graph-rehash")
+            return { comparable: true, rehashAt: i };
     }
-    return { comparable: baseline.comparable };
+    return { comparable: true };
 };
 // The journal's own reader rule (src/run/journal.ts readJsonl), applied to bytes already in hand:
 // skip blanks, drop a line that will not parse (a torn trailing write after a crash), keep the rest.

package/dist/compile/native.js

@@ -847,6 +847,9 @@ acceptance is required on every task (a nested list of observable outcomes).
       hard value anywhere in the domain, the criterion asserts a universal that may be FALSE ABOUT THE
       WORLD — bound it or say where it stops holding, rather than demanding a value that does not exist.
 
+    - A millisecond ceiling in a test is a BUDGET for the SLOWEST RUNNER.
+      Any ceiling under one second must carry a SLOWEST-RUNNER note and a member that OVERRUNS it.
+
   PICK THE CRITERION FORM FROM WHO COULD BE WRONG:
     - When the WORKER could be wrong because it can choose the value, use "test:" and pin the exact
       literal it could otherwise choose; an example selected by its implementer proves only itself.

package/dist/compile/ownership.d.ts

@@ -13,6 +13,12 @@ export type OwnershipFinding = {
     taskIds: string[];
     corroboration?: OwnershipCorroboration;
     detail: string;
+} | {
+    code: "unowned-shape-oracle";
+    taskId: string;
+    source: string;
+    oracle: string;
+    detail: string;
 } | {
     code: "test-path-outside-allowlist";
     taskId: string;
@@ -26,6 +32,9 @@ export type OwnershipFinding = {
     path: string;
     detail: string;
 };
+export declare const SHAPE_ORACLES: readonly ["tests/run/narration.test.ts", "tests/cli/brand-surfaces.test.ts", "tests/run/notify-identity.test.ts", "tests/run/outcome-projections.test.ts", "tests/cockpit/setup.test.ts"];
+export declare const SHAPE_ORACLE_SOURCES: readonly ["src/run/daemon.ts", "src/cli/commands/run.ts"];
+export declare const SHAPE_ORACLE_MAP: Record<string, readonly string[]>;
 /**
  * Cross-task ownership evidence. Findings are data: this checker never throws or changes the graph;
  * the compile seam promotes only a corroborated unowned-test finding and reports every other shape.

package/dist/compile/ownership.js

@@ -2,6 +2,38 @@ import { readFileSync, readdirSync } from "node:fs";
 import { basename, extname, join, posix } from "node:path";
 import { filesGlob } from "../graph/files-glob.js";
 import { collateralHits } from "./collateral.js";
+export const SHAPE_ORACLES = [
+    "tests/run/narration.test.ts",
+    "tests/cli/brand-surfaces.test.ts",
+    "tests/run/notify-identity.test.ts",
+    "tests/run/outcome-projections.test.ts",
+    "tests/cockpit/setup.test.ts",
+];
+export const SHAPE_ORACLE_SOURCES = [
+    "src/run/daemon.ts",
+    "src/cli/commands/run.ts",
+];
+export const SHAPE_ORACLE_MAP = {
+    "src/run/daemon.ts": SHAPE_ORACLES,
+    "src/cli/commands/run.ts": SHAPE_ORACLES,
+};
+// Anchored-glob only: a files[] entry touches a mapped source when it names the source (or its
+// extensionless stem) exactly, or when its glob's literal head — everything before the first
+// wildcard — is the stem plus a literal dot, i.e. the wildcard only ever spans the extension
+// ("src/run/daemon.*"). A broad multi-file glob like "src/**" that merely happens to cover the
+// source is an unrelated task casting a wide net, not one touching daemon narration — that
+// distinction is what broke every fixture using tests/fixtures/sample.prd.md's files: src/** task.
+function touchesSource(files, source) {
+    const stem = source.replace(/\.(?:[cm]?[jt]sx?)$/, "");
+    return files.some((entry) => {
+        if (entry === source || entry === stem)
+            return true;
+        const special = entry.search(/[*?{[]/);
+        // Leg-2 v2.5.3: the anchored head is necessary, not sufficient — the pattern must also MATCH the
+        // source under the shared matcher, or "src/run/daemon.{js,jsx}" (never daemon.ts) would count as a touch.
+        return special !== -1 && entry.slice(0, special) === `${stem}.` && filesGlob([entry])(source);
+    });
+}
 const normalize = (path) => path.replace(/^\.\//, "").split("\\").join("/");
 function testSources(repoRoot) {
     const root = join(repoRoot, "tests");
@@ -155,6 +187,7 @@ export function ownershipFindings(tasks, repoRoot) {
         const context = task.context.map(normalize);
         return {
             task,
+            files,
             owns: files.length === 0 ? () => false : filesGlob(files),
             allows: files.length === 0 ? () => true : filesGlob([...files, ...context]),
         };
@@ -204,6 +237,23 @@ export function ownershipFindings(tasks, repoRoot) {
             });
         }
     }
+    for (const entry of indexed) {
+        for (const [source, oracles] of Object.entries(SHAPE_ORACLE_MAP)) {
+            if (!touchesSource(entry.files, source))
+                continue;
+            for (const oracle of oracles) {
+                if (!entry.owns(oracle)) {
+                    findings.push({
+                        code: "unowned-shape-oracle",
+                        taskId: entry.task.id,
+                        source,
+                        oracle,
+                        detail: `${entry.task.id} touches ${source} without owning shape oracle ${oracle}`,
+                    });
+                }
+            }
+        }
+    }
     for (const source of sources) {
         for (const owner of owners(source.path)) {
             for (const path of repositoryPaths(source.text)) {
@@ -234,11 +284,24 @@ export function ownershipFindings(tasks, repoRoot) {
             }
         }
     }
-    return findings.sort((a, b) => `${a.code}:${"test" in a ? a.test : a.path}:${"taskId" in a ? a.taskId : ""}`.localeCompare(`${b.code}:${"test" in b ? b.test : b.path}:${"taskId" in b ? b.taskId : ""}`));
+    const target = (f) => {
+        switch (f.code) {
+            case "unowned-test": return f.test;
+            case "unowned-shape-oracle": return f.oracle;
+            case "test-path-outside-allowlist": return f.test;
+            case "unordered-context-write": return f.path;
+        }
+    };
+    return findings.sort((a, b) => {
+        const taskA = "taskId" in a ? a.taskId : "";
+        const taskB = "taskId" in b ? b.taskId : "";
+        return `${a.code}:${target(a)}:${taskA}`.localeCompare(`${b.code}:${target(b)}:${taskB}`);
+    });
 }
 export function renderOwnershipFinding(finding) {
     return `tickmarkr: ownership-lint[${finding.code}]: ${finding.detail}`;
 }
 export function blocksCompile(finding) {
-    return finding.code === "unowned-test" && finding.corroboration !== undefined;
+    return (finding.code === "unowned-test" && finding.corroboration !== undefined)
+        || finding.code === "unowned-shape-oracle";
 }

package/dist/config/config.d.ts

@@ -240,6 +240,7 @@ export declare const TickmarkrConfigSchema: z.ZodObject<{
     gates: z.ZodObject<{
         build: z.ZodOptional<z.ZodString>;
         test: z.ZodOptional<z.ZodString>;
+        tipTest: z.ZodOptional<z.ZodString>;
         lint: z.ZodOptional<z.ZodString>;
         diffCap: z.ZodOptional<z.ZodNumber>;
         byShape: z.ZodOptional<z.ZodOptional<z.ZodRecord<z.ZodEnum<{
@@ -339,6 +340,11 @@ export type InitConfigOverlay = {
         llm?: TickmarkrConfig["visibility"]["llm"];
     };
 };
+/**
+ * Default config overlay template.
+ * Seam: gates.test defines the per-task gate and baseline test command;
+ * gates.tipTest optionally defines the integration tip verify test command (defaults to gates.test).
+ */
 export declare function configTemplate(overlay?: InitConfigOverlay): string;
 export { FLEET_OVERLAY_KEYS, fleetEditableEquals, fleetRepoOverlayFromDelta, renderFleetOverlayWrite, repoOverlayYaml, serializeFleetOverlay, unifiedYamlDiff, } from "./fleet-overlay.js";
 export type { FleetOverlayWrite } from "./fleet-overlay.js";

package/dist/config/config.js

@@ -337,6 +337,7 @@ export const TickmarkrConfigSchema = z.object({
     gates: z.object({
         build: z.string(),
         test: z.string(),
+        tipTest: z.string(),
         lint: z.string(),
         diffCap: z.number().int().positive(),
         byShape: z.partialRecord(z.enum(SHAPES), ShapeGateParticipationSchema).optional(),
@@ -756,6 +757,11 @@ export function overlayBytesLoadError(repoRoot, bytes, opts = {}) {
         return e.message;
     }
 }
+/**
+ * Default config overlay template.
+ * Seam: gates.test defines the per-task gate and baseline test command;
+ * gates.tipTest optionally defines the integration tip verify test command (defaults to gates.test).
+ */
 export function configTemplate(overlay) {
     const base = `# tickmarkr config overlay — merges over built-in defaults (repo beats global beats defaults)
 # concurrency: 3

package/dist/drivers/subprocess.d.ts

@@ -3,9 +3,8 @@ export declare const MAX_BUF: number;
 export declare const HERDR_CONTROL_VARS: readonly ["HERDR_ENV", "HERDR_SOCKET_PATH", "ORCA_TERMINAL_HANDLE", "ORCA_PANE_KEY", "ORCA_TAB_ID"];
 /**
  * Copy of worker env with the fork cap applied and host control-plane vars stripped.
- * The cap is the one the enclosing run resolved (resolvedForkCap) — a worker's suites divide the
- * same machine the gate shells do, so both seams have to read the same run-owned number rather
- * than a flat constant. The operator's own export still wins.
+ * Workers retain the run's concurrency-derived cap (resolvedForkCap), independently of
+ * verification's suite-window budget. The operator's own export still wins.
  */
 export declare function sealHerdrEnv(env?: NodeJS.ProcessEnv): NodeJS.ProcessEnv;
 /** Pane/login-shell form of the same host-neutral worker env seal (herdr seed + daemon setup). */

package/dist/drivers/subprocess.js

@@ -22,9 +22,8 @@ export const HERDR_CONTROL_VARS = [
 ];
 /**
  * Copy of worker env with the fork cap applied and host control-plane vars stripped.
- * The cap is the one the enclosing run resolved (resolvedForkCap) — a worker's suites divide the
- * same machine the gate shells do, so both seams have to read the same run-owned number rather
- * than a flat constant. The operator's own export still wins.
+ * Workers retain the run's concurrency-derived cap (resolvedForkCap), independently of
+ * verification's suite-window budget. The operator's own export still wins.
  */
 export function sealHerdrEnv(env = process.env) {
     const out = { ...env };

package/dist/gates/baseline.d.ts

@@ -31,6 +31,8 @@ export interface BaselineCommand {
     durationMs?: number;
     /** Sum of the per-file durations named by the runner; null when its output names none. */
     fileDurationSumMs?: number | null;
+    /** Total files reported by the runner summary; null when unavailable. */
+    fileCount?: number | null;
     /** fileDurationSumMs / durationMs — average implied file concurrency, not a configured fork count. */
     impliedParallelism?: number | null;
     /** The slowest per-file entry named by the runner; null when per-file timing is unavailable. */
@@ -158,6 +160,8 @@ export declare function detectVacuousOracles(cwd: string, tasks: ReadonlyArray<{
 }>): Promise<VacuousOracleWarning[]>;
 export declare function compareToBaseline(cwd: string, commands: Record<string, string>, baseline: Baseline, enabled: string[], opts?: {
     rerunOf?: HostStarvedRerun;
+    infraRerun?: HostStarvedRerun;
+    selected?: readonly string[];
 }): Promise<GateResult[]>;
 export interface HostStarvedRerun {
     durationMs: number;
@@ -178,4 +182,13 @@ interface CalmWindow {
 }
 export declare function setCalmWindowForTests(over: Partial<CalmWindow>): void;
 export declare function resetCalmWindowForTests(): void;
+export declare function waitForCalmWindow(): Promise<number>;
+/** Summary totals survive digit-normalized fingerprints and exclude test-owned echoed output. */
+export declare function runnerFileCount(raw: string): number | null;
+export declare function fileCountDeficit(entry: BaselineCommand | undefined, raw: string, opts?: {
+    name?: string;
+    selected?: readonly string[];
+}): string | undefined;
+/** Both readers classify fresh evidence first, retaining the whole-output guard against infra forgiveness. */
+export declare function classifyFreshRunnerOutput(entry: BaselineCommand | undefined, raw: string, code: number): FailureClassification | undefined;
 export {};