tickmarkr 1.57.0 → 1.58.0

package/dist/adapters/kimi.js

@@ -1,16 +1,33 @@
 import { spawnSync } from "node:child_process";
-import { readFileSync } from "node:fs";
+import { readdirSync, readFileSync, realpathSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { probeVersion } from "./claude-code.js";
 import { parseWorkerResult } from "./prompt.js";
-import { channelsFromConfig, MODEL_ID_RE, shq } from "./types.js";
-// KIMI-03: collectUsage is DELIBERATELY ABSENT — documented won't-implement, consistent with the
-// metering-honesty invariant (adapters/types.ts). Sessions live under ~/.kimi-code/sessions/ with
-// kimi export (ZIP) + session_index.jsonl; no harness-readable per-attempt token counter was found
-// in the session store (research F-6, 2026-07-17). Consequence: kimi channels report honestly
-// `unmetered` — same class as grok (grok.ts:11-39). Revisit if kimi ships usage in the
-// `-p --output-format stream-json` envelope or a counter in the session store.
+import { channelsFromConfig, MODEL_ID_RE, shq, TokenUsageSchema } from "./types.js";
+// KIMI-03 → v1.58 T5: the "no harness-readable counter" block (research F-6, 2026-07-17) is
+// LIFTED for collectUsage — kimi 0.27.0 writes a wire journal per agent at
+// ~/.kimi-code/sessions/<wd>/session_<uuid>/agents/<agent>/wire.jsonl, and ~/.kimi-code/
+// workspaces.json maps each wd_* dir to its realpath'd workspace root. Field mapping pinned ONLY
+// after live verification of the real store (2026-07-18, 53 wire files / 178 usage rows, zero
+// tokens spent):
+//   - the canonical row is top-level `{"type":"usage.record","usage":{...},"usageScope":"turn",
+//     "time":<epoch ms>}` — 178/178 rows carried scope "turn" and the identical key set
+//     {inputOther, output, inputCacheRead, inputCacheCreation};
+//   - per-turn DELTA semantics verified arithmetically: each turn's inputCacheRead ≈ prior
+//     inputCacheRead + inputOther + output (the grown context re-read from cache — claude's
+//     per-message convention), and inputOther/output are non-monotonic per-turn counts, so
+//     SUMMING rows is the correct fold (never a cumulative 3A+2B+C trap);
+//   - the SAME usage object is echoed inside the step.end loop event
+//     (`type:"context.append_loop_event"`, event.usage) — folding anything but usage.record
+//     rows double-counts every turn, hence the exact type+scope pin below;
+//   - mapping: inputOther→input, output→output, inputCacheRead→cacheRead,
+//     inputCacheCreation→cacheWrite (creation observed live only as 0; mapped by name).
+// Absent or ambiguous usage resolves to UNMETERED, never an invented count: unknown usageScope,
+// non-numeric core fields, torn lines, or no post-cursor row all skip/return undefined — the
+// "?? 0" poisoning class stays banned. contextUsage remains absent (resumeUnknownContext below).
+const MAX_SESSION_FILES = 20;
+const MAX_SESSION_BYTES = 8_000_000;
 const CREDENTIALS_PATH = join(homedir(), ".kimi-code", "credentials", "kimi-code.json");
 // KIMI-01. Auth verdict from ~/.kimi-code/credentials/kimi-code.json ONLY — flat JSON, never a
 // network call. expires_at is epoch SECONDS (not ISO like grok). Non-empty refresh_token dominates
@@ -101,6 +118,102 @@ export const kimi = {
         return { command: this.headlessCommand(ctx.promptFile, a.model) };
     },
     parse: parseKimiResult,
+    collectUsage(cwd, sinceMs) {
+        try {
+            const real = realpathSync(cwd);
+            const home = join(homedir(), ".kimi-code");
+            const ws = JSON.parse(readFileSync(join(home, "workspaces.json"), "utf8"));
+            // a recreated workspace gets a new wd_* hash for the same root — fold every match
+            const wdDirs = Object.entries(ws.workspaces ?? {})
+                .filter(([, v]) => v && typeof v === "object" && v.root === real)
+                .map(([k]) => k);
+            // newest-first by mtime, bounded — mtime picks WHICH files to scan, never a record's cursor
+            const files = [];
+            for (const wd of wdDirs) {
+                const wdPath = join(home, "sessions", wd);
+                let sessions;
+                try {
+                    sessions = readdirSync(wdPath);
+                }
+                catch {
+                    continue;
+                }
+                for (const s of sessions) {
+                    if (!s.startsWith("session_"))
+                        continue;
+                    const agentsPath = join(wdPath, s, "agents");
+                    let agents;
+                    try {
+                        agents = readdirSync(agentsPath);
+                    }
+                    catch {
+                        continue;
+                    }
+                    for (const a of agents) {
+                        const p = join(agentsPath, a, "wire.jsonl");
+                        try {
+                            files.push({ path: p, m: statSync(p).mtimeMs });
+                        }
+                        catch {
+                            continue;
+                        }
+                    }
+                }
+            }
+            files.sort((a, b) => b.m - a.m);
+            let input = 0, output = 0, kept = false;
+            let cacheRead, cacheWrite;
+            for (const { path: fp } of files.slice(0, MAX_SESSION_FILES)) {
+                let text;
+                try {
+                    text = readFileSync(fp, "utf8").slice(0, MAX_SESSION_BYTES);
+                }
+                catch {
+                    continue;
+                }
+                for (const line of text.split("\n")) {
+                    if (!line.trim())
+                        continue;
+                    let recRaw;
+                    try {
+                        recRaw = JSON.parse(line);
+                    }
+                    catch {
+                        continue;
+                    }
+                    const rec = recRaw;
+                    // exact type+scope pin: the step.end loop event ECHOES the same usage (double-count),
+                    // and any scope other than the live-verified "turn" has unknown fold semantics — skip
+                    if (rec.type !== "usage.record" || rec.usageScope !== "turn")
+                        continue;
+                    if (typeof rec.time !== "number" || !Number.isFinite(rec.time) || rec.time < sinceMs)
+                        continue;
+                    const u = rec.usage;
+                    if (!u || typeof u !== "object")
+                        continue;
+                    const uu = u;
+                    // ambiguous row (core fields missing/non-numeric) resolves to unmetered, never 0
+                    if (typeof uu.inputOther !== "number" || typeof uu.output !== "number")
+                        continue;
+                    input += uu.inputOther;
+                    output += uu.output;
+                    if (typeof uu.inputCacheRead === "number")
+                        cacheRead = (cacheRead ?? 0) + uu.inputCacheRead;
+                    if (typeof uu.inputCacheCreation === "number")
+                        cacheWrite = (cacheWrite ?? 0) + uu.inputCacheCreation;
+                    kept = true;
+                }
+            }
+            if (!kept)
+                return undefined; // nothing matched ⇒ unmetered, never {input:0,…}
+            const out = { input, output, ...(cacheRead !== undefined ? { cacheRead } : {}), ...(cacheWrite !== undefined ? { cacheWrite } : {}) };
+            const p = TokenUsageSchema.safeParse(out);
+            return p.success ? p.data : undefined;
+        }
+        catch {
+            return undefined; // missing home/workspaces.json / any throw ⇒ fail open
+        }
+    },
     listModels: async () => {
         const r = spawnSync("kimi", ["provider", "list", "--json"], { encoding: "utf8", timeout: 15000 });
         return r.error || r.status !== 0 ? [] : parseKimiModels(r.stdout || "");

package/dist/route/router.js

@@ -67,6 +67,43 @@ function ladderFor(task, entry) {
     const escalate = task.routingHints?.escalate ?? entry?.escalate ?? true;
     return escalate ? ["retry", "escalate", "consult", "human"] : ["retry", "consult", "human"];
 }
+// v1.58 frontier spread (operator ruling .planning/rulings/2026-07-18-frontier-spread-credits.md):
+// every sub channel marginal-cost-ranks 0, so tier-equal frontier ties fell through all sort keys
+// to discovery order — the first sub channel (claude-code:fable) served every frontier auto pick,
+// and same-day quota exhaustion on that one channel interrupted two live pipeline agents. A
+// deterministic task-keyed rotation now spreads each residual frontier tie across its whole tie
+// group, so sol/k3-class channels serve frontier work as first-class candidates. Strictly the LAST
+// tiebreak: it permutes only maximal runs already tied on every key above it (prefer band,
+// marginal cost, tier — plus exploration bonus and learned score on the learned path), and only
+// runs of zero-marginal-cost frontier SUB channels outside any prefer entry. Pins return upstream,
+// denies filter upstream, prefer order is operator-explicit — none are touched.
+// ponytail: frontier runs only — the ruled scope (ruling §1); spreading mid/cheap ties too = drop
+// the tier guard. Rotation, not utilization: profile-driven spread would be inert exactly where
+// the concentration bites (cold profiles, plan-time static routing, learned:off).
+const spreadOffset = (task) => {
+    let h = 0;
+    for (const ch of `${task.id}\n${task.goal}`)
+        h = (h * 31 + ch.charCodeAt(0)) >>> 0;
+    return h;
+};
+function spreadFrontierTies(sorted, task, prefer, tied) {
+    const out = [...sorted];
+    const preferLen = prefer?.length ?? 0;
+    let i = 0;
+    while (i < out.length) {
+        let j = i + 1;
+        while (j < out.length && tied(out[i], out[j]))
+            j++;
+        const len = j - i;
+        if (len > 1 && out[i].tier === "frontier" && marginalCostRank(out[i]) === 0 && preferIndex(out[i], prefer) === preferLen) {
+            const run = out.slice(i, j);
+            const k = spreadOffset(task) % len;
+            out.splice(i, len, ...run.slice(k), ...run.slice(0, k));
+        }
+        i = j;
+    }
+    return out;
+}
 function withoutExcluded(channels, exclude) {
     if (!exclude?.size)
         return channels;
@@ -174,8 +211,9 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         for (const p of prefer ?? [])
             preflightPrefer(p);
     // key order is a contract: prefer > marginal cost > tier (cheapest sufficient) > learned score (v1.6 ROUTE-06)
-    // > discovery order (same-tier fairness, D2). The learned score is the LAST key — it decides only the
-    // discovery-order tail, never a pin/floor/prefer/cost/tier boundary (they all sort above it, ROUTE-08).
+    // > frontier spread (v1.58) > discovery order (same-tier fairness, D2). The learned score decides only the
+    // discovery-order tail, never a pin/floor/prefer/cost/tier boundary (they all sort above it, ROUTE-08);
+    // the spread rotates only what would otherwise fall to discovery order.
     const staticCmp = (a, b) => preferIndex(a, prefer) - preferIndex(b, prefer) || marginalCostRank(a) - marginalCostRank(b) || TIER_RANK[a.tier] - TIER_RANK[b.tier];
     const eligibleRaw = channels.filter((c) => TIER_RANK[c.tier] >= TIER_RANK[minTier]);
     if (!eligibleRaw.length) {
@@ -192,6 +230,11 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     let eligible;
     let deviation;
     let learnedChosen = "";
+    let spreadDecided = false;
+    // v1.58: the spread is applied identically on both sort paths (and to the deviation baseline), so
+    // an empty/cold profile stays byte-identical to the 3-arg call (ROUTE-07) and a deviation always
+    // means learned evidence moved the pick — never the spread mislabeled as learning.
+    const spreadStatic = (sorted) => spreadFrontierTies(sorted, task, prefer, (a, b) => staticCmp(a, b) === 0);
     if (profile) {
         // scores precomputed ONCE over the eligible set — never inside the comparator (Pitfall 1).
         // ponytail: no epsilon — two finite scores subtract to a finite number (Phase 12 totality); an
@@ -210,7 +253,7 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         const off = exploreOff(task, cfg, exploreCtx);
         const bonuses = new Map(eligibleRaw.map((c) => [channelKey(c), off ? 0 : explorationBonus(cellOf(profile, task.shape, channelKey(c), c.channel), cap)]));
         const bonusOf = (c) => bonuses.get(channelKey(c));
-        const staticWinner = [...eligibleRaw].sort(staticCmp)[0];
+        const staticWinner = spreadStatic([...eligibleRaw].sort(staticCmp))[0];
         // Phase 34 ROUTE-17: prefer becomes a BAND + group-rep keys so exploration fires ACROSS prefer
         // entries, while intra-entry order (cost > tier > bonus > score) and every cold path stay byte-identical.
         // Cold reduces to preferIndex || cost || tier ≡ staticCmp (proof P1); rep keys use the group HEAD so
@@ -232,7 +275,11 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         }));
         const kOf = (c) => keyOf.get(channelKey(c));
         const firstDiff = (a, b) => kOf(a).findIndex((v, i) => v !== kOf(b)[i]);
-        eligible = [...eligibleRaw].sort((a, b) => { const i = firstDiff(a, b); return i === -1 ? 0 : kOf(a)[i] - kOf(b)[i]; });
+        const sortedByKey = [...eligibleRaw].sort((a, b) => { const i = firstDiff(a, b); return i === -1 ? 0 : kOf(a)[i] - kOf(b)[i]; });
+        // spread runs tied on the FULL learned key (bonus/score included) — a warm score or live probe
+        // bonus still decides its tie exactly as before; the spread rotates only the residual all-equal runs.
+        eligible = spreadFrontierTies(sortedByKey, task, prefer, (a, b) => firstDiff(a, b) === -1);
+        spreadDecided = channelKey(eligible[0]) !== channelKey(sortedByKey[0]);
         const w = eligible[0];
         const ru = channelKey(staticWinner) !== channelKey(w) ? staticWinner : eligible[1];
         // Phase 34 ROUTE-17: first-differing-key markers — probe when a rep or intra bonus key decided.
@@ -250,7 +297,9 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
         }
     }
     else {
-        eligible = eligibleRaw.sort(staticCmp); // ROUTE-07/09: literally the v1.5 code path — dead code cannot deviate
+        const sortedStatic = eligibleRaw.sort(staticCmp); // ROUTE-07/09: the v1.5 key order, spread applied as the last key
+        eligible = spreadStatic(sortedStatic);
+        spreadDecided = channelKey(eligible[0]) !== channelKey(sortedStatic[0]);
     }
     const bound = qualityBound(quality, advisoryFloor, taskFloorRaw) ??
         (taskFloor && TIER_RANK[taskFloor] >= TIER_RANK[baseTier] ? `floor ${taskFloor} (task hint${src})` :
@@ -261,8 +310,10 @@ export function route(task, cfg, channels, profile, preferCtx, exclude, exploreC
     const preferVia = preferFromAuto(task.shape, preferCtx)
         ? `via prefer (auto-modernized ${preferCtx.autoPrefer.derivedAt.slice(0, 10)})`
         : "via prefer";
-    const chosenBy = learnedChosen || (prefer && preferIndex(eligible[0], prefer) < prefer.length
-        ? preferVia : "cheapest sufficient tier");
+    // a spread-decided winner is never inside a prefer band (the spread skips those runs), so the
+    // three arms below are mutually exclusive by construction
+    const chosenBy = learnedChosen || (spreadDecided ? "via frontier spread"
+        : prefer && preferIndex(eligible[0], prefer) < prefer.length ? preferVia : "cheapest sufficient tier");
     maybeSlaLint(lints, task, profile, slaMinutes, eligible[0]);
     return { assignment: toAssignment(eligible[0]), ladder: ladderFor(task, entry), lints, provenance: `${degraded}${bound}, marginal-cost auto (${chosenBy})`, ...(deviation ? { deviation } : {}) };
 }

package/package.json

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