akm-cli 0.9.6 → 0.9.8-beta.1

package/dist/indexer/search/search-source.js

@@ -158,12 +158,6 @@ export function resolveEntryContentDir(entry) {
     }
     return dir;
 }
-/**
- * Convenience: returns just the directory paths, preserving priority order.
- */
-export function resolveAllStashDirs(overrideStashDir) {
-    return resolveSourceEntries(overrideStashDir).map((s) => s.path);
-}
 /**
  * Find which source a file path belongs to.
  *
@@ -187,13 +181,6 @@ export function findSourceForPath(filePath, sources) {
     }
     return best;
 }
-/**
- * Return the primary stash source (first entry in the list).
- * This is the user's working stash and the default destination for clone.
- */
-export function getPrimarySource(sources) {
-    return sources[0];
-}
 // ── Editability ─────────────────────────────────────────────────────────────
 /**
  * Determine whether AKM policy allows modifying this exact file in place.

package/dist/indexer/usage/usage-events.js

@@ -1,6 +1,13 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Usage event helpers for telemetry and utility-based re-ranking.
+ *
+ * Schema (created by ensureUsageEventsSchema):
+ *   id, event_type, query, entry_id (nullable), entry_ref, signal, metadata, source, created_at
+ */
+import { rethrowIfTestIsolationError } from "../../core/errors.js";
 const USAGE_EVENT_SOURCES = new Set(["user", "improve", "task", "audit", "unknown"]);
 /**
  * Resolve subprocess provenance without treating an invalid value as user
@@ -50,7 +57,8 @@ export function insertUsageEvent(db, event) {
         db.prepare(`INSERT INTO usage_events (event_type, query, entry_id, entry_ref, signal, metadata, source)
        VALUES (?, ?, ?, ?, ?, ?, ?)`).run(event.event_type, event.query ?? null, event.entry_id ?? null, event.entry_ref ?? null, event.signal ?? null, event.metadata ?? null, event.source ?? "unknown");
     }
-    catch {
+    catch (error) {
+        rethrowIfTestIsolationError(error);
         /* fire-and-forget: silently ignore errors */
     }
 }

package/dist/indexer/walk/walker.js

@@ -167,13 +167,16 @@ function isInsideGitRepo(dir) {
     return false;
 }
 /**
- * Recursively yield every `.md` file under `root`.
+ * Recursively collect every `.md` file under `root`.
  *
- * Shared by graph-extraction and memory-inference so the generator logic
- * lives in exactly one place. Silently skips directories that cannot be
- * read (e.g. permission errors).
+ * Shared by graph-extraction and memory-inference so the walk logic lives in
+ * exactly one place. Mirrors the `complete` tracking of the other walkers in
+ * this file: a directory that cannot be read makes the result incomplete
+ * instead of silently looking like a clean, empty scan.
  */
-export function* walkMarkdownFiles(root) {
+export function walkMarkdownFiles(root) {
+    const files = [];
+    let complete = true;
     const stack = [root];
     while (stack.length > 0) {
         const current = stack.pop();
@@ -184,6 +187,7 @@ export function* walkMarkdownFiles(root) {
             entries = fs.readdirSync(current, { withFileTypes: true });
         }
         catch {
+            complete = false;
             continue;
         }
         for (const entry of entries) {
@@ -194,10 +198,11 @@ export function* walkMarkdownFiles(root) {
                 stack.push(full);
             }
             else if (entry.isFile() && entry.name.toLowerCase().endsWith(".md")) {
-                yield full;
+                files.push(full);
             }
         }
     }
+    return { files, complete };
 }
 /** Manual walk for non-git directories. */
 function walkStashManual(stashRoot, options) {

package/dist/integrations/harnesses/claude/result-extractor.js

@@ -1,21 +1,36 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function asNonEmptyString(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-/** JSON.parse that returns undefined instead of throwing. */
-function tryParseJson(raw) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-}
+/**
+ * Claude Code CLI result extractor (Codex round-3 finding A; plan §"The adapter
+ * contract" step 3 / §"Structured-output normalization", tier "native-json").
+ *
+ * Normalizes one raw {@link AgentRunResult} from a headless `claude -p` run into
+ * `{ text, sessionId? }` — the {@link AgentResultExtraction} seam. The engine's
+ * shared schema-validation / retry-until-valid loop runs *after* this; the
+ * extractor only strips transport framing.
+ *
+ * A schema-bearing unit is dispatched with `--output-format json` (see
+ * `./agent-builder.ts`), so stdout is Claude Code's documented RESULT ENVELOPE —
+ * a single JSON object:
+ *
+ *   {"type":"result","subtype":"success","is_error":false,
+ *    "result":"<final answer>","session_id":"<uuid>","total_cost_usd":…,"usage":…}
+ *
+ * The final answer the model produced lives in `result` (a string); the
+ * harness-native session id in `session_id`, stored opportunistically on the
+ * unit row for `claude --resume <id>` (akm never depends on it —
+ * `workflow_run_units` stays the source of truth).
+ *
+ * A SCHEMALESS unit is dispatched WITHOUT `--output-format json`, so stdout is
+ * plain text — passed through verbatim (untrimmed) so the schemaless dispatch
+ * path is byte-identical to the pre-extractor behaviour. Only a genuine result
+ * envelope (a `type: "result"` object, or one carrying both a string `result`
+ * and a `session_id`) is unwrapped; anything else degrades to raw pass-through,
+ * so a point-release envelope rename fails soft (the engine's embedded-JSON
+ * parsing still runs downstream for schema units) rather than hard.
+ */
+import { asNonEmptyString, isRecord, tryParseJson } from "../../../core/common.js";
 /**
  * Is this parsed object Claude Code's `--output-format json` RESULT ENVELOPE
  * (rather than a bare JSON answer a schema unit produced without the flag)? A

package/dist/integrations/harnesses/codex/result-extractor.js

@@ -1,12 +1,49 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function asNonEmptyString(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
+/**
+ * OpenAI Codex CLI result extractor (P2, plan §"The adapter contract" step 3 /
+ * §"Structured-output normalization").
+ *
+ * Normalizes the raw {@link AgentRunResult} of a `codex exec --json` run into
+ * `{ text, sessionId? }` ({@link AgentResultExtraction}). Schema validation and
+ * the retry-until-valid loop stay in the engine, shared across harnesses —
+ * this module only strips transport framing.
+ *
+ * `--json` emits ONE JSON event per stdout line. Two documented event dialects
+ * exist across codex versions; the adapter contract localizes that churn here,
+ * so both are handled:
+ *
+ * Legacy protocol (envelope with an `msg` object):
+ *   {"id":"0","msg":{"type":"session_configured","session_id":"<uuid>", ...}}
+ *   {"id":"1","msg":{"type":"agent_message","message":"<text>"}}
+ *   {"id":"1","msg":{"type":"task_complete","last_agent_message":"<text>"}}
+ *
+ * Newer experimental-JSON protocol (flat `type` field):
+ *   {"type":"thread.started","thread_id":"<id>"}
+ *   {"type":"item.completed","item":{"id":"item_1","type":"agent_message","text":"<text>"}}
+ *   {"type":"turn.completed","usage":{...}}
+ *
+ * Extraction rules:
+ *   - text: `task_complete.last_agent_message` wins when present (it is the
+ *     harness's own "final answer" designation); otherwise the LAST
+ *     agent-message event seen; otherwise the trimmed raw stdout (plain-text
+ *     fallback for runs without `--json`, or unrecognized formats — the
+ *     engine's `parseEmbeddedJsonResponse` tier still gets a fair input).
+ *   - sessionId: `session_configured.session_id` / `thread.started.thread_id`,
+ *     falling back to any sessionId the spawn layer already attached. Stored
+ *     opportunistically on the unit row for `codex exec resume <id>`; akm
+ *     never depends on it (plan §"Session, MCP, and identity").
+ *
+ * Non-event JSON lines (e.g. a bare JSON answer printed without framing) are
+ * ignored by the event scan and land in the raw-stdout fallback untouched.
+ *
+ * Registered: `codexResultExtractor` is `CodexHarness.resultExtractor`
+ * (`./index.ts`); the engine resolves it via `getHarness()` in
+ * `workflows/exec/native-executor.ts` to normalize agent-unit stdout before
+ * schema validation.
+ */
+import { asNonEmptyString, isRecord } from "../../../core/common.js";
 /** Interpret one parsed JSONL event in either codex event dialect. */
 function interpretEvent(event) {
     // Legacy protocol: {"id":..., "msg":{"type": ...}}

package/dist/integrations/harnesses/copilot/result-extractor.js

@@ -1,9 +1,45 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+/**
+ * GitHub Copilot CLI result extractor (P2, plan §"The adapter contract"
+ * step 3 / §"Structured-output normalization", tier "native-json").
+ *
+ * Normalizes one raw {@link AgentRunResult} from a headless `copilot` run
+ * into `{ text, sessionId? }` — the {@link AgentResultExtraction} seam. The
+ * engine's shared schema-validation / retry-until-valid loop runs *after*
+ * this; the extractor only strips transport framing.
+ *
+ * Copilot's stdout takes one of three shapes depending on flags/version
+ * (`--output-format json` per the capability matrix), all handled here:
+ *
+ *  1. **Single JSON document** — a result envelope, e.g.
+ *     `{"type":"result","session_id":"…","result":"<final answer>"}`.
+ *     Pretty-printed multi-line JSON is included (whole-stdout parse is
+ *     attempted first). Only objects carrying a transport marker (a `type`
+ *     discriminator or a session-id field) are unwrapped; a bare JSON answer
+ *     with no marker (a schema unit's `{"result":"ok"}`) is passed through
+ *     raw so the engine's schema validator sees the whole object.
+ *  2. **JSONL event stream** — one JSON object per line
+ *     (`session.start` / assistant `message` / `result` events); the LAST
+ *     text-bearing event wins, the first session-id-bearing event supplies
+ *     the session id. Non-JSON banner lines are skipped.
+ *  3. **Plain text** — no JSON anywhere; trimmed stdout passes through
+ *     verbatim (the engine's embedded-JSON parsing still runs downstream for
+ *     schema units).
+ *
+ * Key names are matched tolerantly (`result`/`response`/`text`/`output`/
+ * `content`/`message`, snake_case and camelCase session-id variants) so
+ * point-release renames in the CLI's envelope degrade to the plain-text
+ * fallback instead of hard-failing — version churn stays contained in this
+ * one file, per the adapter contract.
+ *
+ * Registered: `copilotResultExtractor` is `CopilotHarness.resultExtractor`
+ * (`./index.ts`); the engine resolves it via `getHarness()` in
+ * `workflows/exec/native-executor.ts` to normalize agent-unit stdout before
+ * schema validation.
+ */
+import { isRecord, tryParseJson } from "../../../core/common.js";
 /** Keys that may carry the final answer, in precedence order. */
 const TEXT_KEYS = ["result", "response", "text", "output", "content", "message"];
 /** Keys that may carry the harness-native session id, in precedence order. */
@@ -90,15 +126,6 @@ function isTransportEnvelope(value) {
         return true;
     return extractSessionId(value) !== undefined;
 }
-/** JSON.parse that returns undefined instead of throwing. */
-function tryParseJson(raw) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-}
 /**
  * Normalize a raw copilot run result into `{ text, sessionId? }`.
  * See the module doc for the three stdout shapes handled.

package/dist/integrations/harnesses/gemini/result-extractor.js

@@ -1,9 +1,46 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+/**
+ * Gemini CLI result extractor (P2, plan §"The adapter contract" step 3 /
+ * §"Structured-output normalization", tier "native-json").
+ *
+ * Normalizes one raw {@link AgentRunResult} from a headless `gemini` run into
+ * `{ text, sessionId? }` — the {@link AgentResultExtraction} seam. The
+ * engine's shared schema-validation / retry-until-valid loop runs *after*
+ * this; the extractor only strips transport framing.
+ *
+ * Gemini's stdout takes one of three shapes depending on flags/version
+ * (`--output-format json` per the capability matrix), all handled here:
+ *
+ *  1. **Single JSON document** — the documented `--output-format json`
+ *     envelope, e.g. `{"response":"<final answer>","stats":{...}}` (an
+ *     `error` variant carries `{error:{type,message,code}}` and no usable
+ *     response — that degrades to the raw-stdout fallback so the engine's
+ *     failure handling sees the whole envelope). Pretty-printed multi-line
+ *     JSON is included (whole-stdout parse is attempted first).
+ *  2. **JSONL event stream** (`--output-format stream-json`) — one JSON
+ *     object per line; the LAST text-bearing event wins, the first
+ *     session-id-bearing event supplies the session id. Non-JSON banner
+ *     lines ("Loaded cached credentials.", update notices) are skipped.
+ *  3. **Plain text** — no JSON anywhere; trimmed stdout passes through
+ *     verbatim (the engine's embedded-JSON parsing still runs downstream for
+ *     schema units).
+ *
+ * Key names are matched tolerantly (`response` first — Gemini's documented
+ * envelope key — then `result`/`text`/`output`/`content`/`message`;
+ * snake_case and camelCase session-id variants) so point-release renames in
+ * the CLI's envelope degrade to the plain-text fallback instead of
+ * hard-failing — version churn stays contained in this one file, per the
+ * adapter contract. The session id feeds `--resume <id>` opportunistically;
+ * `workflow_run_units` remains the durable source of truth.
+ *
+ * Registered: `geminiResultExtractor` is `GeminiHarness.resultExtractor`
+ * (`./index.ts`); the engine resolves it via `getHarness()` in
+ * `workflows/exec/native-executor.ts` to normalize agent-unit stdout before
+ * schema validation.
+ */
+import { isRecord, tryParseJson } from "../../../core/common.js";
 /**
  * Keys that may carry the final answer, in precedence order. `response` is
  * Gemini's documented `--output-format json` envelope key.
@@ -64,15 +101,6 @@ function extractSessionId(value) {
     }
     return undefined;
 }
-/** JSON.parse that returns undefined instead of throwing. */
-function tryParseJson(raw) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-}
 /**
  * Normalize a raw gemini run result into `{ text, sessionId? }`.
  * See the module doc for the three stdout shapes handled.

package/dist/integrations/harnesses/index.js

@@ -96,10 +96,6 @@ export const VALID_HARNESS_IDS = Object.freeze(HARNESS_REGISTRY.map((h) => h.id)
 export const SESSION_LOG_HARNESSES = HARNESS_REGISTRY.filter(isSessionLogHarness);
 /** Harnesses that can be dispatched as an agent CLI / SDK. */
 export const AGENT_DISPATCH_HARNESSES = HARNESS_REGISTRY.filter((h) => h.capabilities.agentDispatch);
-/** Harnesses that can import an existing harness config into akm. */
-export const CONFIG_IMPORTER_HARNESSES = HARNESS_REGISTRY.filter((h) => h.capabilities.configImport);
-/** Harnesses that participate in `akm setup` detection. */
-export const DETECTION_HARNESSES = HARNESS_REGISTRY.filter((h) => h.capabilities.detection);
 /**
  * Resolve an exact harness id to its descriptor, or `undefined` if unknown.
  */

package/dist/integrations/harnesses/openhands/result-extractor.js

@@ -1,15 +1,56 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+/**
+ * OpenHands CLI result extractor (P2, plan §"The adapter contract" step 3 /
+ * §"Structured-output normalization", tier "native-json").
+ *
+ * Normalizes one raw {@link AgentRunResult} from a headless
+ * `openhands --headless --json` run into `{ text, sessionId? }` — the
+ * {@link AgentResultExtraction} seam. The engine's shared schema-validation /
+ * retry-until-valid loop runs *after* this; the extractor only strips
+ * transport framing.
+ *
+ * With `--json` OpenHands emits ONE JSON event per stdout line — its
+ * action/observation event stream, e.g.:
+ *
+ *   {"id":0,"source":"user","action":"message","args":{"content":"<task>"},"message":"<task>"}
+ *   {"id":1,"source":"agent","action":"run","args":{"command":"ls"},"message":"Running command: ls"}
+ *   {"id":2,"source":"agent","observation":"run","content":"README.md","message":"Command `ls` executed."}
+ *   {"id":3,"source":"agent","action":"message","args":{"content":"<answer>"},"message":"<answer>"}
+ *   {"id":4,"source":"agent","action":"finish","args":{"final_thought":"<answer>","outputs":{}},"message":"..."}
+ *
+ * Extraction rules ("parse JSONL final message" per the capability matrix):
+ *   - text: the LAST agent-sourced *message-bearing* event wins. Only two
+ *     event kinds carry the agent's answer: `action:"message"`
+ *     (`args.content`, falling back to the top-level `message` mirror) and
+ *     `action:"finish"` (`args.final_thought`/`args.thought`, falling back to
+ *     `message`). User echoes, observations, and tool actions (`run`, `edit`,
+ *     …, whose `message` is progress noise like "Running command: ls") never
+ *     contribute.
+ *   - sessionId: the FIRST id-bearing event supplies it (`session_id`,
+ *     `sessionId`, `sid`, `conversation_id`), falling back to any sessionId
+ *     the spawn layer already attached. Stored opportunistically on the unit
+ *     row; per the matrix OpenHands resume is workspace-state, so akm never
+ *     depends on it (plan §"Session, MCP, and identity across harnesses").
+ *
+ * Also handled, so version churn stays contained in this one file (per the
+ * adapter contract):
+ *   - a single whole-stdout JSON document (or a spawn-layer `result.parsed`
+ *     value) is interpreted with the same rules;
+ *   - plain text (no `--json`, or an unrecognized envelope) passes through
+ *     trimmed — the engine's embedded-JSON parsing still runs downstream for
+ *     schema units;
+ *   - non-JSON banner lines interleaved in the stream are skipped.
+ *
+ * Registered: `openhandsResultExtractor` is `OpenhandsHarness.resultExtractor`
+ * (`./index.ts`); the engine resolves it via `getHarness()` in
+ * `workflows/exec/native-executor.ts` to normalize agent-unit stdout before
+ * schema validation.
+ */
+import { asNonEmptyString, isRecord, tryParseJson } from "../../../core/common.js";
 /** Keys that may carry the harness-native session id, in precedence order. */
 const SESSION_KEYS = ["session_id", "sessionId", "sid", "conversation_id"];
-/** Return a non-empty string, else undefined. */
-function nonEmptyString(value) {
-    return typeof value === "string" && value.length > 0 ? value : undefined;
-}
 /**
  * Extract the agent's answer text from one parsed OpenHands event, if the
  * event is one of the two message-bearing kinds (see module doc). Everything
@@ -25,31 +66,22 @@ function extractAgentText(event) {
         return undefined;
     const args = isRecord(event.args) ? event.args : undefined;
     if (event.action === "message") {
-        return nonEmptyString(args?.content) ?? nonEmptyString(event.message);
+        return asNonEmptyString(args?.content) ?? asNonEmptyString(event.message);
     }
     if (event.action === "finish") {
-        return nonEmptyString(args?.final_thought) ?? nonEmptyString(args?.thought) ?? nonEmptyString(event.message);
+        return asNonEmptyString(args?.final_thought) ?? asNonEmptyString(args?.thought) ?? asNonEmptyString(event.message);
     }
     return undefined;
 }
 /** Extract a harness-native session id from one parsed JSON value, if any. */
 function extractSessionId(event) {
     for (const key of SESSION_KEYS) {
-        const candidate = nonEmptyString(event[key]);
+        const candidate = asNonEmptyString(event[key]);
         if (candidate)
             return candidate;
     }
     return undefined;
 }
-/** JSON.parse that returns undefined instead of throwing. */
-function tryParseJson(raw) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-}
 /**
  * Normalize a raw openhands run result into `{ text, sessionId? }`.
  * See the module doc for the stdout shapes handled.

package/dist/integrations/harnesses/pi/result-extractor.js

@@ -1,9 +1,51 @@
 // This Source Code Form is subject to the terms of the Mozilla Public
 // License, v. 2.0. If a copy of the MPL was not distributed with this
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
+/**
+ * Pi coding-agent CLI result extractor (P2, plan §"The adapter contract"
+ * step 3 / §"Structured-output normalization", tier "native-json").
+ *
+ * Normalizes one raw {@link AgentRunResult} from a headless `pi` run into
+ * `{ text, sessionId? }` — the {@link AgentResultExtraction} seam. The
+ * engine's shared schema-validation / retry-until-valid loop runs *after*
+ * this; the extractor only strips transport framing.
+ *
+ * With `--mode json` (the capability matrix's structured mode) Pi emits ONE
+ * JSON event per stdout line — the agent-session event stream, e.g.:
+ *
+ *   {"type":"session_start","session_id":"<id>"}
+ *   {"type":"agent_start"}
+ *   {"type":"message_start","message":{"role":"assistant","content":[]}}
+ *   {"type":"message_end","message":{"role":"assistant","content":[{"type":"text","text":"<text>"}]}}
+ *   {"type":"agent_end","messages":[{"role":"assistant","content":[...]}]}
+ *
+ * Extraction rules:
+ *   - text: the LAST assistant text-bearing event wins (`message_end` bodies;
+ *     an `agent_end` transcript's final assistant message; tolerant flat
+ *     `role:"assistant"` events). User-role echoes / tool events never
+ *     contribute. Assistant content blocks are flattened; non-text blocks
+ *     (thinking, tool use) are skipped.
+ *   - sessionId: the FIRST session-id-bearing event supplies it (snake_case /
+ *     camelCase variants, plus `id` on `session*`-typed events), falling back
+ *     to any sessionId the spawn layer already attached. Stored
+ *     opportunistically on the unit row for `--session <id>` resume; akm
+ *     never depends on it (plan §"Session, MCP, and identity").
+ *
+ * Also handled, so version churn stays contained in this one file (per the
+ * adapter contract):
+ *   - a single whole-stdout JSON document (or a spawn-layer `result.parsed`
+ *     value) is interpreted with the same rules;
+ *   - plain text (no `--mode json`, or an unrecognized envelope) passes
+ *     through trimmed — the engine's embedded-JSON parsing still runs
+ *     downstream for schema units;
+ *   - non-JSON banner lines interleaved in the stream are skipped.
+ *
+ * Registered: `piResultExtractor` is `PiHarness.resultExtractor`
+ * (`./index.ts`); the engine resolves it via `getHarness()` in
+ * `workflows/exec/native-executor.ts` to normalize agent-unit stdout before
+ * schema validation.
+ */
+import { isRecord, tryParseJson } from "../../../core/common.js";
 /** Keys that may carry the harness-native session id, in precedence order. */
 const SESSION_KEYS = ["session_id", "sessionId", "session"];
 /**
@@ -73,15 +115,6 @@ function extractSessionId(event) {
     }
     return undefined;
 }
-/** JSON.parse that returns undefined instead of throwing. */
-function tryParseJson(raw) {
-    try {
-        return JSON.parse(raw);
-    }
-    catch {
-        return undefined;
-    }
-}
 /**
  * Normalize a raw pi run result into `{ text, sessionId? }`.
  * See the module doc for the stdout shapes handled.

package/dist/integrations/lockfile.js

@@ -186,20 +186,6 @@ export async function writeLockfile(entries) {
         release();
     }
 }
-/** Replace one exact parsed lock generation while the lockfile sentinel is held. */
-export async function compareAndSwapLockfile(expected, desired) {
-    const release = await acquireLockSentinel();
-    try {
-        const current = readLockfileOrThrow();
-        if (JSON.stringify(current) !== JSON.stringify(expected))
-            return false;
-        writeLockfileUnlocked(desired);
-        return true;
-    }
-    finally {
-        release();
-    }
-}
 /**
  * Publish an update from one exact raw + parsed lockfile generation and return
  * the exact bytes that were written. Formatting-only concurrent edits are a

package/dist/integrations/session-logs/index.js

@@ -39,7 +39,6 @@ for (const provider of HARNESSES) {
         throw new Error(`[akm] session-log provider "${provider.name}" is not registered as a sessionLogs harness in HARNESS_REGISTRY (src/integrations/harnesses). Add it there.`);
     }
 }
-const ERROR_PATTERNS = /error|failed|exception|cannot|undefined|null pointer|ENOENT|timeout/i;
 /**
  * Returns all available session log harnesses for the current machine.
  * Add new harnesses to HARNESSES to support additional agent runtimes.
@@ -53,83 +52,3 @@ export function normalizeSessionTopic(text) {
         return undefined;
     return normalized.slice(0, 60);
 }
-export function aggregateSessionEvents(events) {
-    const counts = new Map();
-    for (const event of events) {
-        const topic = normalizeSessionTopic(event.text);
-        if (!topic)
-            continue;
-        const isFailurePattern = ERROR_PATTERNS.test(topic);
-        if (!isFailurePattern)
-            continue;
-        const existing = counts.get(topic) ?? {
-            count: 0,
-            isFailurePattern,
-            sources: new Set(),
-            topic,
-        };
-        existing.count += 1;
-        existing.isFailurePattern = existing.isFailurePattern || isFailurePattern;
-        existing.sources.add(event.harness);
-        counts.set(topic, existing);
-    }
-    return [...counts.values()]
-        .filter((entry) => entry.count >= 2)
-        .sort((a, b) => b.count - a.count || a.topic.localeCompare(b.topic))
-        .slice(0, 15)
-        .map((entry) => ({
-        topic: entry.topic,
-        frequency: entry.count,
-        source: [...entry.sources].sort().join(","),
-        isFailurePattern: entry.isFailurePattern,
-    }));
-}
-/**
- * Collect normalized session events from a set of harnesses for the health
- * candidate scan (#568).
- *
- * Pipeline selection per harness:
- *   - Drive the richer `listSessions()` + `readSession()` pipeline. `readSession` flattens
- *     structured content — tool calls, assistant content blocks, thinking,
- *     tool_result — into event text (e.g. ClaudeCodeProvider's `parseClaudeEvent`
- *     surfaces `[tool:*]` / `[tool_result]` blocks that the legacy flat
- *     `readEvents` scan drops entirely). This is what lets health advisories see
- *     repeated tool failures / long runs that the flat scan hid.
- *
- * Extracted as a pure function (harnesses injected) so it is unit-testable
- * without touching the real on-disk session-log locations.
- *
- * `maxSessionsPerHarness` bounds the path: `readSession()` reads each
- * session file in full. On a machine with a
- * deep `~/.claude/projects` history a 30-day window can hold hundreds of
- * multi-MB session files, and reading+parsing every one in full made the
- * health command (`akm health`, which calls this synchronously) blow past its
- * latency budget. `listSessions()` returns summaries sorted newest-first, so
- * capping to the most-recent N sessions per harness keeps the richer signal
- * for what actually matters (recent activity) while bounding cost.
- */
-const DEFAULT_MAX_SESSIONS_PER_HARNESS = 50;
-export function collectSessionEvents(harnesses, sinceMs, maxSessionsPerHarness = DEFAULT_MAX_SESSIONS_PER_HARNESS) {
-    const events = [];
-    for (const harness of harnesses) {
-        try {
-            // Enumerate sessions cheaply, then read each one's full structured event
-            // stream. There is no parallel flat-log parser.
-            const summaries = harness.listSessions({ sinceMs });
-            // summaries are newest-first; bound the full-file reads (see doc above).
-            for (const summary of summaries.slice(0, maxSessionsPerHarness)) {
-                try {
-                    const session = harness.readSession(summary);
-                    events.push(...session.events);
-                }
-                catch {
-                    // a single unreadable session is non-fatal
-                }
-            }
-        }
-        catch {
-            // individual harness failures are non-fatal
-        }
-    }
-    return events;
-}

package/dist/llm/client.js

@@ -423,18 +423,6 @@ async function chatCompletionAttemptOnce(config, messages, options, timeoutMs, i
     }
 }
 // ── Availability check ──────────────────────────────────────────────────────
-/**
- * Check if the LLM endpoint is reachable.
- */
-export async function isLlmAvailable(config) {
-    try {
-        const result = await chatCompletion(config, [{ role: "user", content: "Respond with just the word: ok" }]);
-        return result.length > 0;
-    }
-    catch {
-        return false;
-    }
-}
 // ── Reachability probe ──────────────────────────────────────────────────────
 /**
  * Best-effort reachability check with an error message, for setup's optional