tickmarkr 1.47.0 → 1.48.1

package/dist/adapters/kimi.d.ts

@@ -0,0 +1,5 @@
+import { type WorkerAdapter, type WorkerResult } from "./types.js";
+export declare function kimiAuthed(credentialsText: string, nowMs: number): boolean;
+export declare function parseKimiModels(raw: string): string[];
+export declare function parseKimiResult(raw: string, nonce: string): WorkerResult;
+export declare const kimi: WorkerAdapter;

package/dist/adapters/kimi.js

@@ -0,0 +1,79 @@
+import { spawnSync } from "node:child_process";
+import { readFileSync } 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.
+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
+// an expired expires_at (device-code flow auto-refreshes). Missing/unreadable/garbage ⇒ authed:false.
+export function kimiAuthed(credentialsText, nowMs) {
+    try {
+        const j = JSON.parse(credentialsText);
+        if (typeof j.refresh_token === "string" && j.refresh_token.length > 0)
+            return true;
+        const exp = typeof j.expires_at === "number" ? j.expires_at * 1000 : Number(j.expires_at) * 1000;
+        return Number.isFinite(exp) && exp > nowMs;
+    }
+    catch {
+        return false;
+    }
+}
+// KIMI-04 listModels parse: `kimi provider list --json` models map keys. Fail-open to [].
+export function parseKimiModels(raw) {
+    try {
+        const j = JSON.parse(raw);
+        if (!j.models || typeof j.models !== "object")
+            return [];
+        return Object.keys(j.models).filter((id) => id.length > 0 && MODEL_ID_RE.test(id));
+    }
+    catch {
+        return [];
+    }
+}
+// KIMI-02 parse: kimi -p text output prefixes thinking/answer lines with `• `. Strip before trailer
+// scan so JSON.parse succeeds (research F-4 fixture). Resume line after the trailer is ignored by
+// last-valid-trailer-wins in parseWorkerResult.
+export function parseKimiResult(raw, nonce) {
+    const stripped = raw.split("\n").map((l) => l.replace(/^[\s]*[•*-]\s+/, "")).join("\n");
+    return parseWorkerResult(stripped, nonce);
+}
+export const kimi = {
+    id: "kimi",
+    vendor: "moonshot",
+    probeCwd: "neutral",
+    probe: async () => {
+        const h = probeVersion("kimi");
+        if (!h.installed)
+            return h;
+        let authed = false;
+        try {
+            authed = kimiAuthed(readFileSync(CREDENTIALS_PATH, "utf8"), Date.now());
+        }
+        catch { /* missing/unreadable ⇒ truthfully unauthed */ }
+        return authed
+            ? { ...h, note: "auth verified via ~/.kimi-code/credentials/kimi-code.json (free, no network)" }
+            : { ...h, authed: false, note: "no valid ~/.kimi-code/credentials/kimi-code.json (kimi login to fix)" };
+    },
+    channels: (cfg) => channelsFromConfig("kimi", cfg),
+    // KIMI-02 headless. -p prompt mode + -y yolo + explicit model. kimi 0.27.0 rejects -p combined
+    // with -y at parse time — tickmarkr still emits both per harness contract; interactive uses -y.
+    headlessCommand: (promptFile, model) => `kimi -p "$(cat ${shq(promptFile)})" -y --model ${shq(model)} --output-format text`,
+    interactiveCommand: (promptFile, model) => `kimi -y --model ${shq(model)} "$(cat ${shq(promptFile)})"`,
+    invoke(task, _cwd, a, ctx) {
+        return { command: this.headlessCommand(ctx.promptFile, a.model) };
+    },
+    parse: parseKimiResult,
+    listModels: async () => {
+        const r = spawnSync("kimi", ["provider", "list", "--json"], { encoding: "utf8", timeout: 15000 });
+        return r.error || r.status !== 0 ? [] : parseKimiModels(r.stdout || "");
+    },
+};

package/dist/adapters/registry.d.ts

@@ -1,6 +1,17 @@
 import { type TickmarkrConfig } from "../config/config.js";
 import { type RoutingProfile } from "../route/profile.js";
 import { type AuthHealth, type BillingChannel, type WorkerAdapter } from "./types.js";
+export declare const CANDIDATE_CLI_CATALOG: readonly ["kimi", "gemini", "qwen", "aider", "goose", "amp", "droid", "auggie", "crush"];
+export declare const REGISTERED_ADAPTER_BINARIES: readonly ["claude", "codex", "cursor-agent", "opencode", "pi", "grok"];
+export type CandidateCliDetection = {
+    binary: string;
+    version: string | undefined;
+};
+export declare function probeCandidateVersion(bin: string): string | undefined;
+export declare function detectCandidateClis(opts?: {
+    pathEnv?: string;
+}): CandidateCliDetection[];
+export declare function formatCandidateCliRow({ binary, version }: CandidateCliDetection): string;
 export declare function allAdapters(opts?: {
     fakeScriptPath?: string;
 }): WorkerAdapter[];

package/dist/adapters/registry.js

@@ -1,3 +1,4 @@
+import { spawnSync } from "node:child_process";
 import { existsSync, mkdtempSync, readFileSync, renameSync, statSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
@@ -14,14 +15,49 @@ import { codex } from "./codex.js";
 import { cursorAgent } from "./cursor-agent.js";
 import { FakeAdapter } from "./fake.js";
 import { grok } from "./grok.js";
+import { kimi } from "./kimi.js";
 import { opencode } from "./opencode.js";
 import { pi } from "./pi.js";
 import { channelKey, modelAuthed, QUOTA_RE } from "./types.js";
+// Agent-CLI binary names with no tickmarkr adapter — doctor sweeps these advisory-only (v1.48 T1).
+export const CANDIDATE_CLI_CATALOG = ["kimi", "gemini", "qwen", "aider", "goose", "amp", "droid", "auggie", "crush"];
+// Binaries probed by registered adapters — kept beside the catalog so a test can forbid overlap.
+export const REGISTERED_ADAPTER_BINARIES = ["claude", "codex", "cursor-agent", "opencode", "pi", "grok"];
+function candidateOnPath(bin, pathEnv) {
+    const r = spawnSync("which", [bin], { encoding: "utf8", env: { ...process.env, PATH: pathEnv } });
+    return r.status === 0 && r.stdout.trim().length > 0;
+}
+// Fail open: a broken candidate binary never throws and never fails doctor.
+export function probeCandidateVersion(bin) {
+    try {
+        const r = spawnSync(bin, ["--version"], { encoding: "utf8", timeout: 10000 });
+        if (r.error || r.status !== 0)
+            return undefined;
+        return (r.stdout || r.stderr).trim().split("\n")[0];
+    }
+    catch {
+        return undefined;
+    }
+}
+export function detectCandidateClis(opts = {}) {
+    const pathEnv = opts.pathEnv ?? process.env.PATH ?? "";
+    const out = [];
+    for (const bin of CANDIDATE_CLI_CATALOG) {
+        if (!candidateOnPath(bin, pathEnv))
+            continue;
+        out.push({ binary: bin, version: probeCandidateVersion(bin) });
+    }
+    return out;
+}
+export function formatCandidateCliRow({ binary, version }) {
+    const ver = version ?? "version unknown";
+    return `  ! ${binary.padEnd(14)} detected: ${ver} (no tickmarkr adapter — not routable)`;
+}
 export function allAdapters(opts = {}) {
-    // pi + grok appended LAST: same-tier ties resolve by discovery order (Phase 6 D2), so appending
-    // keeps the Phase 6 shape→channel matrix byte-identical; inserting anywhere else silently
-    // reassigns shapes on same-tier ties. grok is appended AFTER pi for the same reason.
-    const real = [claudeCode, codex, cursorAgent, opencode, pi, grok];
+    // pi + grok + kimi appended LAST: same-tier ties resolve by discovery order (Phase 6 D2), so
+    // appending keeps the Phase 6 shape→channel matrix byte-identical; inserting anywhere else
+    // silently reassigns shapes on same-tier ties. kimi is appended AFTER grok for the same reason.
+    const real = [claudeCode, codex, cursorAgent, opencode, pi, grok, kimi];
     const fakePath = opts.fakeScriptPath ?? process.env.TICKMARKR_FAKE_SCRIPT;
     return fakePath ? [new FakeAdapter(fakePath), ...real] : real;
 }
@@ -112,7 +148,7 @@ export async function probeModels(cfg, repoRoot, adapters, health, onProgress) {
         if (!h?.installed)
             return;
         // Tests inject FakeAdapter; never let an incidental default adapter spend a real token in the suite.
-        if (process.env.VITEST && [claudeCode, codex, cursorAgent, opencode, pi, grok].includes(a))
+        if (process.env.VITEST && [claudeCode, codex, cursorAgent, opencode, pi, grok, kimi].includes(a))
             return;
         const verdicts = {};
         const priorModelAuth = priorHealth?.[a.id]?.modelAuth;

package/dist/cli/commands/doctor.js

@@ -1,6 +1,6 @@
 import { writeFileSync } from "node:fs";
 import { join } from "node:path";
-import { allAdapters, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
+import { allAdapters, detectCandidateClis, formatCandidateCliRow, probeAll, probeModels, readAutoPrefer, servableExclusions, servabilityLine, writeDoctor } from "../../adapters/registry.js";
 import { BANNER } from "../../brand.js";
 import { tickmarkrDir, stateDirName } from "../../graph/graph.js";
 import { declaredModelWindow, hasWindowsConfig, modelLints, suggestOverlay, ttyVisual } from "../../adapters/model-lints.js";
@@ -33,6 +33,9 @@ function stylize(out) {
 }
 export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(), opts = {}) {
     const cfg = loadConfig(cwd);
+    // banner at START — the logo greets the operator before the ~60s probe wait, never trailing it (operator report 2026-07-17)
+    if (opts.banner !== false && visual())
+        process.stdout.write(BANNER);
     // stderr, live: auth probes are real LLM calls (up to 30s per configured model) and the CLI
     // otherwise prints nothing until the end — silence here reads as a hang (v1.33.1)
     console.error("probing installed agent CLIs — one short LLM call per configured model, may take a minute...");
@@ -62,6 +65,8 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
         const state = !h.installed ? "not installed" : `${h.version ?? "installed"}${h.note ? ` (${h.note})` : ""}`;
         return `  ${h.installed ? "✓" : "✗"} ${a.id.padEnd(14)} ${state}`;
     });
+    // v1.48 T1: advisory sweep for known agent CLIs with no adapter — never written to doctor.json health.
+    rows.push(...detectCandidateClis().map(formatCandidateCliRow));
     rows.push(`  ${HerdrDriver.available() ? "✓" : "✗"} herdr          ${HerdrDriver.available() ? "driver available (HERDR_ENV=1)" : "not detected — subprocess driver will be used"}`);
     // 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.
@@ -163,6 +168,5 @@ export async function doctor(_argv, cwd = process.cwd(), adapters = allAdapters(
     const modelSummary = modelStatus.length || preferStatus.length
         ? `\nmodel status:\n${[...modelStatus, ...preferStatus].join("\n")}`
         : "";
-    const body = stylize(`tickmarkr doctor — capability matrix:\n${rows.join("\n")}${modelSummary}${drift}\nwrote ${stateDirName(cwd)}/doctor.json`);
-    return opts.banner !== false && visual() ? BANNER + body : body;
+    return stylize(`tickmarkr doctor — capability matrix:\n${rows.join("\n")}${modelSummary}${drift}\nwrote ${stateDirName(cwd)}/doctor.json`);
 }

package/dist/cli/commands/init.js

@@ -210,6 +210,8 @@ export async function init(argv, cwd = process.cwd()) {
             yes: { type: "boolean" },
         },
     });
+    // banner at START on the visual surface — every init path, not just the wizard, and never trailing the probe (operator report 2026-07-17)
+    emitBanner();
     const gdir = values["global-dir"] ?? globalConfigDir();
     mkdirSync(gdir, { recursive: true });
     const notes = [];
@@ -262,8 +264,5 @@ export async function init(argv, cwd = process.cwd()) {
     }
     if (values.agent)
         await installAgentFiles(cwd, values.force ?? false, values.docs ?? false, notes);
-    const body = `${notes.join("\n")}\n${doc}\n${nextSteps(cwd, SCAFFOLD_SPEC)}\n${ENVIRONMENTS_FOOTER}`;
-    if (visual() && !bannerEmitted)
-        return BANNER + body;
-    return body;
+    return `${notes.join("\n")}\n${doc}\n${nextSteps(cwd, SCAFFOLD_SPEC)}\n${ENVIRONMENTS_FOOTER}`;
 }

package/dist/config/config.js

@@ -244,6 +244,18 @@ export const DEFAULT_CONFIG = {
             vendor: "xai", channel: "sub",
             models: { "grok-4.5": "mid", "grok-composer-2.5-fast": "cheap" },
         },
+        // Native kimi CLI (Phase 48). kimi-code/k3 → frontier: 81.2 FrontierSWE, 88.3 Terminal-Bench 2.1,
+        // top-3 across six coding benchmarks (research 2026-07-17, K3 released 2026-07-16).
+        // kimi-code/kimi-for-coding → mid (K2.7 Coding, 262k ctx). kimi-code/kimi-for-coding-highspeed →
+        // cheap (fast K2.7 variant). Ids live-verified `kimi provider list --json` 2026-07-17, kimi 0.27.0.
+        kimi: {
+            vendor: "moonshot", channel: "sub",
+            models: {
+                "kimi-code/k3": "frontier",
+                "kimi-code/kimi-for-coding": "mid",
+                "kimi-code/kimi-for-coding-highspeed": "cheap",
+            },
+        },
     },
     pricing: { cheap: 0.1, mid: 0.5, frontier: 2.5 },
     gates: { diffCap: DEFAULT_DIFF_CAP },

package/package.json

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

package/skills/tickmarkr-auto/SKILL.md

@@ -14,7 +14,7 @@ When working in a multi-agent terminal environment, decide your role before star
 
 - **Orchestrator:** your session was started to execute the mission. Rename your own tab/pane `ORCH · <version>` (short labels: ≤20 chars, `ROLE · token`) and run the loop below.
 - **Supervisor with a live orchestrator:** do not start a second run. Relay the mission to the existing orchestrator with a [verified handoff](#verified-handoffs-agent-to-agent-messaging), then supervise it as OVERSEER.
-- **Primary session without an orchestrator:** rename your own tab `OVERSEER · <version>` and your agent `overseer`, spawn one child orchestration session with `--permission-mode bypassPermissions`, label its tab `ORCH · <version>` and name its agent, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself. Before spawning, confirm any PREVIOUS orchestrator has stood down (monitors stopped, input box empty) and close its tab — the journal, records, and ledger hold the story; scrollback is disposable.
+- **Primary session without an orchestrator:** rename your own tab `OVERSEER · <version>` and your agent `overseer`, spawn one child orchestration session with `--permission-mode bypassPermissions`, label its tab `ORCH · <version>` and name its agent, give it the mission and these rules verbatim, then supervise it. Do not drive a duplicate single-tier run yourself. Before spawning, confirm any PREVIOUS orchestrator has stood down (monitors stopped, input box empty — dim ghost-text suggestions are UI, not queued input; ANSI-verify before alarming) and close its tab — the journal, records, and ledger hold the story; scrollback is disposable.
 
 Outside a multi-agent terminal environment, run the loop directly.
 
@@ -60,7 +60,7 @@ After sending, **confirm delivery** by reading the target pane and verifying the
 1. **Prepare** — confirm the target list. Run the [binary preflight](#binary-preflight-before-compile-or-run). Check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
 2. **Compile** — run `tickmarkr compile <spec-or-directory>`. Fix source-spec defects instead of editing the generated graph.
 3. **Plan** — run `tickmarkr plan`. Review routes, capability-floor warnings, and human gates before execution.
-4. **Run** — run `tickmarkr run`. Watch the run journal for its terminal event rather than polling agents. Resolve blocked interactions in the relevant agent session.
+4. **Run** — run `tickmarkr run`. Watch the run journal for its terminal event rather than polling agents — a self-terminating poll (`until grep -q '"event":"run-end"' <state-dir>/runs/<runId>/journal.jsonl; do sleep 20; done`), never `tail -F | grep -m1` (wedges on the journal's final line) and never a pane-level done wait (turn-end flaps). Resolve blocked interactions in the relevant agent session.
 5. **Verify and consolidate** — continue only after a green run. A run is green when the run-end event exists in the journal AND the tip verify is not "failed". Tickmarkr consolidates accepted work on `tickmarkr/<runId>` and never signs off to the main branch. A human controls any later release merge.
 6. **Record** — write `tickmarkr report <runId> --md` beside the source spec and commit the execution record when the repository tracks those records.
 7. **Continue** — move to the next requested target. If a target fails or is parked, stop with the journal evidence rather than silently skipping it.

package/skills/tickmarkr-loop/SKILL.md

@@ -53,13 +53,13 @@ After sending, **confirm delivery** by reading the target pane and verifying the
 ## Stand-down (mission end and retirement)
 
 - **Orchestrator, on terminal state** (green, failed, or parked), after the record commit and operator notification: stop every monitor and background task you started, print one final stand-down line, and leave NOTHING queued in your input box. A finished session with an armed watcher or pre-filled input is a loaded gun — a retired v1.40 orchestrator sat idle with "merge … tag, publish" unsent in its input; one stray Enter would have shipped a duplicate release.
-- **Supervisor, when a mission completes** (and always before spawning the next orchestrator): verify the orchestrator stood down, then close its tab. The journal, execution record, OBS ledger, and memory hold the story; pane scrollback is disposable. Never leave a retired agent idle with watchers armed.
+- **Supervisor, when a mission completes** (and always before spawning the next orchestrator): verify the orchestrator stood down, then close its tab. Seeming input-box text in a retired pane can be the TUI's dim ghost-text suggestion, not queued input — confirm with an ANSI read (dim escape around the text) or type-one-char-and-read-back before treating it as the loaded gun; close the tab either way. The journal, execution record, OBS ledger, and memory hold the story; pane scrollback is disposable. Never leave a retired agent idle with watchers armed.
 
 ## The loop
 
 1. **Prepare** — start from the requested spec. Run the [binary preflight](#binary-preflight-before-compile-or-run). Check `git status`, confirm no tickmarkr run is active, and work from a non-main branch.
 2. **Compile** — run `tickmarkr compile <spec>`. Correct compilation errors in the spec, never in the generated graph.
 3. **Plan** — run `tickmarkr plan`. Review the routing table, capability-floor warnings, and every human gate, including work that each gate blocks.
-4. **Run** — run `tickmarkr run`. Watch the run journal for its terminal event rather than repeatedly polling agents. Resolve blocked interactions in the agent session; do not turn them into proxy questions.
+4. **Run** — run `tickmarkr run`. Watch the run journal for its terminal event rather than repeatedly polling agents. Use a self-terminating poll — `until grep -q '"event":"run-end"' <state-dir>/runs/<runId>/journal.jsonl; do sleep 20; done` — never `tail -F | grep -m1` (run-end is the journal's last line, so tail never notices the broken pipe and the watcher hangs forever) and never a pane-level done wait (it fires on every agent turn end, not mission end). Resolve blocked interactions in the agent session; do not turn them into proxy questions.
 5. **Verify and consolidate** — accept only a green run. A run is green when the run-end event exists in the journal AND the tip verify is not "failed". Tickmarkr consolidates accepted task work on `tickmarkr/<runId>`; it never signs off to the main branch. A human may later merge that integration branch through the repository's normal release process.
 6. **Record** — write `tickmarkr report <runId> --md` beside the source spec and commit the execution record when the repository tracks those records. Then [stand down](#stand-down-mission-end-and-retirement).