tickmarkr 1.90.7 → 1.91.0

package/dist/cli/commands/init.js

@@ -362,21 +362,20 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
     const interactive = input.isTTY === true && output.isTTY === true && !(values.yes ?? false);
     // Act 1 — preferences. Only when the repo config does not exist yet: init never rewrites an
     // operator's config; re-tuning is `tickmarkr fleet` (act 3 below still runs and writes overlays).
-    let wizardQuit = false;
     if (!repoConfigExists) {
         if (interactive) {
             emitBanner();
             const wizard = await runInitWizard(cwd, input, output);
             if (wizard === null) {
-                wizardQuit = true;
-                notes.push("wizard quit — no repo config written; re-run tickmarkr init (or tickmarkr fleet after a manual config)");
+                // Operator field report 2026-08-13: quit means QUIT — no probe, no report wall, no fleet
+                // act, one line out. Scaffolding above already happened (spec/global config), and saying
+                // so costs one clause; everything else stops here. Esc and ctrl+c both land here.
+                return `init: wizard quit — nothing further run (scaffolding kept: ${notes.filter((n) => n.startsWith("wrote")).length} file(s) written above). Re-run tickmarkr init to continue.`;
             }
-            else {
-                writeFileSync(repoConfigPath, configTemplate(wizard.overlay));
-                notes.push(`wrote ${repoConfigPath}`);
-                if (wizard.installSkills) {
-                    await installAgentFiles(cwd, values.force ?? false, wizard.installDocs || (values.docs ?? false), notes);
-                }
+            writeFileSync(repoConfigPath, configTemplate(wizard.overlay));
+            notes.push(`wrote ${repoConfigPath}`);
+            if (wizard.installSkills) {
+                await installAgentFiles(cwd, values.force ?? false, wizard.installDocs || (values.docs ?? false), notes);
             }
         }
         else {
@@ -386,17 +385,20 @@ export async function init(argv, cwd = process.cwd(), io = {}) {
     }
     // Act 2 — discovery. Doctor is the sensor (fleet never re-probes); runs after preferences so the
     // probe reads the config the operator just chose. Reuse keeps init fast; --fresh forces the probe.
+    // Interactive journeys get the COMPACT surface (status rows + pointer) — the full matrix between
+    // two TUIs was the operator's clutter report; non-TTY keeps the complete machine surface.
     const fresh = values.fresh ?? false;
     const { reuse, ageMs, health } = initDoctorReuse(cwd, fresh);
     let 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, undefined, { banner: false });
-    // Act 3 — fleet. Interactive only, and never after a wizard quit ("stop" means stop). The
-    // discovery report prints BETWEEN the acts so the operator reads what the presets screen
-    // ranks with; the final summary then carries a pointer instead of the same bytes twice.
-    if (interactive && !wizardQuit) {
+        ? interactive
+            ? `using probe results from ${formatDoctorAgeForInit(ageMs)} ago — full matrix: tickmarkr doctor · refresh: init --fresh`
+            : `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, undefined, { banner: false, compact: interactive });
+    // Act 3 — fleet. The compact discovery surface prints BETWEEN the acts so the operator reads
+    // what the presets screen ranks with; the final summary then carries a pointer, not a repeat.
+    if (interactive) {
         output.write(`${doc}\n`);
-        doc = "discovery report shown above — re-print any time with `tickmarkr doctor`";
+        doc = "discovery shown above — full matrix any time with `tickmarkr doctor`";
         // Same lazy-Ink seam as fleet.ts: load the editor runtime up front so the assembler's
         // returned props need no startup-input capture window on this path.
         const { runFleetInkEditor } = await import("../../tui/ink/fleet-app.js");

package/dist/compile/native.js

@@ -697,10 +697,11 @@ acceptance is required on every task (a nested list of observable outcomes).
   WHAT MAKES A CRITERION REAL:
     - "test:" must name a real test asserting on recorded state, journal lines, or drawn frames, and its
       title must match the criterion string verbatim. It also needs a collectable test path in files[].
-    - A "test:" oracle must name a TOP-LEVEL test case, never one nested under describe(). Vitest prefixes
-      nested cases with every suite title, while the acceptance gate builds an anchored pattern that
-      vitest -t applies against the FULL runner-visible name; the verbatim leaf title then selects ZERO
-      tests and the gate parks even though the suite is green. Measured: two parks in one run.
+    - A "test:" oracle's criterion must be the test's OWN title — the leaf — verbatim. Nesting under
+      describe() is allowed (OBS-511: the gate matches the criterion as the trailing segment of the
+      runner-visible full name), but the leaf title itself must equal the criterion: a shortened,
+      decorated, or paraphrased leaf selects ZERO tests and the gate parks even though the suite is green.
+      Measured before the widening: two parks across two runs, one full attempt lost in each.
     - NO criterion may be satisfiable by an absence, a rename, a source-text grep, or an empty collection.
       "no file references X" is not a criterion — it passes in a repo where the feature was never built.
     - "goal:" is NEVER verification. Prose in the goal enforces nothing: every obligation needs an

package/dist/config/config.js

@@ -705,6 +705,11 @@ export function configTemplate(overlay) {
 # tiers:                  # model → capability band; extend when new models ship
 #   claude-code: { vendor: anthropic, channel: sub, models: { fable: frontier } }
 #   codex: { models: { gpt-5.2-codex: null } }   # null = tombstone: removes a stale seed id
+# tier evidence: \`tickmarkr doctor --refresh-catalog\` fetches the catalogs behind tier suggestions.
+#   models.dev and LiveBench need no key. The Artificial Analysis leg runs ONLY when the environment
+#   carries ARTIFICIAL_ANALYSIS_API_KEY (free key: artificialanalysis.ai) — unset, AA contributes
+#   nothing and suggestions fall back to LiveBench's agentic-coding rank, then price. Not a config
+#   key: an API credential belongs in the environment, never in a tracked overlay.
 # visibility:
 #   llm: headless         # headless (default): judge/review/consult run silently | pane: visible agents
 #   keepPanes: run        # run (default): ephemeral judge/review/consult panes close when read; a merged task's worker pane closes on done; other worker panes persist until run end | attempt | forever (keep everything for debugging)

package/dist/config/fleet-overlay.js

@@ -1,5 +1,5 @@
 // Fleet-overlay mutation, serialization, and diff rendering for the `tickmarkr fleet` write path.
-import { isMap, isScalar, isSeq, parseDocument, stringify } from "yaml";
+import { isMap, isScalar, isSeq, parseDocument, stringify, visit } from "yaml";
 /** Fleet-owned overlay keys — the only config surface `tickmarkr fleet` may write. */
 export const FLEET_OVERLAY_KEYS = ["routing", "tiers"];
 function fleetSubset(obj) {
@@ -18,6 +18,9 @@ function sortedUnique(xs) {
 // private provenance envelope until this module writes the YAML. The envelope never reaches disk.
 const FIRST_TOUCH_OPEN = "\uE000tickmarkr-fleet-first-touch:";
 const FIRST_TOUCH_CLOSE = "\uE001";
+// OBS-505: marks a scalar-trailing single-line comment for the two-space inline note style at
+// stringify time; applied and consumed inside renderFleetOverlayWrite, never written to disk.
+const INLINE_COMMENT_SENTINEL = "\uE002";
 export function fleetFirstTouchProvenance(note, firstTouch) {
     return `${FIRST_TOUCH_OPEN}${encodeURIComponent(firstTouch.vendor)}:${firstTouch.channel}${FIRST_TOUCH_CLOSE}${note}`;
 }
@@ -189,10 +192,23 @@ export function renderFleetOverlayWrite(priorBytes, write) {
             }
         }
     }
-    // Fleet's established note style uses two spaces before `#`; the Document remains the sole
-    // comment writer while preserving that byte-level convention for old and newly-authored notes.
+    // OBS-505: fleet's two-space note style (`tier: mid  # note`) applies to INLINE comments only.
+    // The previous commentString prefixed " #" onto EVERY comment line, so block comments — the
+    // whole init scaffold at column 0, and indented operator essays — each gained a stray leading
+    // space, turning a one-key write into a whole-file diff on the one confirmation surface an
+    // operator reviews. commentString has no position context, but this writer owns the document:
+    // scalar-trailing single-line comments (the only inline form fleet emits) are marked with a
+    // private-use sentinel (the FIRST_TOUCH envelope precedent above), everything else renders
+    // byte-identical to yaml's own stringifyComment.
+    visit(doc, (_key, node) => {
+        if (isScalar(node) && typeof node.comment === "string" && !node.comment.includes("\n")) {
+            node.comment = `${INLINE_COMMENT_SENTINEL}${node.comment}`;
+        }
+    });
     return doc.toString({
-        commentString: (comment) => comment.replace(/^(?!$)(?: $)?/gm, " #"),
+        commentString: (comment) => comment.startsWith(INLINE_COMMENT_SENTINEL)
+            ? ` #${comment.slice(1)}`
+            : comment.replace(/^(?!$)(?: $)?/gm, "#"),
     });
 }
 /** Build the repo overlay fragment fleet would write for edits since session start. */

package/dist/gates/acceptance.js

@@ -75,10 +75,17 @@ function escapeRegExp(s) {
     return s.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 // v1.89 T6: Vitest applies -t to the runner-visible full name (enclosing describe titles and the test
-// title, space-joined). Escaping preserves literal criteria; anchoring makes equality, rather than
-// substring containment, the named-test contract.
+// title, space-joined). Escaping preserves literal criteria; the leaf anchor makes trailing-title
+// equality, rather than substring containment, the named-test contract.
+// OBS-511 (runs 1013+1027, one full attempt lost in EACH): two independent workers nested the verbatim
+// criterion under a describe, the old `^…$` full-name equality matched zero tests, and the gate parked a
+// green suite. `(^| )` accepts any describe prefix while keeping the criterion as the complete trailing
+// segment — equality still matches (empty prefix), and a title merely CONTAINING the criterion still
+// selects zero. ponytail: a leaf title that itself ENDS with " <criterion>" also matches — vitest -t sees
+// only the space-joined full name, so true leaf-boundary precision needs the runner's --list JSON
+// (auditAcceptanceCorpus has it at doctor time); upgrade there if this window is ever exploited.
 export function testFilterPattern(name) {
-    return `^${escapeRegExp(name)}$`;
+    return `(^| )${escapeRegExp(name)}$`;
 }
 // OBS-55: when the base command already contains `--`, append -t after forwarded args — a second `--`
 // makes vitest treat -t as a positional file filter and the name filter is dropped.
@@ -126,8 +133,10 @@ export function auditAcceptanceCorpus(corpusRoot, listedTests) {
                             ? {
                                 namedTest: {
                                     criterion: item.test,
+                                    // OBS-511: mirror the gate's leaf-anchored suffix rule — the audit's denominator
+                                    // must count exactly the tests the -t filter would select, or doctor and gate disagree.
                                     matches: runnerNames
-                                        .filter(({ fullName }) => fullName === item.test)
+                                        .filter(({ fullName }) => fullName === item.test || fullName.endsWith(` ${item.test}`))
                                         .map(({ listed }) => listed),
                                 },
                             }

package/dist/run/daemon.js

@@ -1944,7 +1944,7 @@ export async function runDaemon(repoRoot, opts = {}) {
                     const promptFile = writePrompt(journal.dir, t, attempt, feedback, nonce);
                     // OBS-56: state the non-interactive, one-pass finish contract and the OBS-54 stall budget in every
                     // worker prompt, not only consult retry guidance. Prepended so prompt.ts's completion trailer stays last.
-                    const workerContract = `## Harness contract\n- This harness is non-interactive: make one continuous pass; do not stop for questions or follow-up input.\n- You have a ${taskTimeoutMinutes} minute stall window. Budget the full suite once, then commit and emit the completion trailer before it expires.\n- Each test: acceptance criterion must exist as a vitest test whose title matches the criterion string verbatim.`; // OBS-64
+                    const workerContract = `## Harness contract\n- This harness is non-interactive: make one continuous pass; do not stop for questions or follow-up input.\n- You have a ${taskTimeoutMinutes} minute stall window. Budget the full suite once, then commit and emit the completion trailer before it expires.\n- Each test: acceptance criterion must exist as a vitest test whose OWN title (the leaf, not counting enclosing describe titles) is the criterion string verbatim — never shortened, never decorated. Nesting under describe() is allowed.`; // OBS-64; OBS-511: leaf-title rule stated where the worker reads it
                     // OBS-47: state the worktree layout contract in the worker prompt (cheap-tier workers were
                     // committing/deleting node_modules and tripping the scope gate). The harness re-asserts the link
                     // itself before gates regardless of what the worker does with it.

package/dist/tui/ink/components.d.ts

@@ -9,7 +9,20 @@ export declare function TextLines({ lines }: {
 export declare function ToggleMark({ active }: {
     active: boolean;
 }): import("react").JSX.Element;
-export declare function FleetListScreen({ title, legend, rows, cursor, details, filter, }: {
+/**
+ * v1.90.9 (operator field report: "can't choose models for omp"): a list longer than the
+ * terminal rendered EVERY row, so the title, legend, and cursor scrolled off the top — omp's
+ * 218 unclassified models left the operator staring at a tail of unselectable rows. The window
+ * is cursor-centered and clamped; the markers say exactly what is elided and that the list is
+ * still fully reachable (arrows walk it, type-to-search narrows it).
+ */
+export declare function windowRows<T>(rows: T[], cursor: number, capacity: number): {
+    visible: T[];
+    start: number;
+    above: number;
+    below: number;
+};
+export declare function FleetListScreen({ title, legend, rows, cursor, details, filter, viewRows, }: {
     title: string;
     legend: string;
     rows: FleetListRow[];
@@ -17,6 +30,8 @@ export declare function FleetListScreen({ title, legend, rows, cursor, details,
     details?: string[];
     /** active type-to-search string; rendered on the legend line so the operator sees the narrowing */
     filter?: string;
+    /** list viewport capacity; rows beyond it window around the cursor with elision markers */
+    viewRows?: number;
 }): import("react").JSX.Element;
 export declare function FleetReviewScreen({ title, legend, diff, }: {
     title: string;

package/dist/tui/ink/components.js

@@ -17,8 +17,22 @@ export function ToggleMark({ active }) {
         ? _jsx(Text, { color: "ansi256(41)", children: GLYPHS.toggleActive })
         : _jsx(Text, { dimColor: true, children: GLYPHS.toggleInactive });
 }
-export function FleetListScreen({ title, legend, rows, cursor, details = [], filter, }) {
-    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: filter ? `${legend} · search: ${filter}` : legend }), rows.map((row, index) => (_jsxs(Text, { bold: index === cursor, children: [index === cursor ? `${GLYPHS.pointer} ` : "  ", row.content] }, row.id))), _jsx(TextLines, { lines: details })] }));
+/**
+ * v1.90.9 (operator field report: "can't choose models for omp"): a list longer than the
+ * terminal rendered EVERY row, so the title, legend, and cursor scrolled off the top — omp's
+ * 218 unclassified models left the operator staring at a tail of unselectable rows. The window
+ * is cursor-centered and clamped; the markers say exactly what is elided and that the list is
+ * still fully reachable (arrows walk it, type-to-search narrows it).
+ */
+export function windowRows(rows, cursor, capacity) {
+    if (capacity <= 0 || rows.length <= capacity)
+        return { visible: rows, start: 0, above: 0, below: 0 };
+    const start = Math.min(Math.max(cursor - Math.floor(capacity / 2), 0), rows.length - capacity);
+    return { visible: rows.slice(start, start + capacity), start, above: start, below: rows.length - start - capacity };
+}
+export function FleetListScreen({ title, legend, rows, cursor, details = [], filter, viewRows, }) {
+    const { visible, start, above, below } = windowRows(rows, cursor, viewRows ?? Number.POSITIVE_INFINITY);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: filter ? `${legend} · search: ${filter}` : legend }), above > 0 && _jsxs(Text, { dimColor: true, children: ["  \u2026 ", above, " above"] }), visible.map((row, index) => (_jsxs(Text, { bold: start + index === cursor, children: [start + index === cursor ? `${GLYPHS.pointer} ` : "  ", row.content] }, row.id))), below > 0 && _jsxs(Text, { dimColor: true, children: ["  \u2026 ", below, " below \u2014 type to search"] }), _jsx(TextLines, { lines: details })] }));
 }
 export function FleetReviewScreen({ title, legend, diff, }) {
     return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { bold: true, children: title }), _jsx(Text, { dimColor: true, children: legend }), _jsx(Text, { children: diff })] }));

package/dist/tui/ink/fleet-app.d.ts

@@ -42,6 +42,10 @@ type AgentCli = {
     version: string;
     authed: boolean;
 };
+export type FleetModelSuggestion = {
+    tier: Tier;
+    note: string;
+};
 export type FleetModelGroup = {
     adapter: string;
     vendor?: string;
@@ -49,6 +53,7 @@ export type FleetModelGroup = {
         model: string;
         tier?: Tier;
         detectedAt?: string;
+        suggestion?: FleetModelSuggestion;
     }>;
 };
 export type FleetClassification = {
@@ -76,7 +81,7 @@ export type FleetCandidateOption = {
     };
 };
 export declare function formatDoctorAge(ageMs: number | null): string;
-export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, entry, initialJudge, judgeSeats, }: {
+export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, entry, initialJudge, judgeSeats, viewRows, }: {
     ageMs: number | null;
     agents: AgentCli[];
     initialDenyAdapters: string[];
@@ -98,6 +103,8 @@ export declare function FleetApp({ ageMs, agents, initialDenyAdapters, initialDe
     initialJudge?: string;
     /** discovered adapter:model seats — the judge picker universe */
     judgeSeats?: string[];
+    /** list viewport capacity (terminal rows minus chrome) — long lists window around the cursor */
+    viewRows?: number;
 }): import("react").JSX.Element;
 export declare function runFleetInkEditor({ ageMs, adapters, health, initialDenyAdapters, initialDenyModels, modelGroups, initialMode, modeOptions, initialMap, modePreview, shapeRows, candidatesForShape, preferOptionsForShape, initialSteering, steeringOptionsFor, reviewOverlay, reloadGuard, entry, initialJudge, judgeSeats, initialInput, input, output, debug, }: {
     ageMs: number | null;