akm-cli 0.9.0-rc.8 → 0.9.0

package/dist/tasks/resolve-akm-bin.js

@@ -9,17 +9,14 @@
  *
  * Resolution order:
  *
- *   1. `$AKM_BIN` (explicit override; takes precedence everywhere).
- *   2. `process.execPath` alone for a Bun standalone executable.
- *   3. `process.execPath` + the resolved CLI script — works when running
- *      from a development checkout (`bun /repo/src/cli.ts`) and from a
- *      compiled install (`bun /opt/akm/dist/cli.js`).
- *   4. `which akm` / `where akm` — last resort when the binary is on PATH
- *      but neither override applies.
+ *   1. `process.execPath` alone for a Bun standalone executable.
+ *   2. Absolute Node plus the public `dist/akm` package launcher.
+ *   3. Absolute runtime plus the source/build CLI entry, classified as a
+ *      checkout that requires explicit `--rebind` for scheduler writes.
  *
  * Returns the argv array the scheduler should execute (e.g.
- * `["/usr/local/bin/bun", "/repo/dist/cli.js"]`). The caller appends
- * subcommand args (`"tasks", "run", "<id>"`).
+ * `["/usr/local/bin/node", "/repo/dist/cli-node.mjs"]`). The caller appends
+ * subcommand args (`"task", "run", "<id>"`).
  */
 import { spawnSync } from "node:child_process";
 import fs from "node:fs";
@@ -29,74 +26,155 @@ import { ConfigError } from "../core/errors.js";
 import { mainPath as runtimeMainPath } from "../runtime.js";
 export function resolveAkmInvocation(options = {}) {
     const env = options.env ?? process.env;
-    const override = env.AKM_BIN?.trim();
-    if (override) {
-        return { argv: [override], via: "AKM_BIN" };
-    }
     const runtime = options.runtime ?? (process.versions.bun ? "bun" : "node");
     const execPath = options.execPath ?? process.execPath;
     const mainPath = options.mainPath ?? runtimeMainPath;
     const isStandaloneMain = mainPath?.startsWith("/$bunfs/") || (mainPath !== undefined && /^[A-Za-z]:[\\/]~BUN[\\/]/i.test(mainPath));
     if (runtime === "bun" && isStandaloneMain && execPath) {
-        return { argv: [execPath], via: "execPath" };
+        return { argv: [absoluteInvocationPath(execPath)], via: "standalone", kind: "standalone", eligible: true };
+    }
+    const launcherPath = options.launcherPath ?? env.AKM_LAUNCHER_PATH?.trim();
+    const nodePath = options.nodePath ?? env.AKM_LAUNCHER_NODE?.trim() ?? (runtime === "node" ? execPath : undefined);
+    if (launcherPath && nodePath && isPublicPackageLauncher(launcherPath)) {
+        const checkout = isCheckoutLauncher(launcherPath);
+        let npmGlobalRoot;
+        if (!checkout) {
+            try {
+                npmGlobalRoot = (options.resolveNpmGlobalRoot ?? ((node) => resolveNpmGlobalRoot(node, env)))(nodePath);
+            }
+            catch {
+                // An unprovable package installation is intentionally ineligible.
+            }
+        }
+        const npmGlobal = !checkout && packageBelongsToNpmGlobalRoot(launcherPath, npmGlobalRoot);
+        const kind = checkout ? "checkout" : npmGlobal ? "npm" : "package-local";
+        return {
+            argv: [absoluteInvocationPath(nodePath), absoluteInvocationPath(launcherPath)],
+            via: kind,
+            kind,
+            eligible: npmGlobal,
+        };
+    }
+    const checkoutEntry = resolveCheckoutEntry(options.cliEntryUrl ?? import.meta.url, runtime, mainPath);
+    if (checkoutEntry && execPath) {
+        return {
+            argv: [absoluteInvocationPath(execPath), absoluteInvocationPath(checkoutEntry)],
+            via: "checkout",
+            kind: "checkout",
+            eligible: false,
+        };
     }
-    const cliPath = resolveCliEntry(options.cliEntryUrl ?? import.meta.url);
-    if (cliPath && execPath) {
-        const entry = runtime === "node" ? resolveNodeCliEntry(cliPath) : cliPath;
-        if (entry)
-            return { argv: [execPath, entry], via: "execPath" };
+    throw new ConfigError("Cannot resolve absolute path to the akm binary for scheduler registration.", "INVALID_CONFIG_FILE", "Run the npm-global launcher or a standalone akm executable.");
+}
+function resolveCheckoutEntry(moduleUrl, runtime, mainPath) {
+    try {
+        const modulePath = fileURLToPath(moduleUrl);
+        const parent = path.dirname(path.dirname(modulePath));
+        if (runtime === "node") {
+            const wrapper = path.join(parent, "cli-node.mjs");
+            if (fs.existsSync(wrapper))
+                return wrapper;
+            if (mainPath) {
+                if (path.basename(mainPath) === "cli-node.mjs" && fs.existsSync(mainPath))
+                    return mainPath;
+                const siblingWrapper = path.join(path.dirname(mainPath), "cli-node.mjs");
+                if (fs.existsSync(siblingWrapper))
+                    return siblingWrapper;
+            }
+            return undefined;
+        }
+        const extension = path.extname(modulePath);
+        const candidate = path.join(parent, `cli${extension}`);
+        if (fs.existsSync(candidate))
+            return candidate;
+        const alternate = path.join(parent, extension === ".ts" ? "cli.js" : "cli.ts");
+        return fs.existsSync(alternate) ? alternate : undefined;
     }
-    const whichBin = findOnPath("akm", env);
-    if (whichBin) {
-        return { argv: [whichBin], via: "which" };
+    catch {
+        return runtime === "bun" ? mainPath : undefined;
     }
-    throw new ConfigError("Cannot resolve absolute path to the akm binary for scheduler registration.", "INVALID_CONFIG_FILE", "Set AKM_BIN to the absolute path of the akm binary, or ensure `akm` is on PATH.");
 }
-function resolveNodeCliEntry(cliPath) {
-    const wrapper = path.join(path.dirname(cliPath), "cli-node.mjs");
-    return fs.existsSync(wrapper) ? wrapper : undefined;
+function absoluteInvocationPath(value) {
+    return path.win32.isAbsolute(value) || path.posix.isAbsolute(value) ? value : path.resolve(value);
 }
-/**
- * From the URL of a module inside `src/tasks/` figure out the CLI entry.
- *
- *   • dev      `…/src/tasks/resolve-akm-bin.ts`   → `…/src/cli.ts`
- *   • build    `…/dist/tasks/resolve-akm-bin.js`  → `…/dist/cli.js`
- */
-function resolveCliEntry(moduleUrl) {
-    let modulePath;
+function isPublicPackageLauncher(file) {
+    return (path.basename(file).toLowerCase() === "akm" &&
+        path.basename(path.dirname(file)).toLowerCase() === "dist" &&
+        fs.existsSync(file));
+}
+function isCheckoutLauncher(file) {
+    let launcher = path.resolve(file);
     try {
-        modulePath = fileURLToPath(moduleUrl);
+        launcher = fs.realpathSync(file);
     }
     catch {
-        return undefined;
+        // The caller gets a missing-path diagnostic from doctor.
     }
-    const dir = path.dirname(modulePath); // .../tasks
-    const parent = path.dirname(dir); // .../src or .../dist
-    const ext = path.extname(modulePath); // .ts | .js
-    const candidate = path.join(parent, `cli${ext}`);
-    if (fs.existsSync(candidate))
-        return candidate;
-    // Fallback: try the other extension.
-    const alt = path.join(parent, ext === ".ts" ? "cli.js" : "cli.ts");
-    if (fs.existsSync(alt))
-        return alt;
-    return undefined;
+    const packageRoot = path.dirname(path.dirname(launcher));
+    return fs.existsSync(path.join(packageRoot, ".git"));
 }
-function findOnPath(bin, env) {
-    const tool = process.platform === "win32" ? "where" : "which";
+function packageBelongsToNpmGlobalRoot(launcherPath, npmGlobalRoot) {
+    if (!npmGlobalRoot)
+        return false;
     try {
-        const out = spawnSync(tool, [bin], { encoding: "utf8", env });
-        if (out.status === 0 && typeof out.stdout === "string") {
-            const first = out.stdout
-                .split(/\r?\n/)
-                .map((s) => s.trim())
-                .find(Boolean);
-            if (first && fs.existsSync(first))
-                return first;
-        }
+        const packageRoot = path.dirname(path.dirname(fs.realpathSync(launcherPath)));
+        const globalRoot = fs.realpathSync(npmGlobalRoot);
+        const metadata = JSON.parse(fs.readFileSync(path.join(packageRoot, "package.json"), "utf8"));
+        return metadata.name === "akm-cli" && samePath(path.dirname(packageRoot), globalRoot);
     }
     catch {
-        // ignore — caller will throw a ConfigError
+        return false;
+    }
+}
+function samePath(left, right) {
+    const normalize = (value) => {
+        const resolved = path.resolve(value);
+        return process.platform === "win32" ? resolved.toLowerCase() : resolved;
+    };
+    return normalize(left) === normalize(right);
+}
+function resolveNpmGlobalRoot(nodePath, env) {
+    const npmCli = resolveAssociatedNpmCli(nodePath);
+    if (!npmCli)
+        return undefined;
+    const result = spawnSync(absoluteInvocationPath(nodePath), [npmCli, "root", "--global"], {
+        encoding: "utf8",
+        env,
+        stdio: ["ignore", "pipe", "ignore"],
+        timeout: 5_000,
+        windowsHide: true,
+    });
+    if (result.status !== 0)
+        return undefined;
+    const lines = result.stdout.trim().split(/\r?\n/);
+    if (lines.length !== 1 || !lines[0] || !path.isAbsolute(lines[0]))
+        return undefined;
+    return lines[0];
+}
+function resolveAssociatedNpmCli(nodePath) {
+    const nodeDirs = new Set([path.dirname(absoluteInvocationPath(nodePath))]);
+    try {
+        nodeDirs.add(path.dirname(fs.realpathSync(nodePath)));
+    }
+    catch {
+        // The scheduler binding will separately report a missing Node path.
+    }
+    for (const binDir of nodeDirs) {
+        const candidates = [
+            ...(process.platform === "win32" ? [] : [path.join(binDir, "npm")]),
+            path.join(binDir, "node_modules", "npm", "bin", "npm-cli.js"),
+            path.join(path.dirname(binDir), "lib", "node_modules", "npm", "bin", "npm-cli.js"),
+        ];
+        for (const candidate of candidates) {
+            try {
+                const resolved = fs.realpathSync(candidate);
+                if (fs.statSync(resolved).isFile())
+                    return resolved;
+            }
+            catch {
+                // Try the next layout associated with this Node installation.
+            }
+        }
     }
     return undefined;
 }

package/dist/tasks/runner.js

@@ -2,7 +2,7 @@
 // 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/.
 /**
- * `akm tasks run <id>` — what cron / launchd / schtasks invoke at the
+ * `akm task run <id>` — what cron / launchd / schtasks invoke at the
  * scheduled moment.
  *
  * Responsibilities:
@@ -15,7 +15,7 @@
  *   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)`
+ *        • workflow → `runWorkflowSteps({ target: ref, params })`
  *        • prompt   → `executeRunner(engine, prompt, { stdio: "captured" })`
  *   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`
@@ -30,20 +30,23 @@ import os from "node:os";
 import path from "node:path";
 import { shouldSkipUnactivatedTask } from "../core/activation-policy.js";
 import { assertNever } from "../core/assert.js";
+import { placementSpecFor } from "../core/asset/asset-placement.js";
 import { parseRefInput } from "../core/asset/resolve-ref.js";
 import { loadConfig } from "../core/config/config.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 { redactCredentialPatterns } from "../core/redaction.js";
 import { withStateDb } from "../core/state-db.js";
 import { runManagedSubprocess } from "../core/subprocess.js";
+import { fallbackAnnouncement, NO_ENGINE_MESSAGE_SUFFIX, NO_ENGINE_REMEDY, withEngineFallback, } from "../integrations/agent/engine-fallback.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 { resolveAssetPath } from "../sources/resolve.js";
 import { decodeTaskHistoryMetadata, finalizeTaskHistoryAttempt, getTaskHistory, queryTaskHistory, reserveTaskHistoryAttempt, upsertTaskHistory, } from "../storage/repositories/task-history-repository.js";
-import { startWorkflowRun } from "../workflows/runtime/runs.js";
+import { runWorkflowSteps } from "../workflows/exec/run-workflow.js";
 import { findBareAkmExecutableIndex } from "./command-executable.js";
 import { parseTaskDocument } from "./parser.js";
 import { resolveAkmInvocation } from "./resolve-akm-bin.js";
@@ -51,7 +54,7 @@ import { validateTaskId } from "./task-id.js";
 export const INVALID_TASK_ATTEMPT_ID = "_invalid-task-id";
 export async function runTask(id, options) {
     const runAgentImpl = options.runAgentImpl;
-    const startWorkflowRunImpl = options.startWorkflowRunImpl ?? startWorkflowRun;
+    const runWorkflowStepsImpl = options.runWorkflowStepsImpl ?? runWorkflowSteps;
     const now = options.now ?? (() => new Date());
     const requestedStartedAt = now();
     try {
@@ -98,7 +101,7 @@ export async function runTask(id, options) {
                 log: logPath,
                 target: disabledTarget,
             };
-            const disabledLine = `[akm tasks] task "${id}" is disabled — skipping run.`;
+            const disabledLine = `[akm task] task "${id}" is disabled — skipping run.`;
             persistRunLog({
                 taskId: id,
                 startedAtIso: startedIso,
@@ -116,7 +119,7 @@ export async function runTask(id, options) {
                 logPath,
                 startedAt,
                 now,
-                startWorkflowRunImpl,
+                runWorkflowStepsImpl,
                 historyReserved: attempt.historyReserved,
             });
         }
@@ -165,7 +168,7 @@ async function runCommandTask(input) {
     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 header = `[akm task] task=${task.id} kind=command cmd=${cmd.join(" ")}`;
     const logLines = [header];
     const dbLines = [{ line: header }];
     let exitCode = null;
@@ -246,7 +249,7 @@ function resolveNestedAkmCommand(cmd) {
 }
 // ── workflow target ─────────────────────────────────────────────────────────
 async function runWorkflowTask(input) {
-    const { task, logPath, startedAt, now, startWorkflowRunImpl, historyReserved } = input;
+    const { task, logPath, startedAt, now, runWorkflowStepsImpl, historyReserved } = input;
     if (task.target.kind !== "workflow")
         throw new Error("invariant: workflow target");
     const ref = parseRefInput(task.target.ref);
@@ -254,9 +257,18 @@ async function runWorkflowTask(input) {
         throw new NotFoundError(`Task "${task.id}" workflow target must be a workflow ref (got "${task.target.ref}").`, "WORKFLOW_NOT_FOUND");
     }
     let detail;
+    let gateError;
     let error;
+    // The prompt path logs the engine-fallback announcement; a workflow-backed
+    // task must leave the same trace rather than silently using a chosen engine.
+    let runWarnings = [];
     try {
-        detail = await startWorkflowRunImpl(task.target.ref, task.target.params);
+        const execution = await runWorkflowStepsImpl({ target: task.target.ref, params: task.target.params });
+        detail = execution.run;
+        runWarnings = execution.warnings ?? [];
+        if (execution.gateRejection) {
+            gateError = `Verification rejected step "${execution.gateRejection.stepId}": ${execution.gateRejection.feedback}`;
+        }
     }
     catch (e) {
         if (e instanceof AkmError && e.kind === "config")
@@ -264,8 +276,13 @@ async function runWorkflowTask(input) {
         error = e instanceof Error ? e : new Error(String(e));
     }
     const finishedAt = finishAttempt(startedAt, now());
-    const status = error ? "failed" : mapWorkflowStatus(detail?.run.status);
-    const log = renderWorkflowLog({ task, detail, error });
+    const status = error || gateError ? "failed" : mapWorkflowStatus(detail?.status);
+    const log = renderWorkflowLog({
+        task,
+        detail,
+        error: error ?? (gateError ? new Error(gateError) : undefined),
+        warnings: runWarnings,
+    });
     persistRunLog({
         taskId: task.id,
         startedAtIso: startedAt.toISOString(),
@@ -283,8 +300,8 @@ async function runWorkflowTask(input) {
         log: logPath,
         target: { kind: "workflow", ref: task.target.ref },
         detail: {
-            runId: detail?.run.id,
-            ...(error ? { error: error.message } : {}),
+            runId: detail?.id,
+            ...(error ? { error: error.message } : gateError ? { error: gateError } : {}),
         },
     };
     appendHistory(result, historyReserved);
@@ -297,10 +314,8 @@ async function runWorkflowTask(input) {
 }
 /**
  * Map the workflow runtime's status into the task-runner status space.
- * Workflows can legitimately remain `active` after `startWorkflowRun`
- * returns (multi-step workflows pause for user input); recording them as
- * "completed" would be misleading. We preserve "active" as a first-class
- * task status with exit code 0 — the OS scheduler treats it as success.
+ * A workflow normally reaches completed or failed in one orchestration call.
+ * Active remains representable for explicit engine stops such as a gate.
  *
  * The parameter is typed as the runtime's `WorkflowRunStatus` union (plus the
  * `undefined` that `detail?.run.status` can produce when no detail is present).
@@ -326,11 +341,13 @@ function mapWorkflowStatus(status) {
 }
 function renderWorkflowLog(input) {
     const dbLines = [
-        { line: `[akm tasks] task=${input.task.id} kind=workflow ref=${input.task.target.ref}` },
+        { line: `[akm task] task=${input.task.id} kind=workflow ref=${input.task.target.ref}` },
     ];
+    for (const warning of input.warnings ?? [])
+        dbLines.push({ level: "warn", line: warning });
     if (input.detail) {
-        dbLines.push({ line: `run_id=${input.detail.run.id} status=${input.detail.run.status}` });
-        dbLines.push({ line: `workflow_title=${input.detail.run.workflowTitle}` });
+        dbLines.push({ line: `run_id=${input.detail.id} status=${input.detail.status}` });
+        dbLines.push({ line: `workflow_title=${input.detail.workflowTitle}` });
     }
     if (input.error) {
         dbLines.push({ level: "error", line: `error=${input.error.message}` });
@@ -343,10 +360,15 @@ async function runPromptTask(input) {
     if (task.target.kind !== "prompt")
         throw new Error("invariant: prompt target");
     const promptTarget = task.target;
-    const config = loadConfig();
+    // Same implicit opencode-sdk fallback the workflow freeze boundary applies,
+    // so a scheduled prompt task on an engine-less install behaves identically.
+    const { config, fallbackEngineName } = withEngineFallback(loadConfig());
     const engineName = promptTarget.engine ?? config.defaults?.engine;
+    // `promptTarget.engine` outranks `defaults.engine`, so the fallback is only
+    // reportable when it is the engine actually selected.
+    const engineAnnouncement = fallbackAnnouncement(fallbackEngineName, engineName);
     if (!engineName)
-        throw new NotFoundError(`Task "${task.id}" has no selected engine.`, "ASSET_NOT_FOUND");
+        throw new NotFoundError(`Task "${task.id}" ${NO_ENGINE_MESSAGE_SUFFIX} ${NO_ENGINE_REMEDY}`, "ASSET_NOT_FOUND");
     let runner = resolveEngine(engineName, config);
     if (runner.kind === "llm") {
         const resolved = resolveLlmEngineUse(config, [
@@ -402,7 +424,7 @@ async function runPromptTask(input) {
         },
     });
     const finishedAt = finishAttempt(startedAt, now());
-    const log = renderPromptLog({ task, engineName, result });
+    const log = renderPromptLog({ task, engineName, result, engineAnnouncement });
     persistRunLog({
         taskId: task.id,
         startedAtIso: startedAt.toISOString(),
@@ -443,16 +465,26 @@ async function resolvePromptText(task, stashDir) {
     }
     // asset
     const ref = parseRefInput(src.ref);
+    // D11 — see the matching guard in validator.ts: `resolveAssetPath`
+    // (src/sources/resolve.ts) is placement-dir-only and cannot route an
+    // opaque adapter conceptId, which `parseRefInput` now otherwise accepts.
+    if (placementSpecFor(ref.type) === undefined) {
+        throw new NotFoundError(`Task "${task.id}" prompt asset ref "${src.ref}" is not an AKM-placed asset — adapter-owned (opaque) prompt sources are not resolvable as task inputs yet.`, "ASSET_NOT_FOUND");
+    }
     const assetPath = await resolveAssetPath(stashDir, ref.type, ref.name);
     return fs.readFileSync(assetPath, "utf8");
 }
 function renderPromptLog(input) {
     const lines = [];
     const dbLines = [];
-    const header = `[akm tasks] task=${input.task.id} kind=prompt engine=${input.engineName}`;
+    const header = `[akm task] task=${input.task.id} kind=prompt engine=${input.engineName}`;
     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.engineAnnouncement) {
+        lines.push(input.engineAnnouncement);
+        dbLines.push({ level: "warn", line: input.engineAnnouncement });
+    }
     if (!input.result.ok) {
         const failure = `reason=${input.result.reason ?? ""} error=${input.result.error ?? ""}`;
         lines.push(failure);
@@ -495,14 +527,21 @@ function streamLines(text, stream, level) {
  * task_history keeps resolving for humans and older consumers) plus
  * structured rows in logs.db keyed by `buildTaskRunId(taskId, startedAt)`.
  *
+ * Both sinks are pattern-redacted (`redactCredentialPatterns`) before being
+ * written — task output is raw command/agent/LLM text that can echo a
+ * credential-bearing URL (e.g. a Discord webhook) nothing upstream expects to
+ * scrub.
+ *
  * The DB write is best-effort, mirroring {@link appendHistory}: an unwritable
  * logs.db must never fail a task run.
  */
 function persistRunLog(input) {
+    const fileText = redactCredentialPatterns(input.fileText);
+    const dbLines = input.dbLines.map((entry) => ({ ...entry, line: redactCredentialPatterns(entry.line) }));
     if (input.logPath) {
         try {
             fs.mkdirSync(path.dirname(input.logPath), { recursive: true });
-            fs.writeFileSync(input.logPath, input.fileText);
+            fs.writeFileSync(input.logPath, fileText);
         }
         catch (error) {
             rethrowIfTestIsolationError(error);
@@ -516,7 +555,7 @@ function persistRunLog(input) {
                 taskId: input.taskId,
                 runId: buildTaskRunId(input.taskId, input.startedAtIso),
                 ts: input.finishedAtIso,
-                lines: input.dbLines,
+                lines: dbLines,
             });
         }
         finally {
@@ -597,7 +636,7 @@ export function recordTaskAttemptFailure(input) {
     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 line = `[akm task] status=failed reason=${input.reason} code=${errorCode}`;
     const result = {
         id: taskId,
         status: "failed",
@@ -650,19 +689,13 @@ function appendHistory(result, historyReserved = false) {
 }
 export function readTaskHistory(options = {}) {
     return withStateDb((db) => {
-        let rows;
+        if (options.limit === 0)
+            return [];
         if (options.id) {
             const row = getTaskHistory(db, options.id);
-            rows = row ? [taskHistoryRowToResult(row)] : [];
-        }
-        else {
-            rows = queryTaskHistory(db, {}).map(taskHistoryRowToResult);
-        }
-        rows.sort((a, b) => (a.startedAt < b.startedAt ? 1 : -1));
-        if (options.limit !== undefined && options.limit >= 0) {
-            return rows.slice(0, options.limit);
+            return row ? [taskHistoryRowToResult(row)] : [];
         }
-        return rows;
+        return queryTaskHistory(db, options.limit !== undefined && options.limit > 0 ? { limit: options.limit } : {}).map(taskHistoryRowToResult);
     });
 }
 /**
@@ -676,19 +709,23 @@ function taskHistoryRowToResult(row) {
         : row.target_kind === "command"
             ? { kind: "command" }
             : row.target_kind === "prompt"
-                ? meta.metadataVersion === 2
-                    ? { kind: "prompt", engine: meta.engine ?? null }
-                    : { kind: "prompt", engine: null, ...(meta.legacyProfile ? { legacyProfile: meta.legacyProfile } : {}) }
+                ? meta.metadataVersion === 1
+                    ? {
+                        kind: "prompt",
+                        engine: null,
+                        ...(meta.legacyProfile !== undefined ? { legacyProfile: meta.legacyProfile } : {}),
+                    }
+                    : { kind: "prompt", engine: meta.engine ?? null }
                 : { kind: "unknown" };
     return {
         id: row.task_id,
         status: row.status,
         startedAt: row.started_at,
         finishedAt: row.completed_at ?? row.failed_at ?? row.started_at,
-        durationMs: meta.durationMs ?? 0,
+        durationMs: meta.durationMs,
         log: row.log_path ?? "",
         target,
-        ...(meta.detail !== undefined && meta.detail !== null ? { detail: meta.detail } : {}),
+        ...(meta.detail ? { detail: meta.detail } : {}),
     };
 }
 /**