tickmarkr 1.45.0 → 1.47.0

package/dist/cli/commands/profile.js

@@ -1,13 +1,21 @@
-import { writeFileSync } from "node:fs";
+import { readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { loadConfig } from "../../config/config.js";
 import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
-import { learnedScore, MIN_SAMPLES, cellsOf } from "../../route/profile.js";
-import { Journal, loadRoutingProfile, readProfileCursor, RUNS_WINDOW } from "../../run/journal.js";
-// tickmarkr profile — inspect (show) and forget (reset) the derived learned-routing profile (VIS-03).
-// Read-only class like plan/status/report: no run lock. `reset` writes ONE cursor scalar, nothing else.
+import { cellOf, cellSummary, explorationBonus, EXPLORE_CAP, learnedScore, learnedScoreTerms, MIN_SAMPLES, PRIOR_K, REF_MS, cellsOf, } from "../../route/profile.js";
+import { Journal, loadRoutingProfile, parseRunId, readProfileCursor, readProfileDiscounts, appendProfileDiscount, profileDiscountsPath, RUNS_WINDOW, } from "../../run/journal.js";
+// tickmarkr profile — inspect (show), forget (reset), and discount poisoned evidence (v1.46 T5).
+// Read-only class like plan/status/report except discount append. `reset` writes ONE cursor scalar.
 export async function profile(argv, cwd = process.cwd()) {
-    return argv[0] === "reset" ? reset(cwd) : show(cwd);
+    if (argv[0] === "reset")
+        return reset(cwd);
+    if (argv[0] === "discount")
+        return discount(argv.slice(1), cwd);
+    if (argv[0] === "discounts")
+        return listDiscounts(cwd);
+    if (argv[0] === "--explain" || argv.includes("--explain"))
+        return explain(argv, cwd);
+    return show(cwd);
 }
 // Non-destructive reset (T-13-06): a one-line runId cutoff at .tickmarkr/profile-since. NEVER deletes,
 // truncates, or rotates any telemetry — the profile is derived (PROF-01), so there is nothing to delete;
@@ -26,6 +34,119 @@ function reset(cwd) {
         `  to un-reset: delete ${stateDir}/profile-since.`,
     ].join("\n");
 }
+function parseDiscountArgs(argv) {
+    let runId;
+    let taskId;
+    let weight;
+    let reason;
+    for (let i = 0; i < argv.length; i++) {
+        if (argv[i] === "--weight" && argv[i + 1]) {
+            const w = argv[++i];
+            if (w !== "0" && w !== "0.5")
+                throw new Error(`profile discount --weight must be 0 or 0.5 (got ${w})`);
+            weight = w === "0" ? 0 : 0.5;
+        }
+        else if (argv[i] === "--reason" && argv[i + 1]) {
+            reason = argv[++i];
+        }
+        else if (!argv[i].startsWith("--") && runId === undefined) {
+            runId = parseRunId(argv[i]);
+        }
+        else if (!argv[i].startsWith("--") && taskId === undefined) {
+            taskId = argv[i];
+        }
+    }
+    if (!runId)
+        throw new Error("profile discount requires <runId>");
+    if (weight === undefined)
+        throw new Error("profile discount requires --weight 0|0.5");
+    if (!reason?.trim())
+        throw new Error("profile discount requires --reason (a discount is an evidence claim)");
+    return { runId, taskId, weight, reason: reason.trim() };
+}
+function discount(argv, cwd) {
+    const mark = parseDiscountArgs(argv);
+    appendProfileDiscount(cwd, mark);
+    const stateDir = stateDirName(cwd);
+    const scope = mark.taskId ? `${mark.runId} task ${mark.taskId}` : mark.runId;
+    return [
+        `profile discount — marked ${scope} at weight ${mark.weight}.`,
+        `  reason: ${mark.reason}`,
+        `  wrote ${stateDir}/profile-discounts (append-only).`,
+        `  list: tickmarkr profile discounts`,
+    ].join("\n");
+}
+function listDiscounts(cwd) {
+    const marks = readProfileDiscounts(cwd);
+    const path = profileDiscountsPath(cwd);
+    if (!marks.length) {
+        return existsDiscountsFile(cwd)
+            ? `profile discounts — ${path}\n  (no valid marks)`
+            : `profile discounts — no ${stateDirName(cwd)}/profile-discounts file yet.`;
+    }
+    const lines = marks.map((m) => {
+        const scope = m.taskId ? `${m.runId} ${m.taskId}` : m.runId;
+        return `  ${scope.padEnd(28)} weight=${m.weight}  # ${m.reason}`;
+    });
+    return [`profile discounts — ${path}`, ...lines].join("\n");
+}
+function existsDiscountsFile(cwd) {
+    try {
+        readFileSync(profileDiscountsPath(cwd));
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+const fmtSigned = (n) => (n >= 0 ? `+${n.toFixed(3)}` : n.toFixed(3));
+function explain(argv, cwd) {
+    const rest = argv[0] === "--explain" ? argv.slice(1) : argv.filter((a) => a !== "--explain");
+    const shape = rest[0];
+    const chKey = rest[1];
+    const channel = rest[2] ?? "sub";
+    if (!shape || !chKey)
+        throw new Error("profile --explain requires <shape> <channel>");
+    const cfg = loadConfig(cwd);
+    const p = loadRoutingProfile(cwd, cfg, { preview: true });
+    const tuning = { availWeight: cfg.routing.learnedTuning?.availWeight };
+    const cell = cellOf(p, shape, chKey, channel);
+    const terms = learnedScoreTerms(p, shape, chKey, channel, tuning);
+    const score = learnedScore(p, shape, chKey, channel, tuning);
+    const header = `${shape} × ${chKey} (${channel})`;
+    if (!cell) {
+        return [
+            header,
+            `  quality   ${fmtSigned(terms.quality)}   (no cell — neutral)`,
+            `  perf      ${fmtSigned(terms.perf)}`,
+            `  avail     ${fmtSigned(terms.avail)}`,
+            `  overrun   ${fmtSigned(terms.overrun)}`,
+            `  score     ${fmtSigned(score)}`,
+        ].join("\n");
+    }
+    const s = cellSummary(cell);
+    const disc = s.discounted > 0 ? `, ${s.discounted} rows discounted` : "";
+    const qualityDetail = s.cold
+        ? `n_eff ${s.nEff} < ${MIN_SAMPLES} (cold)`
+        : `q̂=(qSum ${cell.qSum} + ${PRIOR_K})/(n ${cell.n} + ${2 * PRIOR_K}) − 0.5  n_raw ${s.nRaw}${disc}`;
+    const perfDetail = cell.doneMedianMs === undefined || s.cold
+        ? `cold`
+        : `median ${Math.round(cell.doneMedianMs / 60_000)}m vs ref ${REF_MS / 60_000}m  done=${cell.doneCount}`;
+    const availDetail = `quotaHits ${cell.quotaHits} / dispatches ${cell.dispatches}`;
+    const overrunDetail = `overruns ${cell.overruns ?? 0} / dispatches ${cell.dispatches}`;
+    const explore = cell.dispatches >= EXPLORE_CAP
+        ? `spent  dispatches ${cell.dispatches} ≥ cap ${EXPLORE_CAP}`
+        : `remaining ${s.exploreRemaining}  bonus ${explorationBonus(cell).toFixed(3)}`;
+    return [
+        header,
+        `  quality   ${fmtSigned(terms.quality)}   ${qualityDetail}`,
+        `  perf      ${fmtSigned(terms.perf)}   ${perfDetail}`,
+        `  avail     ${fmtSigned(terms.avail)}   ${availDetail}`,
+        `  overrun   ${fmtSigned(terms.overrun)}   ${overrunDetail}`,
+        `  score     ${fmtSigned(score)}   (deciding only below prefer/cost/tier — ROUTE-08)`,
+        `  explore   ${explore}`,
+    ].join("\n");
+}
 // Inspection surface: preview:true bypasses the routing.learned:off short-circuit so `show` renders the
 // profile even under the default off — same trust ramp as `tickmarkr plan`. The routing path stays inert.
 function show(cwd) {
@@ -51,7 +172,8 @@ function show(cwd) {
         // VIS-04/ROUTE-15 — preview must match routing's tuning, never the bare module default.
         const score = learnedScore(p, shape, chKey, channel, { availWeight: cfg.routing.learnedTuning?.availWeight }).toFixed(3);
         const cold = cell.n < MIN_SAMPLES ? `  cold (n<${MIN_SAMPLES})` : "";
-        return `  ${shape.padEnd(10)} ${chKey.padEnd(28)} ${channel.padEnd(4)} n=${String(cell.n).padEnd(3)} q=${quality.padEnd(5)} ${median.padEnd(9)} disp=${String(cell.dispatches).padEnd(3)} score=${score}${cold}`;
+        const disc = (cell.discounted ?? 0) > 0 ? `  disc=${cell.discounted}` : "";
+        return `  ${shape.padEnd(10)} ${chKey.padEnd(28)} ${channel.padEnd(4)} n=${String(cell.n).padEnd(3)} q=${quality.padEnd(5)} ${median.padEnd(9)} disp=${String(cell.dispatches).padEnd(3)} score=${score}${disc}${cold}`;
     });
     return [...header, "", "  shape      channel                      class obs   quality  median    dispatch  score", ...rows].join("\n");
 }

package/dist/cli/commands/run.js

@@ -4,7 +4,7 @@ import { loadConfig } from "../../config/config.js";
 import { pickDriver } from "../../drivers/index.js";
 import { loadGraph } from "../../graph/graph.js";
 import { formatSummary, runDaemon } from "../../run/daemon.js";
-import { route } from "../../route/router.js";
+import { route, QUALITY_ENV, NO_EXPLORE_ENV } from "../../route/router.js";
 import { formatJournalNarration, loadRoutingProfile } from "../../run/journal.js";
 const summaryGreen = (s) => s.failed.length === 0 && s.human.length === 0 && s.blocked.length === 0 && s.pending.length === 0
     && s.tipVerify !== "failed";
@@ -15,6 +15,8 @@ export async function run(argv, cwd = process.cwd()) {
             concurrency: { type: "string" },
             driver: { type: "string" },
             "route-strict": { type: "boolean" },
+            "no-explore": { type: "boolean" },
+            quality: { type: "boolean" },
         },
     });
     if (values.concurrency !== undefined) {
@@ -23,21 +25,36 @@ export async function run(argv, cwd = process.cwd()) {
             throw new Error(`--concurrency must be a positive integer (got ${values.concurrency})`);
     }
     const cfg = loadConfig(cwd);
-    if (values["route-strict"]) {
-        const adapters = allAdapters();
-        const health = readDoctor(cwd) ?? (await probeAll(adapters));
-        const channels = discoverChannels(cfg, adapters, health);
-        // no preview: the strict pre-flight routes through exactly what the daemon will use (honors the switch)
-        const profile = loadRoutingProfile(cwd, cfg);
-        const lints = loadGraph(cwd).tasks.flatMap((t) => route(t, cfg, channels, profile).lints);
-        if (lints.length)
-            throw new Error(`--route-strict: routing lints present, refusing to dispatch:\n${lints.join("\n")}`);
+    const quality = !!values.quality;
+    const noExplore = !!values["no-explore"] || quality;
+    const exploreCtx = noExplore || quality ? { noExplore, quality } : undefined;
+    if (noExplore)
+        process.env[NO_EXPLORE_ENV] = "1";
+    if (quality)
+        process.env[QUALITY_ENV] = "1";
+    try {
+        if (values["route-strict"]) {
+            const adapters = allAdapters();
+            const health = readDoctor(cwd) ?? (await probeAll(adapters));
+            const channels = discoverChannels(cfg, adapters, health);
+            // no preview: the strict pre-flight routes through exactly what the daemon will use (honors the switch)
+            const profile = loadRoutingProfile(cwd, cfg);
+            const lints = loadGraph(cwd).tasks.flatMap((t) => route(t, cfg, channels, profile, undefined, undefined, exploreCtx).lints);
+            if (lints.length)
+                throw new Error(`--route-strict: routing lints present, refusing to dispatch:\n${lints.join("\n")}`);
+        }
+        const s = await runDaemon(cwd, {
+            concurrency: values.concurrency ? Number(values.concurrency) : undefined,
+            driver: pickDriver(cfg, values.driver),
+            narrate: (event) => console.log(formatJournalNarration(event)),
+        });
+        const out = `run ${s.runId} finished — ${formatSummary(s)} (merge to main is a human decision)`;
+        return { out, code: summaryGreen(s) ? 0 : 2 };
+    }
+    finally {
+        if (noExplore)
+            delete process.env[NO_EXPLORE_ENV];
+        if (quality)
+            delete process.env[QUALITY_ENV];
     }
-    const s = await runDaemon(cwd, {
-        concurrency: values.concurrency ? Number(values.concurrency) : undefined,
-        driver: pickDriver(cfg, values.driver),
-        narrate: (event) => console.log(formatJournalNarration(event)),
-    });
-    const out = `run ${s.runId} finished — ${formatSummary(s)} (merge to main is a human decision)`;
-    return { out, code: summaryGreen(s) ? 0 : 2 };
 }

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  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  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\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  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  approve a parked human gate (--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\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  run           execute the graph (--concurrency N --driver herdr|subprocess --route-strict)\n  status        live run state\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  unlock        remove a stale/garbage run lock (refuses if the holder is alive)\n  approve <id> <task>  approve a parked human gate (--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

@@ -4,6 +4,7 @@ import { pathToFileURL } from "node:url";
 import { approve } from "./commands/approve.js";
 import { compile } from "./commands/compile.js";
 import { doctor } from "./commands/doctor.js";
+import { fleet } from "./commands/fleet.js";
 import { init } from "./commands/init.js";
 import { plan } from "./commands/plan.js";
 import { profile } from "./commands/profile.js";
@@ -16,7 +17,7 @@ import { unlock } from "./commands/unlock.js";
 import { version } from "./commands/version.js";
 const normalize = (r) => typeof r === "string" ? { out: r, code: 0 } : r;
 export const COMMANDS = {
-    init, doctor, compile, scope, plan, run, status, resume, report, profile, unlock, approve, version,
+    init, doctor, fleet, compile, scope, plan, run, status, resume, report, profile, unlock, approve, version,
 };
 const VERSION_FLAGS = new Set(["version", "--version", "-v"]);
 const HELP_CMDS = new Set(["help", "-h", "--help"]);
@@ -25,6 +26,7 @@ export const USAGE = `tickmarkr — spec-driven orchestration harness for AI cod
 usage: tickmarkr <command>
   init          guided setup + doctor; init --agent [--force] [--docs] adds agent skills/docs
   doctor        re-probe adapters, herdr, auth; print capability matrix
+  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)
   plan          dry-run routing table + cost estimate + floor lints

package/dist/compile/collateral.js

@@ -1,5 +1,6 @@
 import { readdirSync, readFileSync, statSync } from "node:fs";
 import { extname, join, relative } from "node:path";
+import picomatch from "picomatch";
 // Advisory plan-time scan only (OBS-12/13/14/21). NEVER expands files[], fails compile, or
 // feeds the scope gate — a warning the author acts on. Plain-text (no AST), capped + sorted.
 /** Max test files walked under tests/ (sorted walk; rest ignored). */
@@ -99,7 +100,8 @@ export function collateralLints(tasks, repoRoot) {
     };
     const lines = [];
     for (const t of tasks) {
-        const scoped = new Set(t.files.map((f) => f.replace(/^\.\//, "")));
+        // OBS-22: scopeGate accepts picomatch globs; advisory collateral warnings must agree.
+        const scoped = picomatch(t.files.map((f) => f.replace(/^\.\//, "")), { dot: true });
         const srcFiles = t.files.map((f) => f.replace(/^\.\//, "")).filter(isSrcPath);
         if (!srcFiles.length)
             continue;
@@ -107,7 +109,7 @@ export function collateralLints(tasks, repoRoot) {
         const needles = [...new Set(srcFiles.flatMap(needlesFor))];
         const hits = [];
         for (const tf of testFiles) {
-            if (scoped.has(tf))
+            if (scoped(tf))
                 continue;
             const text = read(tf);
             if (text === null)

package/dist/compile/native.js

@@ -23,7 +23,7 @@ export function compileNative(file) {
     for (const line of content.split("\n")) {
         const heading = line.match(HEAD_RE);
         if (heading) {
-            drafts.push({ id: heading[1], title: heading[2].trim(), fields: {}, acceptance: [], gates: [], hasGates: false, list: null });
+            drafts.push({ id: heading[1], title: heading[2].trim(), fields: {}, acceptance: [], gates: [], hasGates: false, list: null, goalContinuation: false });
             continue;
         }
         const draft = drafts.at(-1);
@@ -41,15 +41,30 @@ export function compileNative(file) {
                 draft.list = name;
                 if (name === "gates")
                     draft.hasGates = true;
+                draft.goalContinuation = false;
             }
             else {
                 if (name === "goal" && !value)
                     invalid(draft.id, field[1], "must not be empty");
                 draft.fields[name] = value;
+                // OBS-60: carry every indented continuation line after `- goal:` into the compiled goal.
+                draft.goalContinuation = name === "goal";
                 draft.list = null;
             }
             continue;
         }
+        // OBS-60: multiline goals — indented prose after `- goal:` is appended until the next field.
+        if (draft.goalContinuation) {
+            if ((line.startsWith(" ") || line.startsWith("\t")) && !NESTED_RE.test(line)) {
+                draft.fields.goal += `\n${line.trim()}`;
+                continue;
+            }
+            if (!line.trim()) {
+                draft.fields.goal += "\n";
+                continue;
+            }
+            draft.goalContinuation = false;
+        }
         const nested = line.match(NESTED_RE);
         if (nested && draft.list) {
             const value = nested[1].trim();

package/dist/config/config.d.ts

@@ -32,6 +32,7 @@ export declare const TierEntrySchema: z.ZodObject<{
         mid: "mid";
         frontier: "frontier";
     }>>;
+    windows: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
 }, z.core.$strip>;
 export type TierEntry = z.infer<typeof TierEntrySchema>;
 export declare const ModelPricingSchema: z.ZodObject<{
@@ -85,6 +86,16 @@ export declare const TickmarkrConfigSchema: z.ZodObject<{
             halfLifeRuns: z.ZodOptional<z.ZodNumber>;
             availWeight: z.ZodOptional<z.ZodNumber>;
         }, z.core.$strip>>;
+        explore: z.ZodOptional<z.ZodObject<{
+            mode: z.ZodOptional<z.ZodEnum<{
+                on: "on";
+                off: "off";
+            }>>;
+            excludeShapes: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            excludeComplexityAtOrAbove: z.ZodOptional<z.ZodNullable<z.ZodNumber>>;
+            cap: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>>;
+        sla: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
         allowUnverifiedModels: z.ZodBoolean;
         allow: z.ZodOptional<z.ZodObject<{
             adapters: z.ZodOptional<z.ZodArray<z.ZodString>>;
@@ -106,6 +117,7 @@ export declare const TickmarkrConfigSchema: z.ZodObject<{
             mid: "mid";
             frontier: "frontier";
         }>>;
+        windows: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodNumber>>;
     }, z.core.$strip>>;
     pricing: z.ZodRecord<z.ZodString, z.ZodNumber>;
     cost: z.ZodOptional<z.ZodObject<{
@@ -194,4 +206,34 @@ export type InitConfigOverlay = {
     };
 };
 export declare function configTemplate(overlay?: InitConfigOverlay): string;
+/** Fleet-owned overlay keys — the only config surface `tickmarkr fleet` may write. */
+export declare const FLEET_OVERLAY_KEYS: readonly ["routing", "tiers"];
+export type FleetTierAssignment = {
+    tier: Tier;
+    provenance?: string;
+};
+export type FleetEditable = {
+    denyAdapters: string[];
+    denyModels: string[];
+    tiers: Record<string, Record<string, FleetTierAssignment | null>>;
+    map: Record<string, MapEntry>;
+    floors: Record<string, Tier>;
+};
+export declare function repoOverlayPath(repoRoot: string): string;
+export declare function readOverlayFile(path: string): Record<string, unknown>;
+export declare function fleetEditableFromConfig(cfg: TickmarkrConfig): FleetEditable;
+/** Resolve which layer last set a dotted fleet path (defaults < global < repo). */
+export declare function fleetKeyLayer(repoRoot: string, dotted: string, opts?: {
+    globalDir?: string;
+}): "defaults" | "global" | "repo";
+/** Non-interactive fleet state for CI drift checks (`tickmarkr fleet --print`). */
+export declare function formatFleetPrint(repoRoot: string, opts?: {
+    globalDir?: string;
+}): string;
+/** Build the repo overlay fragment fleet would write for edits since session start. */
+export declare function fleetRepoOverlayFromDelta(initial: FleetEditable, edited: FleetEditable, existingRepo?: Record<string, unknown>): Record<string, unknown>;
+export declare function repoOverlayYaml(overlay: Record<string, unknown>, provenance?: Record<string, Record<string, string>>): string;
+export declare function serializeFleetOverlay(overlay: Record<string, unknown>, provenance?: Record<string, Record<string, string>>): string;
+export declare function unifiedYamlDiff(before: string, after: string, label?: string): string;
+export declare function fleetEditableEquals(a: FleetEditable, b: FleetEditable): boolean;
 export {};