akm-cli 0.9.0-beta.2 → 0.9.0-beta.4

package/dist/scripts/migrations/import-fs-improve-runs-to-db.js

@@ -8631,7 +8631,7 @@ function openStateDatabase(dbPath) {
   const db = openDatabase(resolvedPath);
   db.exec("PRAGMA journal_mode = WAL");
   db.exec("PRAGMA foreign_keys = ON");
-  db.exec("PRAGMA busy_timeout = 5000");
+  db.exec("PRAGMA busy_timeout = 30000");
   runMigrations2(db);
   return db;
 }
@@ -8706,7 +8706,9 @@ var MIGRATIONS = [
       --
       -- Extensible (metadata_json) columns:
       --   metadata_json TEXT      \u2014 JSON object for future proposal fields.
-      --                             Current fields stored here: sourceRun, review.
+      --                             Current fields stored here: sourceRun,
+      --                             review, confidence, gateDecision (#577),
+      --                             backupContent.
       --
       -- ADD COLUMN extension points (future migrations):
       --   ALTER TABLE proposals ADD COLUMN source_run TEXT DEFAULT NULL;
@@ -8893,6 +8895,16 @@ var MIGRATIONS = [
       CREATE INDEX IF NOT EXISTS idx_extract_sessions_processed
         ON extract_sessions_seen(processed_at);
     `
+  },
+  {
+    id: "005-proposal-fs-imports",
+    up: `
+      CREATE TABLE IF NOT EXISTS proposal_fs_imports (
+        stash_dir      TEXT    PRIMARY KEY,
+        imported_at    TEXT    NOT NULL,
+        imported_count INTEGER NOT NULL DEFAULT 0
+      );
+    `
   }
 ];
 function runMigrations2(db) {

package/dist/tasks/runner.js

@@ -16,7 +16,9 @@
  *   4. Dispatch by target kind:
  *        • workflow → `startWorkflowRun(ref, params)`
  *        • prompt   → `runAgent(profile, prompt, { stdio: "captured" })`
- *   5. Capture stdout / stderr to `<cacheDir>/tasks/logs/<id>/<ts>.log`.
+ *   5. Capture stdout / stderr as structured rows in logs.db (task_logs) and,
+ *      transitionally, as a flat text tail at `<cacheDir>/tasks/logs/<id>/<ts>.log`
+ *      (see docs/technical/logs-audit.md).
  *   6. Write a history row to state.db task_history table.
  *
  * Returns a structured result so the CLI handler can shape it for `output()`
@@ -29,6 +31,7 @@ import { parseAssetRef } from "../core/asset/asset-ref.js";
 import { resolveStashDir } from "../core/common.js";
 import { loadConfig } from "../core/config/config.js";
 import { NotFoundError, rethrowIfTestIsolationError } from "../core/errors.js";
+import { buildTaskRunId, insertTaskLogLines, openLogsDatabase, } from "../core/logs-db.js";
 import { getTaskLogDir } from "../core/paths.js";
 import { getTaskHistory, openStateDatabase, queryTaskHistory, upsertTaskHistory } from "../core/state-db.js";
 import { error } from "../core/warn.js";
@@ -70,7 +73,15 @@ export async function runTask(id, options = {}) {
             log: logPath,
             target: disabledTarget,
         };
-        fs.writeFileSync(logPath, `[akm tasks] task "${id}" is disabled — skipping run.\n`);
+        const disabledLine = `[akm tasks] task "${id}" is disabled — skipping run.`;
+        persistRunLog({
+            taskId: id,
+            startedAtIso: startedIso,
+            finishedAtIso: result.finishedAt,
+            logPath,
+            fileText: `${disabledLine}\n`,
+            dbLines: [{ line: disabledLine }],
+        });
         appendHistory(result);
         return result;
     }
@@ -108,7 +119,9 @@ async function runCommandTask(input) {
         throw new Error("invariant: command target");
     const { cmd } = task.target;
     const timeoutMs = task.timeoutMs !== undefined ? task.timeoutMs : null;
-    const logLines = [`[akm tasks] task=${task.id} kind=command cmd=${cmd.join(" ")}`];
+    const header = `[akm tasks] task=${task.id} kind=command cmd=${cmd.join(" ")}`;
+    const logLines = [header];
+    const dbLines = [{ line: header }];
     let stdout = "";
     let stderr = "";
     let exitCode = null;
@@ -144,24 +157,36 @@ async function runCommandTask(input) {
         exitCode = proc.exitCode ?? (timedOut ? 143 : 1);
         if (timedOut) {
             logLines.push(`timed_out=true timeout_ms=${timeoutMs}`);
+            dbLines.push({ level: "error", line: `timed_out=true timeout_ms=${timeoutMs}` });
         }
         logLines.push(`exit_code=${exitCode}`);
+        dbLines.push({ level: exitCode === 0 ? "info" : "error", line: `exit_code=${exitCode}` });
         if (stdout) {
             logLines.push("--- stdout ---");
             logLines.push(stdout);
+            dbLines.push(...streamLines(stdout, "stdout", "info"));
         }
         if (stderr) {
             logLines.push("--- stderr ---");
             logLines.push(stderr);
+            dbLines.push(...streamLines(stderr, "stderr", "error"));
         }
     }
     catch (e) {
         const msg = e instanceof Error ? e.message : String(e);
         logLines.push(`spawn_error=${msg}`);
+        dbLines.push({ level: "error", line: `spawn_error=${msg}` });
         exitCode = 1;
     }
-    fs.writeFileSync(logPath, `${logLines.join("\n")}\n`);
     const finishedAt = now();
+    persistRunLog({
+        taskId: task.id,
+        startedAtIso: startedAt.toISOString(),
+        finishedAtIso: finishedAt.toISOString(),
+        logPath,
+        fileText: `${logLines.join("\n")}\n`,
+        dbLines,
+    });
     const status = exitCode === 0 ? "completed" : "failed";
     const result = {
         id: task.id,
@@ -196,7 +221,14 @@ async function runWorkflowTask(input) {
     const finishedAt = now();
     const status = error ? "failed" : mapWorkflowStatus(detail?.run.status);
     const log = renderWorkflowLog({ task, detail, error });
-    fs.writeFileSync(logPath, log);
+    persistRunLog({
+        taskId: task.id,
+        startedAtIso: startedAt.toISOString(),
+        finishedAtIso: finishedAt.toISOString(),
+        logPath,
+        fileText: log.fileText,
+        dbLines: log.dbLines,
+    });
     const result = {
         id: task.id,
         status,
@@ -248,16 +280,17 @@ function mapWorkflowStatus(status) {
     }
 }
 function renderWorkflowLog(input) {
-    const lines = [];
-    lines.push(`[akm tasks] task=${input.task.id} kind=workflow ref=${input.task.target.ref}`);
+    const dbLines = [
+        { line: `[akm tasks] task=${input.task.id} kind=workflow ref=${input.task.target.ref}` },
+    ];
     if (input.detail) {
-        lines.push(`run_id=${input.detail.run.id} status=${input.detail.run.status}`);
-        lines.push(`workflow_title=${input.detail.run.workflowTitle}`);
+        dbLines.push({ line: `run_id=${input.detail.run.id} status=${input.detail.run.status}` });
+        dbLines.push({ line: `workflow_title=${input.detail.run.workflowTitle}` });
     }
     if (input.error) {
-        lines.push(`error=${input.error.message}`);
+        dbLines.push({ level: "error", line: `error=${input.error.message}` });
     }
-    return `${lines.join("\n")}\n`;
+    return { fileText: `${dbLines.map((entry) => entry.line).join("\n")}\n`, dbLines };
 }
 // ── prompt target ───────────────────────────────────────────────────────────
 async function runPromptTask(input) {
@@ -321,7 +354,14 @@ async function runPromptTask(input) {
     });
     const finishedAt = now();
     const log = renderPromptLog({ task, profileName: profile.name, result });
-    fs.writeFileSync(logPath, log);
+    persistRunLog({
+        taskId: task.id,
+        startedAtIso: startedAt.toISOString(),
+        finishedAtIso: finishedAt.toISOString(),
+        logPath,
+        fileText: log.fileText,
+        dbLines: log.dbLines,
+    });
     const status = result.ok ? "completed" : "failed";
     const out = {
         id: task.id,
@@ -359,20 +399,63 @@ async function resolvePromptText(task, stashDir) {
 }
 function renderPromptLog(input) {
     const lines = [];
-    lines.push(`[akm tasks] task=${input.task.id} kind=prompt profile=${input.profileName}`);
-    lines.push(`ok=${input.result.ok} exit_code=${input.result.exitCode ?? "null"} duration_ms=${input.result.durationMs}`);
+    const dbLines = [];
+    const header = `[akm tasks] task=${input.task.id} kind=prompt profile=${input.profileName}`;
+    const summary = `ok=${input.result.ok} exit_code=${input.result.exitCode ?? "null"} duration_ms=${input.result.durationMs}`;
+    lines.push(header, summary);
+    dbLines.push({ line: header }, { level: input.result.ok ? "info" : "error", line: summary });
     if (!input.result.ok) {
-        lines.push(`reason=${input.result.reason ?? ""} error=${input.result.error ?? ""}`);
+        const failure = `reason=${input.result.reason ?? ""} error=${input.result.error ?? ""}`;
+        lines.push(failure);
+        dbLines.push({ level: "error", line: failure });
     }
     if (input.result.stdout) {
         lines.push("--- agent stdout ---");
         lines.push(input.result.stdout);
+        dbLines.push(...streamLines(input.result.stdout, "stdout", "info"));
     }
     if (input.result.stderr) {
         lines.push("--- agent stderr ---");
         lines.push(input.result.stderr);
+        dbLines.push(...streamLines(input.result.stderr, "stderr", "error"));
+    }
+    return { fileText: `${lines.join("\n")}\n`, dbLines };
+}
+/** Split captured pipe output into per-line logs.db rows (blank lines dropped). */
+function streamLines(text, stream, level) {
+    return text
+        .split("\n")
+        .filter((line) => line.length > 0)
+        .map((line) => ({ stream, level, line }));
+}
+/**
+ * Persist a finished run's log: the flat text file (so `log_path` in
+ * task_history keeps resolving for humans and older consumers) plus
+ * structured rows in logs.db keyed by `buildTaskRunId(taskId, startedAt)`.
+ *
+ * The DB write is best-effort, mirroring {@link appendHistory}: an unwritable
+ * logs.db must never fail a task run.
+ */
+function persistRunLog(input) {
+    fs.writeFileSync(input.logPath, input.fileText);
+    try {
+        const db = openLogsDatabase();
+        try {
+            insertTaskLogLines(db, {
+                taskId: input.taskId,
+                runId: buildTaskRunId(input.taskId, input.startedAtIso),
+                ts: input.finishedAtIso,
+                lines: input.dbLines,
+            });
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch (err) {
+        rethrowIfTestIsolationError(err);
+        error(`[akm] task log DB write failed: ${String(err)}`);
     }
-    return `${lines.join("\n")}\n`;
 }
 // ── history ─────────────────────────────────────────────────────────────────
 function appendHistory(result) {

package/dist/workflows/db.js

@@ -47,6 +47,10 @@ export function openWorkflowDatabase(dbPath = getWorkflowDbPath()) {
     }
     const db = openDatabase(dbPath);
     db.exec("PRAGMA journal_mode = WAL");
+    // #589: 30 s busy timeout, matching index.db / state.db. Without it the
+    // default is 0 ms, so any concurrent writer fails immediately with
+    // SQLITE_BUSY.
+    db.exec("PRAGMA busy_timeout = 30000");
     db.exec("PRAGMA foreign_keys = ON");
     ensureBaseSchema(db);
     runMigrations(db);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.9.0-beta.2",
+  "version": "0.9.0-beta.4",
   "type": "module",
   "description": "akm (Agent Knowledge Management) — A package manager for AI agent skills, commands, tools, and knowledge. Works with Claude Code, OpenCode, Cursor, and any AI coding assistant.",
   "keywords": [
@@ -59,6 +59,7 @@
     "test:unit": "bun test --parallel=${TEST_PARALLEL:-12} --timeout=30000 ./tests --path-ignore-patterns=tests/integration",
     "test:integration": "bun test --parallel=${TEST_PARALLEL:-12} --timeout=30000 ./tests/integration ./tests/commands ./tests/workflows",
     "test:node-smoke": "bun scripts/node-smoke.ts",
+    "test:node-compat": "AKM_NODE_COMPAT_TESTS=1 bun test --timeout=120000 tests/integration/node-compat.test.ts",
     "test:sharded": "bun test ./tests --shard=1/4 & bun test ./tests --shard=2/4 & bun test ./tests --shard=3/4 & bun test ./tests --shard=4/4 & wait",
     "test:time": "bun scripts/test-timing-report.ts",
     "lint:isolation": "bun scripts/lint-tests-isolation.ts",