akm-cli 0.9.7 → 0.9.8-beta.1

package/dist/setup/setup.js

@@ -24,7 +24,7 @@ import { deriveBundleIds } from "../core/bundle-id.js";
 import { bundleEntryToSourceEntry, DEFAULT_CONFIG, loadUserConfig, mutateConfigWithPrecommit, parseAndValidateConfigText, primaryBundlePath, validateCompleteConfig, } from "../core/config/config.js";
 import { readConfigText } from "../core/config/config-io.js";
 import { listTopLevelConfigKeys } from "../core/config/config-schema.js";
-import { deepMergeConfig } from "../core/config/deep-merge.js";
+import { deepMergeConfig, isPlainObject } from "../core/config/deep-merge.js";
 import { ConfigError, UsageError } from "../core/errors.js";
 import { getConfigPath, getDefaultStashDir, isTransientStashPath } from "../core/paths.js";
 import { warn } from "../core/warn.js";
@@ -131,17 +131,11 @@ export function assertSetupConfigPreflight() {
             `(e.g. \`mv ${configPath} ${configPath}.bak\`) and re-run \`akm setup\`.`);
     }
 }
-function isPlainRecord(value) {
-    if (!value || typeof value !== "object" || Array.isArray(value))
-        return false;
-    const prototype = Object.getPrototypeOf(value);
-    return prototype === Object.prototype || prototype === null;
-}
 function sameConfigValue(left, right) {
     return isDeepStrictEqual(left, right);
 }
 function configArrayItemKey(value) {
-    if (!isPlainRecord(value))
+    if (!isPlainObject(value))
         return `value:${JSON.stringify(value)}`;
     if (typeof value.id === "string")
         return `id:${value.id}`;
@@ -199,14 +193,14 @@ export function rebaseSetupChanges(original, desired, latest, pathParts = []) {
         }
         return result;
     }
-    if (!isPlainRecord(original) || !isPlainRecord(desired)) {
+    if (!isPlainObject(original) || !isPlainObject(desired)) {
         if (!sameConfigValue(latest, original) && !sameConfigValue(latest, desired))
             setupConflict(pathParts);
         return desired;
     }
-    if (latest !== undefined && !isPlainRecord(latest))
+    if (latest !== undefined && !isPlainObject(latest))
         setupConflict(pathParts);
-    const result = isPlainRecord(latest) ? { ...latest } : {};
+    const result = isPlainObject(latest) ? { ...latest } : {};
     for (const key of new Set([...Object.keys(original), ...Object.keys(desired)])) {
         if (!Object.hasOwn(desired, key)) {
             if (Object.hasOwn(result, key) && !sameConfigValue(result[key], original[key]))
@@ -855,7 +849,7 @@ export async function runSetupFromConfig(opts) {
     catch (e) {
         throw new UsageError(`Invalid JSON in --config: ${e.message}`, "INVALID_FLAG_VALUE");
     }
-    if (!isPlainRecord(parsed)) {
+    if (!isPlainObject(parsed)) {
         throw new ConfigError("Setup config must contain a top-level object.", "INVALID_CONFIG_FILE");
     }
     const incoming = parsed;

package/dist/sources/providers/git-install.js

@@ -48,8 +48,13 @@ export function inspectGitUpstream(repoDir) {
  * commit SHA peels to itself.
  */
 export function verifyClonedRevision(cloneDir, url, expectedRevision) {
-    if (!expectedRevision)
-        return;
+    if (!expectedRevision) {
+        // `resolveGitArtifact` (registry/resolve.ts) throws when it cannot resolve
+        // a revision via `git ls-remote`, so a plain git install never reaches
+        // this call with `undefined` — treat it as a bug, not a silently-skipped
+        // check that would defeat the R-011 post-clone integrity verification.
+        throw new UsageError(`No revision was resolved from ${url}; refusing to install without a verifiable checkout.`);
+    }
     const head = runGit(["-C", cloneDir, "rev-parse", "HEAD"]);
     if (head.status !== 0 || !head.stdout.trim()) {
         throw new UsageError(`Failed to read cloned HEAD at ${cloneDir}: ${head.stderr.trim() || "rev-parse failed"}`);

package/dist/sources/providers/tar-utils.js

@@ -91,13 +91,7 @@ export function extractTarGzSecure(archivePath, destinationDir) {
     scanExtractedFiles(destinationDir, destinationDir);
 }
 function scanExtractedFiles(dir, root) {
-    let entries;
-    try {
-        entries = fs.readdirSync(dir, { withFileTypes: true });
-    }
-    catch {
-        return;
-    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
     for (const entry of entries) {
         const fullPath = path.join(dir, entry.name);
         // Reject only entries whose name is exactly the parent-traversal segment

package/dist/sources/snapshot-fetchers/content-extract.js

@@ -609,20 +609,3 @@ export function htmlToMarkdownAndLinks(html, pageUrl) {
     const markdown = root ? markdownFromRoot(root, html, pageUrl) : plainTextFallback(html);
     return { markdown: finalizeMarkdown(markdown), links };
 }
-/**
- * Collect links from the WHOLE document, not the extracted content region.
- *
- * Deliberate and load-bearing: nav/header/footer links are how a crawl
- * discovers pages. Narrowing this to the content region would silently shrink
- * every crawl to whatever the first page happens to link inline.
- */
-export function extractDocumentLinks(html, pageUrl) {
-    let root;
-    try {
-        root = parse(scrubDangerousMarkup(html), { comment: false });
-    }
-    catch {
-        return [];
-    }
-    return collectLinksFromRoot(root, pageUrl);
-}

package/dist/storage/managed-db.js

@@ -61,13 +61,19 @@ export function openManagedDatabase(spec) {
         // Initializers may open a transaction (source update does so before index
         // schema work). Never strand that transaction/handle when later setup
         // fails; closing rolls it back and releases its writer lock.
-        if (db.inTransaction) {
-            try {
+        //
+        // `db.inTransaction` is INSIDE the try: reading it on an already-closed
+        // handle throws "Database has closed", and it used to sit outside, so that
+        // throw escaped and replaced `error` — masking the real initializer failure
+        // this whole block exists to preserve. Every other step here was already
+        // guarded for exactly that reason; this one was not, and a concurrent
+        // close (WAL contention between two writers) reached it.
+        try {
+            if (db.inTransaction)
                 db.exec("ROLLBACK");
-            }
-            catch {
-                // Closing remains the final rollback backstop.
-            }
+        }
+        catch {
+            // Closing remains the final rollback backstop.
         }
         try {
             db.close();
@@ -99,6 +105,13 @@ export function withManagedDb(open, fn, opts) {
         return fn(db);
     }
     finally {
-        db.close();
+        try {
+            db.close();
+        }
+        catch {
+            // A close() throw here would REPLACE fn's in-flight exception — the same
+            // masking openManagedDatabase above was hardened against. The handle is
+            // being discarded either way; fn's error is the one that matters.
+        }
     }
 }

package/dist/storage/repositories/events-repository.js

@@ -147,84 +147,3 @@ export function purgeOldEvents(db, retentionDays = 90) {
     const changes = result.changes ?? 0;
     return typeof changes === "bigint" ? Number(changes) : changes;
 }
-/**
- * Import all events from an `events.jsonl` file into the `events` table.
- *
- * The old byte-offset `id` is NOT preserved — the database assigns new
- * monotonic integer ids. Callers that persisted a byte-offset cursor must
- * discard it after migration and use the returned `maxId` as the new cursor.
- *
- * **Idempotency**: each line is pre-checked against the `events` table using
- * `(event_type, ts, ref, metadata_json)` as the duplicate key. Lines whose
- * exact tuple is already present are skipped and reported as `skipped` in the
- * return value. This makes the migration safe to re-run (the v0.7→v0.8
- * migration guide recommends re-running the script as a recovery path; without
- * this guard, every re-run would double-import the entire event log).
- *
- * Duplicate detection is per-import-tuple, not a table-wide UNIQUE constraint:
- * the events table has no UNIQUE constraint at runtime so that
- * `appendEvent` can write multiple events with the same ts (sub-millisecond
- * bursts produce identical `(event_type, ts, ref)` triples in practice). The
- * SELECT-first check is scoped to the import path only.
- *
- * The import is wrapped in a single transaction for atomicity.
- *
- * @param db       - Open state.db connection.
- * @param jsonlPath - Absolute path to the events.jsonl file to import.
- * @returns         Number of rows inserted, the max id assigned, and the
- *                  count of rows skipped because an identical event already
- *                  existed in the table.
- */
-export async function importEventsJsonl(db, jsonlPath) {
-    const { readFileSync, existsSync } = await import("node:fs");
-    if (!existsSync(jsonlPath)) {
-        return { imported: 0, maxId: 0, skipped: 0 };
-    }
-    const text = readFileSync(jsonlPath, "utf8");
-    const lines = text.split("\n").filter((l) => l.trim().length > 0);
-    let imported = 0;
-    let maxId = 0;
-    let skipped = 0;
-    const insertStmt = db.prepare(`INSERT INTO events (event_type, ts, ref, metadata_json)
-     VALUES (?, ?, ?, ?)
-     RETURNING id`);
-    // Dedup pre-check: matches by the full tuple including metadata_json so an
-    // import is idempotent over identical rows but does not collide with two
-    // genuinely different events that happen to share (event_type, ts, ref).
-    //
-    // Uses IS for ref so two NULL refs compare equal (a plain `=` would treat
-    // NULL = NULL as NULL and the row would be re-inserted on every run).
-    const existsStmt = db.prepare(`SELECT 1 FROM events
-     WHERE event_type = ?
-       AND ts = ?
-       AND ref IS ?
-       AND metadata_json = ?
-     LIMIT 1`);
-    db.transaction(() => {
-        for (const line of lines) {
-            let parsed;
-            try {
-                parsed = JSON.parse(line);
-            }
-            catch {
-                continue; // skip malformed lines — same behaviour as readEvents()
-            }
-            const eventType = typeof parsed.eventType === "string" ? parsed.eventType : "unknown";
-            const ts = typeof parsed.ts === "string" ? parsed.ts : new Date().toISOString();
-            const ref = typeof parsed.ref === "string" ? parsed.ref : null;
-            const metadata = parsed.metadata !== undefined && typeof parsed.metadata === "object" ? JSON.stringify(parsed.metadata) : "{}";
-            const duplicate = existsStmt.get(eventType, ts, ref, metadata);
-            if (duplicate) {
-                skipped++;
-                continue;
-            }
-            const result = insertStmt.get(eventType, ts, ref, metadata);
-            if (result) {
-                imported++;
-                if (result.id > maxId)
-                    maxId = result.id;
-            }
-        }
-    })();
-    return { imported, maxId, skipped };
-}

package/dist/storage/repositories/index-entries-repository.js

@@ -683,23 +683,6 @@ export function getEntryFilePathById(db, id) {
     const row = db.prepare("SELECT file_path FROM entries WHERE id = ?").get(id);
     return row?.file_path;
 }
-/**
- * Fetch every `(file_path, document_json)` row whose path is under a source
- * root. The path containment filter is applied in JS so SQLite LIKE wildcard
- * characters in filesystem paths cannot widen ownership.
- *
- * Lifted verbatim (WS5) from the inline query in commands/graph.ts'
- * `buildRefByPath`. The full result set is materialised with `.all()` before
- * return so callers can iterate it after the connection closes (WS5
- * connection-lifetime rule). JSON parsing stays with the caller, unchanged.
- */
-export function getEntryRefRowsForStashRoot(db, stashRoot) {
-    const root = path.resolve(stashRoot);
-    return db.prepare("SELECT file_path, document_json FROM entries").all().filter((row) => {
-        const file = path.resolve(row.file_path);
-        return file === root || file.startsWith(`${root}${path.sep}`);
-    });
-}
 // ── Indexer-phase helpers (moved from indexer.ts) ────────────────────────────
 /**
  * Return distinct zero-result search queries from the `usage_events` table

package/dist/storage/repositories/index-fts-repository.js

@@ -91,38 +91,32 @@ function runFtsQuery(db, ftsQuery, lexicalMatch, limit, entryType, excludeTypes)
     ORDER BY bm25Score, e.id ASC
     LIMIT ?
   `;
-    try {
-        const rows = db.prepare(sql).all(...params);
-        // Guard against corrupt JSON — skip the row rather than crashing
-        const results = [];
-        for (const row of rows) {
-            let entry;
-            try {
-                entry = JSON.parse(row.documentJson);
-            }
-            catch {
-                warn(`[db] searchFts: skipping entry id=${row.id} — corrupt document_json`);
-                continue;
-            }
-            results.push({
-                id: row.id,
-                filePath: row.filePath,
-                entry,
-                searchText: row.searchText,
-                bm25Score: row.bm25Score,
-                itemRef: row.itemRef,
-                bundleId: row.bundleId,
-                conceptId: row.conceptId,
-                adapterId: row.adapterId,
-                lexicalMatch,
-            });
+    const rows = db.prepare(sql).all(...params);
+    // Guard against corrupt JSON — skip the row rather than crashing
+    const results = [];
+    for (const row of rows) {
+        let entry;
+        try {
+            entry = JSON.parse(row.documentJson);
         }
-        return results;
-    }
-    catch (err) {
-        warn("[db] runFtsQuery failed:", err instanceof Error ? err.message : String(err));
-        return [];
+        catch {
+            warn(`[db] searchFts: skipping entry id=${row.id} — corrupt document_json`);
+            continue;
+        }
+        results.push({
+            id: row.id,
+            filePath: row.filePath,
+            entry,
+            searchText: row.searchText,
+            bm25Score: row.bm25Score,
+            itemRef: row.itemRef,
+            bundleId: row.bundleId,
+            conceptId: row.conceptId,
+            adapterId: row.adapterId,
+            lexicalMatch,
+        });
     }
+    return results;
 }
 /**
  * Explicitly rebuild the complete FTS5 projection from canonical entries.

package/dist/storage/repositories/index-utility-repository.js

@@ -263,63 +263,6 @@ function getSourceScopedRetrievalCounts(indexDb, stateDb, refs, options) {
     }
     return result;
 }
-/**
- * Apply a MemRL reward signal to a batch of entries via exponential moving
- * average (EMA): next = clamp(current + lr * (reward - current), 0, 1).
- *
- * Wrapped in a single transaction so all bumps succeed or fail together.
- * The indexer (`akm index`) will overwrite these values at next reindex run;
- * bumps are intentionally temporary hints between index runs, not permanent
- * overrides.
- *
- * When `scopeKey` is provided, also writes a scoped bump to
- * `utility_scores_scoped` so per-project usage signals accumulate alongside
- * the global ones. The global table is always updated regardless.
- */
-export function bumpUtilityScoresBatch(db, entryIds, reward, lr = 0.1, scopeKey) {
-    if (entryIds.length === 0)
-        return;
-    db.transaction(() => {
-        const { global: scoreMap } = getUtilityScoresByIds(db, entryIds);
-        const now = new Date().toISOString();
-        const nowMs = Date.now();
-        const stmt = db.prepare(`INSERT INTO utility_scores (entry_id, utility, show_count, search_count, select_rate, last_used_at, updated_at)
-       VALUES (?, ?, 0, 0, 0, ?, ?)
-       ON CONFLICT(entry_id) DO UPDATE SET
-         utility = excluded.utility,
-         updated_at = excluded.updated_at`);
-        // Prepare scoped upsert once outside the loop when scopeKey is present.
-        const scopedStmt = scopeKey
-            ? db.prepare(`INSERT INTO utility_scores_scoped (entry_id, scope_key, utility, last_used_at)
-           VALUES (?, ?, ?, ?)
-           ON CONFLICT(entry_id, scope_key) DO UPDATE SET
-             utility = excluded.utility,
-             last_used_at = excluded.last_used_at`)
-            : null;
-        for (const entryId of entryIds) {
-            const existing = scoreMap.get(entryId);
-            const current = existing?.utility ?? 0;
-            const next = Math.max(0, Math.min(1, current + lr * (reward - current)));
-            stmt.run(entryId, next, now, now);
-            if (scopedStmt && scopeKey) {
-                // Retrieve the current scoped utility so we can apply the same EMA.
-                const scopedCurrent = getScopedUtility(db, entryId, scopeKey);
-                const scopedNext = Math.max(0, Math.min(1, scopedCurrent + lr * (reward - scopedCurrent)));
-                scopedStmt.run(entryId, scopeKey, scopedNext, nowMs);
-            }
-        }
-    })();
-}
-/**
- * Return the current utility value for a single (entry_id, scope_key) pair.
- * Returns 0 when no row exists yet.
- */
-function getScopedUtility(db, entryId, scopeKey) {
-    const row = db
-        .prepare("SELECT utility FROM utility_scores_scoped WHERE entry_id = ? AND scope_key = ?")
-        .get(entryId, scopeKey);
-    return row?.utility ?? 0;
-}
 /**
  * Apply accumulated feedback counts to the utility score of an entry, persisting
  * the result. The bounded-step EMA policy itself (MemRL, F-5 / #386,

package/dist/storage/repositories/index-vec-repository.js

@@ -229,9 +229,14 @@ export function searchVec(db, queryEmbedding, k) {
                 .all(buf, k);
         }
         catch (err) {
-            // Log the failure so it's visible in diagnostics
-            warn("[db] searchVec (sqlite-vec path) failed:", err instanceof Error ? err.message : String(err));
-            return [];
+            // A dimension mismatch (e.g. the embedding provider/model changed since
+            // the fast-path table was built) is a real, expected reason this query
+            // specifically cannot use the vec table — the complete BLOB table below
+            // is unaffected, so fall back to it rather than either silently
+            // returning [] (masking a genuinely corrupt index) or failing the whole
+            // search over one degraded index.
+            warn("[db] searchVec (sqlite-vec path) failed, falling back to JS-cosine scan:", err instanceof Error ? err.message : String(err));
+            return searchBlobVec(db, queryEmbedding, k);
         }
     }
     // Fallback: JS-based cosine similarity over BLOB table
@@ -281,32 +286,25 @@ function bufferToFloat32(buf, expectedDim) {
     return Array.from(f32);
 }
 function searchBlobVec(db, queryEmbedding, k) {
-    try {
-        const rows = db.prepare("SELECT id, embedding FROM embeddings").all();
-        if (rows.length === 0)
-            return [];
-        const expectedDim = queryEmbedding.length;
-        const scored = [];
-        for (const row of rows) {
-            const embedding = bufferToFloat32(row.embedding, expectedDim);
-            if (embedding === null)
-                continue;
-            const similarity = cosineSimilarity(queryEmbedding, embedding);
-            scored.push({ id: row.id, similarity });
-        }
-        scored.sort((a, b) => b.similarity - a.similarity);
-        // Convert cosine similarity to L2 distance for compatibility with sqlite-vec interface
-        // For normalized vectors: L2² = 2(1 - cos_sim)
-        return scored.slice(0, k).map(({ id, similarity }) => ({
-            id,
-            distance: Math.sqrt(2 * Math.max(0, 1 - similarity)),
-        }));
-    }
-    catch (err) {
-        // MD-5: Log the failure so it's visible in diagnostics
-        warn("[db] searchBlobVec (JS fallback) failed:", err instanceof Error ? err.message : String(err));
+    const rows = db.prepare("SELECT id, embedding FROM embeddings").all();
+    if (rows.length === 0)
         return [];
+    const expectedDim = queryEmbedding.length;
+    const scored = [];
+    for (const row of rows) {
+        const embedding = bufferToFloat32(row.embedding, expectedDim);
+        if (embedding === null)
+            continue;
+        const similarity = cosineSimilarity(queryEmbedding, embedding);
+        scored.push({ id: row.id, similarity });
     }
+    scored.sort((a, b) => b.similarity - a.similarity);
+    // Convert cosine similarity to L2 distance for compatibility with sqlite-vec interface
+    // For normalized vectors: L2² = 2(1 - cos_sim)
+    return scored.slice(0, k).map(({ id, similarity }) => ({
+        id,
+        distance: Math.sqrt(2 * Math.max(0, 1 - similarity)),
+    }));
 }
 /**
  * Return all entries that do not yet have an embedding row.

package/dist/storage/repositories/task-history-repository.js

@@ -1,12 +1,18 @@
 // 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/.
+/**
+ * Repository for the state.db `task_history` table (per-task run ledger,
+ * replaces the old per-task JSONL files). Extracted verbatim from
+ * core/state-db.ts — queries unchanged, only relocated behind the repository
+ * boundary. Re-exported by core/state-db.ts so existing importers resolve.
+ *
+ * @module task-history-repository
+ */
+import { isRecord } from "../../core/common.js";
 function metadataError(message) {
     throw new Error(`invalid task_history metadata_json: ${message}`);
 }
-function isRecord(value) {
-    return typeof value === "object" && value !== null && !Array.isArray(value);
-}
 function validateDetail(value) {
     if (value === undefined || value === null)
         return;

package/dist/tasks/backends/launchd.js

@@ -25,6 +25,7 @@ import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
 import launchdTemplate from "../../assets/backends/launchd-template.xml" with { type: "text" };
+import { hasErrnoCode } from "../../core/common.js";
 import { ConfigError } from "../../core/errors.js";
 import { getTaskLogDir } from "../../core/paths.js";
 import { resolveAkmInvocation } from "../resolve-akm-bin.js";
@@ -851,22 +852,6 @@ export function parseLaunchdLoadedLabels(output) {
     }
     return labels;
 }
-function countCharacter(value, needle) {
-    let count = 0;
-    for (const character of value)
-        if (character === needle)
-            count += 1;
-    return count;
-}
-function hasUnsafeLaunchdControlCharacter(output) {
-    for (let index = 0; index < output.length; index += 1) {
-        const code = output.charCodeAt(index);
-        if (code <= 8 || code === 11 || code === 12 || (code >= 14 && code <= 31) || (code >= 127 && code <= 159)) {
-            return true;
-        }
-    }
-    return false;
-}
 function readDisabledLabels(exec) {
     try {
         const result = exec.run(["launchctl", "print-disabled", `gui/${exec.uid()}`]);
@@ -933,8 +918,13 @@ function defaultLaunchdFs() {
             try {
                 return fs.readdirSync(dir);
             }
-            catch {
-                return [];
+            catch (error) {
+                // Genuinely absent is an empty listing; anything else (e.g. EACCES) is
+                // not "no plists" — surfacing it as such could make inspectBindings
+                // think there is nothing to reconcile.
+                if (hasErrnoCode(error, "ENOENT"))
+                    return [];
+                throw new ConfigError(`Unable to read LaunchAgents directory at "${dir}".`, "INVALID_CONFIG_FILE");
             }
         },
         exists(file) {

package/dist/tasks/run/task-history.js

@@ -14,20 +14,15 @@
  *
  * D8 result-vocabulary re-code (why, and the WRITE side's exact shape): see
  * docs/architecture/decisions/0005-task-result-vocabulary-and-legacy-read-mapping.md.
- * The READ side's mapping rule is a PERMANENT invariant kept here, not moved
- * — a maintainer touching `taskHistoryRowToResult` needs it right here, and
- * row B-51 (docs/plans/specs/p4-deletions-closeout.md) makes deleting it a
- * review-blocking violation: it reads rows written by every previous
- * release, forever.
- *
- *   A legacy row (no `targetVocab` marker — written before D8) maps:
- *   `"prompt"` -> `{kind:"command", engine}`, `"command"` -> `{kind:"shell"}`,
- *   `"workflow"` unchanged, anything else (including the new vocabulary's own
- *   "shell"/"script"/"prompt" written WITHOUT a marker, which no production
- *   writer ever does) -> `"unknown"`. The P0-pinned null fallbacks survive:
- *   workflow `ref` falls back to `""`, the command/prompt arm's `engine`
- *   falls back to `null`. A row carrying `targetVocab: 2` reads `target_kind`
- *   directly in the current vocabulary — no mapping needed.
+ * The READ side used to carry a permanent legacy-vocabulary mapping here
+ * (row B-51 of docs/plans/specs/p4-deletions-closeout.md called deleting it
+ * "review-blocking") — SUPERSEDED: `task_history` is DB-owned data, so the
+ * remap is now a one-time schema migration
+ * (`025-task-history-vocabulary-backfill` in src/core/state/migrations.ts)
+ * instead of a read-side shim run forever. Every row this function sees now
+ * carries the current vocabulary's `target_kind` strings; the P0-pinned null
+ * fallbacks still apply (workflow `ref` falls back to `""`, the command
+ * arm's `engine` falls back to `null`).
  *
  * A DAG leaf with respect to the rest of src/tasks/run/**: this module
  * imports TaskRunResult/TaskRunStatus's TYPE from ./task-result but no VALUE
@@ -37,6 +32,7 @@
  */
 import { rethrowIfTestIsolationError } from "../../core/errors.js";
 import { withStateDb } from "../../core/state-db.js";
+import { warn } from "../../core/warn.js";
 import { decodeTaskHistoryMetadata, finalizeTaskHistoryAttempt, getTaskHistory, getTaskHistoryRuns, queryTaskHistory, upsertTaskHistory, } from "../../storage/repositories/task-history-repository.js";
 /** Append (or finalize a reserved attempt into) one task_history row. */
 export function appendHistory(result, historyReserved = false) {
@@ -67,7 +63,11 @@ export function appendHistory(result, historyReserved = false) {
     }
     catch (error) {
         rethrowIfTestIsolationError(error);
-        // History recording is fully best-effort and must not alter CLI output.
+        // History recording must not alter the task's own result/exit status —
+        // the task already ran and its outcome is independent of whether we can
+        // persist a history row. But silence would make a failed write
+        // indistinguishable from the task never having run, so warn.
+        warn(`task history: failed to record history for task ${result.id}: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
 export function readTaskHistory(options = {}) {
@@ -111,32 +111,22 @@ function decodeTaskHistoryRows(rows) {
  * Convert a `TaskHistoryRow` from state.db back to a `TaskRunResult` shape
  * that callers of `readTaskHistory()` expect.
  *
- * D8 read boundary (spec §5.3): branches on the decoded metadata's
- * `targetVocab` marker — see the module header's table.
+ * Reads `target_kind` directly in the current (post-D8) vocabulary — the
+ * `025-task-history-vocabulary-backfill` state migration rewrites every
+ * legacy-vocabulary row before this ever runs against it.
  */
 function taskHistoryRowToResult(row) {
     const meta = decodeTaskHistoryMetadata(row.metadata_json);
-    const marked = meta.targetVocab === 2;
     const target = (() => {
         switch (row.target_kind) {
             case "workflow":
-                // PRESERVED for both vintages (incl. the null-ref fallback).
                 return { kind: "workflow", ref: row.target_ref ?? "" };
             case "command":
-                // NEW vocabulary: a prepared command (agent/LLM) result.
-                // LEGACY vocabulary: the native shell/script arm's shared string.
-                return marked ? { kind: "command", engine: meta.engine ?? null } : { kind: "shell" };
+                return { kind: "command", engine: meta.engine ?? null };
             case "shell":
-                // Only the NEW vocabulary ever writes this string; an unmarked
-                // "shell" row is unreachable from any production writer.
-                return marked ? { kind: "shell" } : { kind: "unknown" };
+                return { kind: "shell" };
             case "script":
-                // Only the NEW vocabulary ever writes this string; an unmarked
-                // "script" row is unreachable from any production writer.
-                return marked ? { kind: "script" } : { kind: "unknown" };
-            case "prompt":
-                // Only LEGACY rows (pre-P1b) ever wrote this string.
-                return marked ? { kind: "unknown" } : { kind: "command", engine: meta.engine ?? null };
+                return { kind: "script" };
             default:
                 return { kind: "unknown" };
         }

package/dist/tasks/scheduler-sync.js

@@ -6,6 +6,7 @@ import { createHash } from "node:crypto";
 import path from "node:path";
 import { loadAdapterExecutionSource } from "../commands/command/execution-source-loader.js";
 import { makeBundleRef } from "../core/asset/asset-ref.js";
+import { compareCodePoints, toPosix } from "../core/common.js";
 import { UsageError } from "../core/errors.js";
 import { canonicalizeWorkflowName, WORKFLOW_EXTENSIONS } from "../core/recognition-util.js";
 import { captureGuardedDirectoryManifest, captureGuardedExecutionSource, GuardedExecutionSourceCollector, } from "../execution/guarded-source.js";
@@ -742,12 +743,6 @@ function freezeOperation(operation) {
 function sameInvocation(left, right) {
     return left.length === right.length && left.every((value, index) => value === right[index]);
 }
-function compareCodePoints(left, right) {
-    return left < right ? -1 : left > right ? 1 : 0;
-}
-function toPosix(value) {
-    return value.replaceAll("\\", "/");
-}
 // Retain the concrete error in this module's public dependency graph so callers
 // can continue to identify ownership failures without importing an adapter.
 export { WorkflowSourceRejectionError };