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

package/dist/tasks/runner.js

@@ -12,7 +12,8 @@
  *      `tasks sync` time, not here — at run time we still want to attempt
  *      execution and surface the actual failure rather than re-fail on a
  *      validation error that the user already knows about.)
- *   3. Refuse to run when `enabled === false` (defense-in-depth).
+ *   3. Skip disabled tasks only when the invocation is scheduler-generated;
+ *      explicit manual runs are allowed for catch-up and testing.
  *   4. Dispatch by target kind:
  *        • workflow → `startWorkflowRun(ref, params)`
  *        • prompt   → `executeRunner(engine, prompt, { stdio: "captured" })`
@@ -25,97 +26,135 @@
  * and so tests can assert against it without scraping stdout.
  */
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 import { assertNever } from "../core/assert.js";
 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 { AkmError, NotFoundError, rethrowIfTestIsolationError } from "../core/errors.js";
 import { buildTaskRunId, insertTaskLogLines, openLogsDatabase, } from "../core/logs-db.js";
 import { getTaskLogDir } from "../core/paths.js";
 import { withStateDb } from "../core/state-db.js";
-import { error } from "../core/warn.js";
 import { resolveEngine, resolveLlmEngineUse } from "../integrations/agent/engine-resolution.js";
 import { resolveModel } from "../integrations/agent/model-aliases.js";
 import { executeRunner } from "../integrations/agent/runner-dispatch.js";
 import { chatCompletion } from "../llm/client.js";
 import { spawn } from "../runtime.js";
 import { resolveAssetPath } from "../sources/resolve.js";
-import { decodeTaskHistoryMetadata, getTaskHistory, queryTaskHistory, upsertTaskHistory, } from "../storage/repositories/task-history-repository.js";
+import { decodeTaskHistoryMetadata, finalizeTaskHistoryAttempt, getTaskHistory, queryTaskHistory, reserveTaskHistoryAttempt, upsertTaskHistory, } from "../storage/repositories/task-history-repository.js";
 import { startWorkflowRun } from "../workflows/runtime/runs.js";
+import { findBareAkmExecutableIndex } from "./command-executable.js";
 import { parseTaskDocument } from "./parser.js";
+import { resolveAkmInvocation } from "./resolve-akm-bin.js";
+import { validateTaskId } from "./task-id.js";
+export const INVALID_TASK_ATTEMPT_ID = "_invalid-task-id";
 export async function runTask(id, options = {}) {
-    const stashDir = options.stashDir ?? resolveStashDir();
     const runAgentImpl = options.runAgentImpl;
     const startWorkflowRunImpl = options.startWorkflowRunImpl ?? startWorkflowRun;
     const now = options.now ?? (() => new Date());
-    const logDir = options.logDir ?? getTaskLogDir();
-    const filePath = await resolveAssetPath(stashDir, "task", id);
-    const yaml = fs.readFileSync(filePath, "utf8");
-    const task = parseTaskDocument({ yaml, filePath, id });
-    const startedAt = now();
-    const startedIso = startedAt.toISOString();
-    const tsSlug = startedIso.replace(/[:.]/g, "-");
-    const taskLogDir = path.join(logDir, id);
-    fs.mkdirSync(taskLogDir, { recursive: true });
-    const logPath = path.join(taskLogDir, `${tsSlug}.log`);
-    if (!task.enabled) {
-        const finishedAt = now();
-        const disabledTarget = task.target.kind === "workflow"
-            ? { kind: "workflow", ref: task.target.ref }
-            : task.target.kind === "command"
-                ? { kind: "command", cmd: task.target.cmd }
-                : { kind: "prompt", engine: task.target.engine ?? null };
-        const result = {
-            id,
-            status: "disabled",
-            startedAt: startedIso,
-            finishedAt: finishedAt.toISOString(),
-            durationMs: finishedAt.getTime() - startedAt.getTime(),
-            log: logPath,
-            target: disabledTarget,
-        };
-        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 }],
+    const requestedStartedAt = now();
+    try {
+        validateTaskId(id);
+    }
+    catch (failure) {
+        const attempt = reserveTaskAttempt(INVALID_TASK_ATTEMPT_ID, requestedStartedAt);
+        recordTaskAttemptFailure({
+            taskId: INVALID_TASK_ATTEMPT_ID,
+            reason: "invalid_task_id",
+            failure,
+            startedAt: attempt.startedAt,
+            finishedAt: now(),
+            logDir: options.logDir,
+            historyReserved: attempt.historyReserved,
         });
-        appendHistory(result);
-        return result;
+        throw failure;
     }
-    if (task.target.kind === "workflow") {
-        return await runWorkflowTask({
+    const attempt = reserveTaskAttempt(id, requestedStartedAt);
+    const startedAt = attempt.startedAt;
+    let failureReason = "task_load_failed";
+    try {
+        const stashDir = options.stashDir ?? resolveStashDir();
+        const filePath = await resolveAssetPath(stashDir, "task", id);
+        const yaml = fs.readFileSync(filePath, "utf8");
+        failureReason = "task_parse_failed";
+        const task = parseTaskDocument({ yaml, filePath, id });
+        failureReason = "task_dispatch_failed";
+        const startedIso = startedAt.toISOString();
+        const logPath = resolveTaskLogPath(options.logDir, id, startedIso);
+        if (!task.enabled && options.scheduled === true) {
+            const finishedAt = finishAttempt(startedAt, now());
+            const disabledTarget = task.target.kind === "workflow"
+                ? { kind: "workflow", ref: task.target.ref }
+                : task.target.kind === "command"
+                    ? { kind: "command", cmd: task.target.cmd }
+                    : { kind: "prompt", engine: task.target.engine ?? null };
+            const result = {
+                id,
+                status: "disabled",
+                startedAt: startedIso,
+                finishedAt: finishedAt.toISOString(),
+                durationMs: finishedAt.getTime() - startedAt.getTime(),
+                log: logPath,
+                target: disabledTarget,
+            };
+            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, attempt.historyReserved);
+            return result;
+        }
+        if (task.target.kind === "workflow") {
+            return await runWorkflowTask({
+                task,
+                logPath,
+                startedAt,
+                now,
+                startWorkflowRunImpl,
+                historyReserved: attempt.historyReserved,
+            });
+        }
+        if (task.target.kind === "command") {
+            return await runCommandTask({ task, logPath, startedAt, now, historyReserved: attempt.historyReserved });
+        }
+        return await runPromptTask({
             task,
+            stashDir,
             logPath,
             startedAt,
             now,
-            startWorkflowRunImpl,
+            runAgentImpl,
+            agentOptions: options.agentOptions,
+            chatCompletionImpl: options.chatCompletionImpl ?? chatCompletion,
+            historyReserved: attempt.historyReserved,
         });
     }
-    if (task.target.kind === "command") {
-        return await runCommandTask({ task, logPath, startedAt, now });
+    catch (failure) {
+        recordTaskAttemptFailure({
+            taskId: id,
+            reason: failureReason,
+            failure,
+            startedAt,
+            finishedAt: now(),
+            logDir: options.logDir,
+            historyReserved: attempt.historyReserved,
+        });
+        throw failure;
     }
-    return await runPromptTask({
-        task,
-        stashDir,
-        logPath,
-        startedAt,
-        now,
-        runAgentImpl,
-        agentOptions: options.agentOptions,
-        chatCompletionImpl: options.chatCompletionImpl ?? chatCompletion,
-    });
 }
 // ── command target ──────────────────────────────────────────────────────────
 async function runCommandTask(input) {
-    const { task, logPath, startedAt, now } = input;
+    const { task, logPath, startedAt, now, historyReserved } = input;
     if (task.target.kind !== "command")
         throw new Error("invariant: command target");
     const { cmd } = task.target;
+    const spawnCmd = resolveNestedAkmCommand(cmd);
     const timeoutMs = task.timeoutMs !== undefined ? task.timeoutMs : null;
     const header = `[akm tasks] task=${task.id} kind=command cmd=${cmd.join(" ")}`;
     const logLines = [header];
@@ -124,11 +163,11 @@ async function runCommandTask(input) {
     let stderr = "";
     let exitCode = null;
     try {
-        const proc = spawn(cmd, {
+        const proc = spawn(spawnCmd, {
             stdin: "ignore",
             stdout: "pipe",
             stderr: "pipe",
-            cwd: process.env.HOME ?? "/tmp",
+            cwd: process.env.HOME ?? os.tmpdir(),
             // Stamp task-runner provenance so any akm invocation in the command tree
             // records usage events as machine traffic, not user demand (DRIFT-6).
             // A more specific stamp already in the environment (e.g. improve's
@@ -181,7 +220,7 @@ async function runCommandTask(input) {
         dbLines.push({ level: "error", line: `spawn_error=${msg}` });
         exitCode = 1;
     }
-    const finishedAt = now();
+    const finishedAt = finishAttempt(startedAt, now());
     persistRunLog({
         taskId: task.id,
         startedAtIso: startedAt.toISOString(),
@@ -201,12 +240,19 @@ async function runCommandTask(input) {
         target: { kind: "command", cmd },
         detail: { exitCode },
     };
-    appendHistory(result);
+    appendHistory(result, historyReserved);
     return result;
 }
+/** Avoid a second PATH lookup when a task invokes the same AKM installation. */
+function resolveNestedAkmCommand(cmd) {
+    const akmIndex = findBareAkmExecutableIndex(cmd);
+    if (akmIndex === undefined)
+        return cmd;
+    return [...cmd.slice(0, akmIndex), ...resolveAkmInvocation().argv, ...cmd.slice(akmIndex + 1)];
+}
 // ── workflow target ─────────────────────────────────────────────────────────
 async function runWorkflowTask(input) {
-    const { task, logPath, startedAt, now, startWorkflowRunImpl } = input;
+    const { task, logPath, startedAt, now, startWorkflowRunImpl, historyReserved } = input;
     if (task.target.kind !== "workflow")
         throw new Error("invariant: workflow target");
     const ref = parseAssetRef(task.target.ref);
@@ -219,9 +265,11 @@ async function runWorkflowTask(input) {
         detail = await startWorkflowRunImpl(task.target.ref, task.target.params);
     }
     catch (e) {
+        if (e instanceof AkmError && e.kind === "config")
+            throw e;
         error = e instanceof Error ? e : new Error(String(e));
     }
-    const finishedAt = now();
+    const finishedAt = finishAttempt(startedAt, now());
     const status = error ? "failed" : mapWorkflowStatus(detail?.run.status);
     const log = renderWorkflowLog({ task, detail, error });
     persistRunLog({
@@ -245,7 +293,7 @@ async function runWorkflowTask(input) {
             ...(error ? { error: error.message } : {}),
         },
     };
-    appendHistory(result);
+    appendHistory(result, historyReserved);
     // Don't re-throw on workflow failure: the OS scheduler reads exit codes,
     // not exceptions, and the CLI maps `status: "failed"` to a non-zero exit
     // via exitCodeForStatus(). Throwing here would route through the generic
@@ -359,7 +407,7 @@ async function runPromptTask(input) {
             return { ok: true, exitCode: 0, stdout, stderr: "", durationMs: Date.now() - started };
         },
     });
-    const finishedAt = now();
+    const finishedAt = finishAttempt(startedAt, now());
     const log = renderPromptLog({ task, engineName, result });
     persistRunLog({
         taskId: task.id,
@@ -382,7 +430,7 @@ async function runPromptTask(input) {
             ? { exitCode: result.exitCode }
             : { reason: result.reason, error: result.error, exitCode: result.exitCode },
     };
-    appendHistory(out);
+    appendHistory(out, input.historyReserved);
     return out;
 }
 async function resolvePromptText(task, stashDir) {
@@ -428,6 +476,19 @@ function renderPromptLog(input) {
     }
     return { fileText: `${lines.join("\n")}\n`, dbLines };
 }
+function taskLogPath(logDir, taskId, startedAtIso) {
+    const tsSlug = startedAtIso.replace(/[:.]/g, "-");
+    return path.join(logDir, taskId, `${tsSlug}.log`);
+}
+function resolveTaskLogPath(logDir, taskId, startedAtIso) {
+    try {
+        return taskLogPath(logDir ?? getTaskLogDir(), taskId, startedAtIso);
+    }
+    catch (error) {
+        rethrowIfTestIsolationError(error);
+        return "";
+    }
+}
 /** Split captured pipe output into per-line logs.db rows (blank lines dropped). */
 function streamLines(text, stream, level) {
     return text
@@ -444,7 +505,16 @@ function streamLines(text, stream, level) {
  * logs.db must never fail a task run.
  */
 function persistRunLog(input) {
-    fs.writeFileSync(input.logPath, input.fileText);
+    if (input.logPath) {
+        try {
+            fs.mkdirSync(path.dirname(input.logPath), { recursive: true });
+            fs.writeFileSync(input.logPath, input.fileText);
+        }
+        catch (error) {
+            rethrowIfTestIsolationError(error);
+            // Transitional file logging is fully best-effort.
+        }
+    }
     try {
         const db = openLogsDatabase();
         try {
@@ -459,36 +529,129 @@ function persistRunLog(input) {
             db.close();
         }
     }
-    catch (err) {
-        rethrowIfTestIsolationError(err);
-        error(`[akm] task log DB write failed: ${String(err)}`);
+    catch (error) {
+        rethrowIfTestIsolationError(error);
+        // Structured logging is fully best-effort and must not alter CLI output.
+    }
+}
+/** Reserve a collision-free identity through state.db's existing unique index. */
+function reserveTaskAttempt(taskId, requestedStartedAt) {
+    try {
+        return withStateDb((db) => {
+            for (let offsetMs = 0;; offsetMs++) {
+                const startedAt = new Date(requestedStartedAt.getTime() + offsetMs);
+                const reserved = reserveTaskHistoryAttempt(db, {
+                    task_id: taskId,
+                    status: "active",
+                    started_at: startedAt.toISOString(),
+                    completed_at: null,
+                    failed_at: null,
+                    log_path: null,
+                    target_kind: null,
+                    target_ref: null,
+                    metadata_json: JSON.stringify({ metadataVersion: 2, durationMs: 0, detail: null }),
+                });
+                if (reserved)
+                    return { startedAt, historyReserved: true };
+            }
+        });
+    }
+    catch (error) {
+        rethrowIfTestIsolationError(error);
+        // Attempt recording cannot prevent or replace task execution.
+        return { startedAt: requestedStartedAt, historyReserved: false };
+    }
+}
+function finishAttempt(startedAt, observedFinishedAt) {
+    return observedFinishedAt.getTime() < startedAt.getTime() ? new Date(startedAt) : observedFinishedAt;
+}
+const SAFE_TASK_ATTEMPT_ERROR_CODES = new Set([
+    "CONFIG_DIR_UNRESOLVABLE",
+    "STASH_DIR_NOT_FOUND",
+    "STASH_DIR_NOT_A_DIRECTORY",
+    "STASH_DIR_UNREADABLE",
+    "LLM_NOT_CONFIGURED",
+    "INVALID_CONFIG_FILE",
+    "UNSUPPORTED_CONFIG_VERSION",
+    "TEST_ISOLATION_MISSING",
+    "INVALID_FLAG_VALUE",
+    "MISSING_REQUIRED_ARGUMENT",
+    "PATH_ESCAPE_VIOLATION",
+    "TASK_SCHEMA_VERSION_UNSUPPORTED",
+    "ASSET_NOT_FOUND",
+    "WORKFLOW_NOT_FOUND",
+    "FILE_NOT_FOUND",
+]);
+function safeTaskAttemptErrorCode(failure) {
+    if (failure instanceof AkmError && SAFE_TASK_ATTEMPT_ERROR_CODES.has(failure.code))
+        return failure.code;
+    return "INTERNAL";
+}
+export function recordTaskAttemptFailure(input) {
+    let taskId = input.taskId;
+    try {
+        validateTaskId(taskId);
+    }
+    catch {
+        taskId = INVALID_TASK_ATTEMPT_ID;
     }
+    const attempt = input.historyReserved === undefined
+        ? reserveTaskAttempt(taskId, input.startedAt)
+        : { startedAt: input.startedAt, historyReserved: input.historyReserved };
+    const finishedAt = finishAttempt(attempt.startedAt, input.finishedAt ?? new Date());
+    const startedAtIso = attempt.startedAt.toISOString();
+    const finishedAtIso = finishedAt.toISOString();
+    const errorCode = safeTaskAttemptErrorCode(input.failure);
+    const logPath = resolveTaskLogPath(input.logDir, taskId, startedAtIso);
+    const line = `[akm tasks] status=failed reason=${input.reason} code=${errorCode}`;
+    const result = {
+        id: taskId,
+        status: "failed",
+        startedAt: startedAtIso,
+        finishedAt: finishedAtIso,
+        durationMs: Math.max(0, finishedAt.getTime() - attempt.startedAt.getTime()),
+        log: logPath,
+        target: { kind: "unknown" },
+        detail: { reason: input.reason, error: errorCode },
+    };
+    persistRunLog({
+        taskId,
+        startedAtIso,
+        finishedAtIso,
+        logPath,
+        fileText: `${line}\n`,
+        dbLines: [{ level: "error", line }],
+    });
+    appendHistory(result, attempt.historyReserved);
 }
 // ── history ─────────────────────────────────────────────────────────────────
-function appendHistory(result) {
+function appendHistory(result, historyReserved = false) {
+    const row = {
+        task_id: result.id,
+        status: result.status,
+        started_at: result.startedAt,
+        completed_at: result.finishedAt,
+        failed_at: result.status === "failed" ? result.finishedAt : null,
+        log_path: result.log || null,
+        target_kind: result.target.kind === "unknown" ? null : result.target.kind,
+        target_ref: result.target.kind === "workflow" ? result.target.ref : null,
+        metadata_json: JSON.stringify({
+            metadataVersion: 2,
+            durationMs: result.durationMs,
+            detail: result.detail ?? null,
+            ...(result.target.kind === "prompt" ? { engine: result.target.engine } : {}),
+        }),
+    };
     try {
         withStateDb((db) => {
-            upsertTaskHistory(db, {
-                task_id: result.id,
-                status: result.status,
-                started_at: result.startedAt,
-                completed_at: result.finishedAt,
-                failed_at: result.status === "failed" ? result.finishedAt : null,
-                log_path: result.log,
-                target_kind: result.target.kind,
-                target_ref: result.target.kind === "workflow" ? result.target.ref : null,
-                metadata_json: JSON.stringify({
-                    metadataVersion: 2,
-                    durationMs: result.durationMs,
-                    detail: result.detail ?? null,
-                    ...(result.target.kind === "prompt" ? { engine: result.target.engine } : {}),
-                }),
-            });
+            if (historyReserved && finalizeTaskHistoryAttempt(db, row))
+                return;
+            upsertTaskHistory(db, row);
         });
     }
-    catch (err) {
-        rethrowIfTestIsolationError(err);
-        error(`[akm] task history DB write failed: ${String(err)}`);
+    catch (error) {
+        rethrowIfTestIsolationError(error);
+        // History recording is fully best-effort and must not alter CLI output.
     }
 }
 export function readTaskHistory(options = {}) {
@@ -518,9 +681,11 @@ function taskHistoryRowToResult(row) {
         ? { kind: "workflow", ref: row.target_ref ?? "" }
         : row.target_kind === "command"
             ? { kind: "command" }
-            : meta.metadataVersion === 2
-                ? { kind: "prompt", engine: meta.engine ?? null }
-                : { kind: "prompt", engine: null, ...(meta.legacyProfile ? { legacyProfile: meta.legacyProfile } : {}) };
+            : row.target_kind === "prompt"
+                ? meta.metadataVersion === 2
+                    ? { kind: "prompt", engine: meta.engine ?? null }
+                    : { kind: "prompt", engine: null, ...(meta.legacyProfile ? { legacyProfile: meta.legacyProfile } : {}) }
+                : { kind: "unknown" };
     return {
         id: row.task_id,
         status: row.status,