akm-cli 0.9.1 → 0.9.2-alpha.2

package/dist/tasks/runner.js

@@ -5,37 +5,24 @@
  * `akm task run <id>` — what cron / launchd / schtasks invoke at the
  * scheduled moment.
  *
- * Responsibilities:
- *
- *   1. Resolve the task file via `resolveAssetPath(stashDir, "task", id)`.
- *   2. Parse the task document. (Validation runs at `tasks add` /
- *      `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. 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 → `runWorkflowSteps({ target: ref, params, signal, … })`
- *                     under a whole-run timeout (issue 11): an unattended run
- *                     gets the same abort path `akm workflow run --timeout`
- *                     gives an interactive one.
- *        • 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`
- *      (per the #579 logs audit).
- *   6. Write a history row to state.db task_history table.
+ * The durable boundary is intentional: id/bundle resolution, source read,
+ * strict v3 parsing, target resolution, command authorization/lowering,
+ * workflow projectability, and frozen script-byte capture all finish before
+ * an attempt is reserved or a log is created. Once prepared, the runner skips
+ * disabled scheduler firings or dispatches the immutable command, workflow,
+ * shell, or script projection and records that actual attempt.
  *
  * Returns a structured result so the CLI handler can shape it for `output()`
  * 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 { dispatchPreparedCommandInvocation } from "../commands/command/command-execution.js";
 import { armAbortDeadline } from "../core/abort-deadline.js";
 import { shouldSkipUnactivatedTask } from "../core/activation-policy.js";
+import { detectAdapterId } from "../core/adapter/detect-adapter.js";
 import { assertNever } from "../core/assert.js";
-import { placementSpecFor } from "../core/asset/asset-placement.js";
-import { parseRefInput } from "../core/asset/resolve-ref.js";
+import { makeBundleRef } from "../core/asset/asset-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";
@@ -43,84 +30,79 @@ import { getTaskLogDir } from "../core/paths.js";
 import { redactCredentialPatterns, redactSensitiveText } 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 { resolveWriteTarget } from "../core/write-source.js";
+import { assertFrozenDirectoryIdentity } from "../execution/directory-identity.js";
+import { resolveAdapterConceptOwner } from "../indexer/lookup/adapter-concept-owner.js";
 import { resolveAssetPath } from "../sources/resolve.js";
 import { decodeTaskHistoryMetadata, finalizeTaskHistoryAttempt, getTaskHistory, getTaskHistoryRuns, queryTaskHistory, reserveTaskHistoryAttempt, upsertTaskHistory, } from "../storage/repositories/task-history-repository.js";
 import { runWorkflowSteps } from "../workflows/exec/run-workflow.js";
-import { findBareAkmExecutableIndex } from "./command-executable.js";
+import { cleanupFrozenScript, frozenScriptCommand, materializeFrozenScript } from "./frozen-script.js";
 import { collectTaskLogSensitiveValues } from "./log-redaction.js";
-import { parseTaskDocument } from "./parser.js";
 import { resolveAkmInvocation } from "./resolve-akm-bin.js";
+import { prepareTaskV3Execution, } from "./runtime-v3.js";
 import { scheduledTaskContextEnv } from "./scheduler-invocation.js";
-import { validateTaskId } from "./task-id.js";
+import { parseTaskV3Yaml } from "./source-v3.js";
+import { validateTaskConceptId, validateTaskId } from "./task-id.js";
 export const INVALID_TASK_ATTEMPT_ID = "_invalid-task-id";
+const CONFIG_FREE_TASK_RUNTIME = Object.freeze({
+    configVersion: "0.9.0",
+    semanticSearchMode: "off",
+});
 export async function runTask(id, options) {
-    const runAgentImpl = options.runAgentImpl;
     const runWorkflowStepsImpl = options.runWorkflowStepsImpl ?? runWorkflowSteps;
     const now = options.now ?? (() => new Date());
     const requestedStartedAt = now();
-    try {
+    const stashDir = options.stashDir;
+    const adapterId = options.adapterId ?? detectAdapterId(stashDir);
+    if (adapterId === "akm-task")
+        validateTaskConceptId(id);
+    else
         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,
-        });
-        throw failure;
-    }
+    const taskConceptId = adapterId === "akm" ? `tasks/${id}` : id;
+    const owner = resolveAdapterConceptOwner(stashDir, adapterId, taskConceptId);
+    if (!owner) {
+        throw new NotFoundError(`Task ${JSON.stringify(id)} was not found in the configured ${JSON.stringify(adapterId)} component.`, "ASSET_NOT_FOUND");
+    }
+    const filePath = owner.path;
+    const yaml = fs.readFileSync(filePath, "utf8");
+    const source = parseTaskV3Yaml({ yaml, filePath, workspaceRoot: stashDir });
+    const requiresCommandConfig = source.target.kind === "uses" &&
+        (source.target.uses.kind === "builtin-command" || source.target.uses.kind === "command");
+    const config = requiresCommandConfig ? loadConfig() : CONFIG_FREE_TASK_RUNTIME;
+    const bundleName = options.bundleName ?? config.defaultBundle ?? "stash";
+    const task = await prepareTaskV3Execution(source, {
+        taskId: id,
+        taskRef: makeBundleRef(bundleName, taskConceptId),
+        bundleName,
+        bundleRoot: stashDir,
+        config,
+        // Agent profiles build child env from an allowlist, so freeze the closed
+        // scheduler-restored AKM directory context before command preparation.
+        ...(options.scheduled ? { schedulerContext: scheduledTaskContextEnv() } : {}),
+        resolveAsset: async ({ bundle, type, name }) => {
+            if (bundle === bundleName) {
+                return { file: await resolveAssetPath(stashDir, type, name), bundleRoot: stashDir };
+            }
+            const resolutionConfig = requiresCommandConfig ? config : loadConfig();
+            const resolvedBundle = resolveWriteTarget(resolutionConfig, bundle, { requireWritable: false });
+            return {
+                file: await resolveAssetPath(resolvedBundle.source.path, type, name),
+                bundleRoot: resolvedBundle.source.path,
+            };
+        },
+    });
+    // All validation, parsing, source resolution, command cascade preparation,
+    // and frozen-byte capture above is non-mutating. Only a fully projectable
+    // task may reserve durable history or create a log.
     const attempt = reserveTaskAttempt(id, requestedStartedAt);
     const startedAt = attempt.startedAt;
-    let failureReason = "task_load_failed";
+    const startedIso = startedAt.toISOString();
+    const logPath = resolveTaskLogPath(options.logDir, id, startedIso);
     try {
-        const stashDir = options.stashDir;
-        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 (shouldSkipUnactivatedTask({ enabled: task.enabled, scheduled: 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 task] task "${id}" is disabled — skipping run.`;
-            persistRunLog({
-                taskId: id,
-                startedAtIso: startedIso,
-                finishedAtIso: result.finishedAt,
-                logPath,
-                fileText: `${disabledLine}\n`,
-                dbLines: [{ line: disabledLine }],
-                redactNames: task.redact,
-            });
-            appendHistory(result, attempt.historyReserved);
-            return result;
+            return finishDisabledTask(task, logPath, startedAt, now(), attempt.historyReserved);
         }
-        if (task.target.kind === "workflow") {
+        if (task.kind === "workflow") {
             return await runWorkflowTask({
                 task,
                 logPath,
@@ -132,34 +114,34 @@ export async function runTask(id, options) {
                 ...(options.clearTimeoutFn ? { clearTimeoutFn: options.clearTimeoutFn } : {}),
             });
         }
-        if (task.target.kind === "command") {
-            return await runCommandTask({
+        if (task.kind === "command") {
+            return await runPreparedCommandTask({
                 task,
                 logPath,
                 startedAt,
                 now,
                 historyReserved: attempt.historyReserved,
-                ...(options.spawnFn ? { spawnFn: options.spawnFn } : {}),
-                ...(options.setTimeoutFn ? { setTimeoutFn: options.setTimeoutFn } : {}),
-                ...(options.clearTimeoutFn ? { clearTimeoutFn: options.clearTimeoutFn } : {}),
+                runAgentImpl: options.runAgentImpl,
+                agentOptions: options.agentOptions,
+                chatCompletionImpl: options.chatCompletionImpl,
             });
         }
-        return await runPromptTask({
+        options.beforeNativeDispatch?.(task);
+        return await runNativeTask({
             task,
-            stashDir,
             logPath,
             startedAt,
             now,
-            runAgentImpl,
-            agentOptions: options.agentOptions,
-            chatCompletionImpl: options.chatCompletionImpl ?? chatCompletion,
             historyReserved: attempt.historyReserved,
+            ...(options.spawnFn ? { spawnFn: options.spawnFn } : {}),
+            ...(options.setTimeoutFn ? { setTimeoutFn: options.setTimeoutFn } : {}),
+            ...(options.clearTimeoutFn ? { clearTimeoutFn: options.clearTimeoutFn } : {}),
         });
     }
     catch (failure) {
         recordTaskAttemptFailure({
             taskId: id,
-            reason: failureReason,
+            reason: "task_dispatch_failed",
             failure,
             startedAt,
             finishedAt: now(),
@@ -169,31 +151,121 @@ export async function runTask(id, options) {
         throw failure;
     }
 }
-// ── command target ──────────────────────────────────────────────────────────
-async function runCommandTask(input) {
+function preparedResultTarget(task) {
+    if (task.kind === "workflow")
+        return { kind: "workflow", ref: task.ref };
+    if (task.kind === "command")
+        return { kind: "prompt", engine: task.invocation.request.engine.name ?? null };
+    return { kind: "command" };
+}
+function finishDisabledTask(task, logPath, startedAt, observedFinishedAt, historyReserved) {
+    const finishedAt = finishAttempt(startedAt, observedFinishedAt);
+    const line = `[akm task] task "${task.taskId}" is disabled — skipping run.`;
+    const result = {
+        id: task.taskId,
+        status: "disabled",
+        startedAt: startedAt.toISOString(),
+        finishedAt: finishedAt.toISOString(),
+        durationMs: finishedAt.getTime() - startedAt.getTime(),
+        log: logPath,
+        target: preparedResultTarget(task),
+    };
+    persistRunLog({
+        taskId: task.taskId,
+        startedAtIso: result.startedAt,
+        finishedAtIso: result.finishedAt,
+        logPath,
+        fileText: `${line}\n`,
+        dbLines: [{ line }],
+        redactNames: task.redact,
+        environment: task.environment,
+    });
+    appendHistory(result, historyReserved);
+    return result;
+}
+// ── shell and frozen-script targets ─────────────────────────────────────────
+function shellCommand(task) {
+    const command = resolveLeadingBareAkmCommand(task.command, task.shell);
+    switch (task.shell) {
+        case "sh":
+        case "bash":
+        case "zsh":
+            return [task.shell, "-c", command];
+        case "pwsh":
+        case "powershell":
+            return [task.shell, "-NoProfile", "-NonInteractive", "-Command", command];
+        case "cmd":
+            return ["cmd", "/d", "/s", "/c", command];
+        default:
+            return assertNever(task.shell, "shellCommand");
+    }
+}
+/**
+ * Bind an unambiguous leading bare `akm` (including the task-v2 migrator's
+ * quoted form) to this installation. Explicit paths and arbitrary shell
+ * fragments remain author-controlled.
+ */
+function resolveLeadingBareAkmCommand(command, shell) {
+    const leadingBareAkm = /^(\s*)(?:akm(?:\.exe)?|'akm(?:\.exe)?'|"akm(?:\.exe)?")(?=$|[\s;|&])/i;
+    if (!leadingBareAkm.test(command))
+        return command;
+    const invocation = resolveAkmInvocation()
+        .argv.map((part) => quoteShellArgument(part, shell))
+        .join(" ");
+    return command.replace(leadingBareAkm, (_match, leadingWhitespace) => `${leadingWhitespace}${invocation}`);
+}
+function quoteShellArgument(value, shell) {
+    switch (shell) {
+        case "sh":
+        case "bash":
+        case "zsh":
+            return `'${value.replaceAll("'", `'"'"'`)}'`;
+        case "pwsh":
+        case "powershell":
+            return `'${value.replaceAll("'", "''")}'`;
+        case "cmd":
+            return `"${value.replaceAll('"', '""')}"`;
+        default:
+            return assertNever(shell, "quoteShellArgument");
+    }
+}
+async function runNativeTask(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);
+    let materialized;
+    let cmd = task.kind === "shell" ? shellCommand(task) : [];
     // Unset → the unattended default; `null` → the explicit no-timeout opt-out.
     const timeoutMs = task.timeoutMs !== undefined ? task.timeoutMs : DEFAULT_SCHEDULED_TASK_TIMEOUT_MS;
-    const header = `[akm task] task=${task.id} kind=command cmd=${cmd.join(" ")}`;
+    const header = task.kind === "shell"
+        ? `[akm task] task=${task.taskId} kind=run shell=${task.shell}`
+        : `[akm task] task=${task.taskId} kind=script ref=${task.sourceRef} sha256=${task.sha256}`;
     const logLines = [header];
     const dbLines = [{ line: header }];
     let exitCode = null;
     try {
+        // The projector froze both canonical paths and filesystem identities before
+        // history mutation. Re-resolve the authored root/cwd immediately before
+        // spawn so a symlink, ancestor, bundle-root, or directory/file swap cannot
+        // redirect execution outside that physical workspace.
+        assertFrozenDirectoryIdentity(task.cwdIdentity);
+        if (task.kind === "script") {
+            materialized = materializeFrozenScript(task);
+            cmd = frozenScriptCommand(task, materialized.file);
+        }
         // Managed spawn (src/core/subprocess.ts): process-GROUP kill so a timeout
         // reaps the whole command tree (no orphans), and a SIGTERM→SIGKILL ladder
         // so a child that ignores SIGTERM can't wedge the run forever.
-        const result = await runManagedSubprocess(spawnCmd, {
+        const result = await runManagedSubprocess(cmd, {
             capture: true,
-            cwd: process.env.HOME ?? os.tmpdir(),
+            cwd: task.cwd,
             // 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
             // AKM_EVENT_SOURCE=improve on its child spawns) still wins in children.
-            env: { ...process.env, AKM_EVENT_SOURCE: process.env.AKM_EVENT_SOURCE ?? "task" },
+            env: {
+                ...process.env,
+                ...task.environment,
+                AKM_EVENT_SOURCE: process.env.AKM_EVENT_SOURCE ?? "task",
+            },
             timeoutMs,
             ...(input.spawnFn ? { spawnFn: input.spawnFn } : {}),
             ...(input.setTimeoutFn ? { setTimeoutFn: input.setTimeoutFn } : {}),
@@ -227,19 +299,24 @@ async function runCommandTask(input) {
         dbLines.push({ level: "error", line: `spawn_error=${msg}` });
         exitCode = 1;
     }
+    finally {
+        if (materialized)
+            cleanupFrozenScript(materialized);
+    }
     const finishedAt = finishAttempt(startedAt, now());
     persistRunLog({
-        taskId: task.id,
+        taskId: task.taskId,
         startedAtIso: startedAt.toISOString(),
         finishedAtIso: finishedAt.toISOString(),
         logPath,
         fileText: `${logLines.join("\n")}\n`,
         dbLines,
         redactNames: task.redact,
+        environment: task.environment,
     });
     const status = exitCode === 0 ? "completed" : "failed";
     const result = {
-        id: task.id,
+        id: task.taskId,
         status,
         startedAt: startedAt.toISOString(),
         finishedAt: finishedAt.toISOString(),
@@ -251,13 +328,6 @@ async function runCommandTask(input) {
     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 ─────────────────────────────────────────────────────────
 /**
  * Whole-run timeout applied to a workflow-bound task that does not declare its
@@ -296,15 +366,8 @@ export const DEFAULT_WORKFLOW_TASK_TIMEOUT_MS = 6 * 60 * 60 * 1000;
 export const DEFAULT_SCHEDULED_TASK_TIMEOUT_MS = DEFAULT_WORKFLOW_TASK_TIMEOUT_MS;
 async function runWorkflowTask(input) {
     const { task, logPath, startedAt, now, runWorkflowStepsImpl, historyReserved } = input;
-    if (task.target.kind !== "workflow")
-        throw new Error("invariant: workflow target");
-    const workflowTarget = task.target;
-    const ref = parseRefInput(workflowTarget.ref);
-    if (ref.type !== "workflow") {
-        throw new NotFoundError(`Task "${task.id}" workflow target must be a workflow ref (got "${workflowTarget.ref}").`, "WORKFLOW_NOT_FOUND");
-    }
     // Unset → the unattended default; `null` → the explicit no-timeout opt-out.
-    const timeoutMs = workflowTarget.timeoutMs === undefined ? DEFAULT_WORKFLOW_TASK_TIMEOUT_MS : workflowTarget.timeoutMs;
+    const timeoutMs = task.timeoutMs === undefined ? DEFAULT_WORKFLOW_TASK_TIMEOUT_MS : task.timeoutMs;
     // The shared deadline `akm workflow run --timeout` also arms
     // ({@link armAbortDeadline}): one AbortController for the run's lifetime,
     // aborted by a timer. The engine reads `options.signal` at every step
@@ -314,7 +377,7 @@ async function runWorkflowTask(input) {
     const controller = new AbortController();
     const deadline = armAbortDeadline(controller, {
         timeoutMs,
-        reason: `Workflow task "${task.id}" timed out after ${timeoutMs}ms.`,
+        reason: `Workflow task "${task.taskId}" timed out after ${timeoutMs}ms.`,
         ...(input.setTimeoutFn ? { setTimeoutFn: input.setTimeoutFn } : {}),
         ...(input.clearTimeoutFn ? { clearTimeoutFn: input.clearTimeoutFn } : {}),
     });
@@ -333,11 +396,11 @@ async function runWorkflowTask(input) {
     process.env.AKM_EVENT_SOURCE = priorEventSource ?? "task";
     try {
         const execution = await runWorkflowStepsImpl({
-            target: workflowTarget.ref,
-            params: workflowTarget.params,
+            target: task.ref,
+            params: task.params,
             signal: controller.signal,
-            ...(workflowTarget.maxSteps !== undefined ? { maxSteps: workflowTarget.maxSteps } : {}),
-            ...(workflowTarget.maxRetries !== undefined ? { maxRetries: workflowTarget.maxRetries } : {}),
+            ...(task.maxSteps !== undefined ? { maxSteps: task.maxSteps } : {}),
+            ...(task.maxRetries !== undefined ? { maxRetries: task.maxRetries } : {}),
         });
         detail = execution.run;
         runWarnings = execution.warnings ?? [];
@@ -387,25 +450,26 @@ async function runWorkflowTask(input) {
         ...(timedOutAfterMs !== undefined ? { timedOutAfterMs } : {}),
     });
     persistRunLog({
-        taskId: task.id,
+        taskId: task.taskId,
         startedAtIso: startedAt.toISOString(),
         finishedAtIso: finishedAt.toISOString(),
         logPath,
         fileText: log.fileText,
         dbLines: log.dbLines,
         redactNames: task.redact,
+        environment: task.environment,
     });
     const result = {
-        id: task.id,
+        id: task.taskId,
         status,
         startedAt: startedAt.toISOString(),
         finishedAt: finishedAt.toISOString(),
         durationMs: finishedAt.getTime() - startedAt.getTime(),
         log: logPath,
-        target: { kind: "workflow", ref: task.target.ref },
+        target: { kind: "workflow", ref: task.ref },
         detail: {
             runId: detail?.id,
-            ...(failure ? { error: failure.message } : {}),
+            ...(failure ? { error: scrubTaskOutput(task, failure.message) } : {}),
         },
     };
     appendHistory(result, historyReserved);
@@ -445,7 +509,7 @@ function mapWorkflowStatus(status) {
 }
 function renderWorkflowLog(input) {
     const dbLines = [
-        { line: `[akm task] task=${input.task.id} kind=workflow ref=${input.task.target.ref}` },
+        { line: `[akm task] task=${input.task.taskId} kind=workflow ref=${input.task.ref}` },
     ];
     for (const warning of input.warnings ?? [])
         dbLines.push({ level: "warn", line: warning });
@@ -461,98 +525,30 @@ function renderWorkflowLog(input) {
     }
     return { fileText: `${dbLines.map((entry) => entry.line).join("\n")}\n`, dbLines };
 }
-// ── prompt target ───────────────────────────────────────────────────────────
-async function runPromptTask(input) {
-    const { task, stashDir, logPath, startedAt, now, agentOptions } = input;
-    if (task.target.kind !== "prompt")
-        throw new Error("invariant: prompt target");
-    const promptTarget = task.target;
-    // 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}" ${NO_ENGINE_MESSAGE_SUFFIX} ${NO_ENGINE_REMEDY}`, "ASSET_NOT_FOUND");
-    let runner = resolveEngine(engineName, config);
-    if (runner.kind === "llm") {
-        const resolved = resolveLlmEngineUse(config, [
-            {
-                engine: engineName,
-                ...(promptTarget.model !== undefined ? { model: promptTarget.model } : {}),
-                ...(promptTarget.timeoutMs !== undefined ? { timeoutMs: promptTarget.timeoutMs } : {}),
-                ...(promptTarget.llm !== undefined ? { llm: promptTarget.llm } : {}),
-            },
-        ]);
-        runner = {
-            kind: "llm",
-            engine: resolved.engine,
-            connection: resolved.connection,
-            ...(resolved.credential ? { credential: resolved.credential } : {}),
-            timeoutMs: resolved.timeoutMs,
-        };
-    }
-    else {
-        if (promptTarget.llm !== undefined) {
-            throw new NotFoundError(`Task "${task.id}" uses llm overrides with non-LLM engine "${engineName}".`, "ASSET_NOT_FOUND");
-        }
-        const requestedModel = promptTarget.model;
-        const platform = runner.profile.platform;
-        if (!platform)
-            throw new Error(`Engine "${engineName}" resolved without a platform.`);
-        const model = requestedModel
-            ? resolveModel(requestedModel, platform, runner.profile.modelAliases, runner.profile.globalModelAliases)
-            : runner.profile.model;
-        runner = {
-            ...runner,
-            profile: { ...runner.profile, ...(model ? { model, modelIsExact: true } : {}) },
-            // Unset → the unattended default (DEFAULT_AGENT_TIMEOUT_MS is null, which
-            // let a prompting or wedged agent CLI hang the schedule); `null` → the
-            // explicit no-timeout opt-out.
-            timeoutMs: promptTarget.timeoutMs !== undefined ? promptTarget.timeoutMs : DEFAULT_SCHEDULED_TASK_TIMEOUT_MS,
-        };
-    }
-    const promptText = await resolvePromptText(task, stashDir);
-    const result = await executeRunner(runner, promptText, {
-        stdio: "captured",
-        cwd: stashDir,
-        ...agentOptions,
-        // Stamp task-runner provenance for any akm invocation the agent makes
-        // (DRIFT-6: agent-task traffic must not be recorded as user demand).
-        // Caller-supplied env still wins on conflicts.
-        //
-        // The agent child env is built from an allowlist, not inherited, so the
-        // scheduler's AKM_* directory context was dropped here — an agent's `akm`
-        // sub-commands then targeted the DEFAULT stash and DB rather than the
-        // ones the scheduled run was configured for. The command arm keeps this
-        // context because it inherits process.env; forward it explicitly.
-        env: { AKM_EVENT_SOURCE: "task", ...scheduledTaskContextEnv(), ...agentOptions?.env },
-    }, {
+// ── common command target ───────────────────────────────────────────────────
+async function runPreparedCommandTask(input) {
+    const { task, logPath, startedAt, now, agentOptions } = input;
+    const result = await dispatchPreparedCommandInvocation(task.invocation, {
         ...(input.runAgentImpl ? { runAgent: input.runAgentImpl } : {}),
-        llm: async (spec, prompt, options) => {
-            const started = Date.now();
-            const stdout = await input.chatCompletionImpl(spec.connection, [{ role: "user", content: prompt }], {
-                ...(options.timeoutMs !== undefined ? { timeoutMs: options.timeoutMs } : {}),
-            });
-            return { ok: true, exitCode: 0, stdout, stderr: "", durationMs: Date.now() - started };
-        },
+        ...(input.chatCompletionImpl ? { chat: input.chatCompletionImpl } : {}),
+        ...(agentOptions ? { runOptions: agentOptions } : {}),
     });
+    const engineName = result.engine;
     const finishedAt = finishAttempt(startedAt, now());
-    const log = renderPromptLog({ task, engineName, result, engineAnnouncement });
+    const log = renderPromptLog({ task, engineName, result, notices: result.notices, warnings: result.warnings });
     persistRunLog({
-        taskId: task.id,
+        taskId: task.taskId,
         startedAtIso: startedAt.toISOString(),
         finishedAtIso: finishedAt.toISOString(),
         logPath,
         fileText: log.fileText,
         dbLines: log.dbLines,
         redactNames: task.redact,
+        environment: task.environment,
     });
     const status = result.ok ? "completed" : "failed";
     const out = {
-        id: task.id,
+        id: task.taskId,
         status,
         startedAt: startedAt.toISOString(),
         finishedAt: finishedAt.toISOString(),
@@ -561,46 +557,38 @@ async function runPromptTask(input) {
         target: { kind: "prompt", engine: engineName },
         detail: result.ok
             ? { exitCode: result.exitCode }
-            : { reason: result.reason, error: result.error, exitCode: result.exitCode },
+            : {
+                reason: result.reason === undefined ? undefined : scrubTaskOutput(task, result.reason),
+                error: result.error === undefined ? undefined : scrubTaskOutput(task, result.error),
+                exitCode: result.exitCode,
+            },
+        ...(result.notices && result.notices.length > 0
+            ? {
+                notices: result.notices.map((notice) => ({
+                    ...notice,
+                    message: scrubTaskOutput(task, notice.message),
+                })),
+            }
+            : {}),
     };
     appendHistory(out, input.historyReserved);
     return out;
 }
-async function resolvePromptText(task, stashDir) {
-    if (task.target.kind !== "prompt")
-        throw new Error("invariant: prompt target");
-    const src = task.target.source;
-    if (src.kind === "inline")
-        return src.text;
-    if (src.kind === "file") {
-        const taskDir = path.dirname(task.source.path);
-        const filePath = path.isAbsolute(src.path) ? src.path : path.resolve(taskDir, src.path);
-        if (!fs.existsSync(filePath) || !fs.statSync(filePath).isFile()) {
-            throw new NotFoundError(`Prompt file not found: ${filePath}`, "FILE_NOT_FOUND");
-        }
-        return fs.readFileSync(filePath, "utf8");
-    }
-    // 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 task] task=${input.task.id} kind=prompt engine=${input.engineName}`;
+    const header = `[akm task] task=${input.task.taskId} 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 });
+    for (const warning of input.warnings ?? []) {
+        lines.push(warning);
+        dbLines.push({ level: "warn", line: warning });
+    }
+    for (const notice of input.notices ?? []) {
+        const line = `lowering_notice=${notice.code} adapter=${notice.adapter} field=${notice.field ?? ""} message=${notice.message}`;
+        lines.push(line);
+        dbLines.push({ level: notice.severity === "warning" ? "warn" : "info", line });
     }
     if (!input.result.ok) {
         const failure = `reason=${input.result.reason ?? ""} error=${input.result.error ?? ""}`;
@@ -698,10 +686,11 @@ function streamLines(text, stream, level) {
  * to "log it anyway with no redaction at all" — `redactCredentialPatterns`
  * still runs unconditionally in the caller.
  */
-function taskLogSensitiveValues(redactNames) {
+function taskLogSensitiveValues(redactNames, environment) {
+    const env = { ...process.env, ...environment };
     try {
         return collectTaskLogSensitiveValues({
-            env: process.env,
+            env,
             config: loadConfig(),
             declaredNames: redactNames,
         });
@@ -710,7 +699,7 @@ function taskLogSensitiveValues(redactNames) {
         rethrowIfTestIsolationError(error);
         // No config — the name heuristic and the task's own `redact:` list still apply.
         try {
-            return collectTaskLogSensitiveValues({ env: process.env, declaredNames: redactNames });
+            return collectTaskLogSensitiveValues({ env, declaredNames: redactNames });
         }
         catch (fallbackError) {
             rethrowIfTestIsolationError(fallbackError);
@@ -718,6 +707,11 @@ function taskLogSensitiveValues(redactNames) {
         }
     }
 }
+function scrubTaskOutput(task, text) {
+    const patterned = redactCredentialPatterns(text);
+    const sensitive = taskLogSensitiveValues(task.redact, task.environment);
+    return sensitive.length > 0 ? redactSensitiveText(patterned, sensitive) : patterned;
+}
 function persistRunLog(input) {
     // Two arms, and both are needed. `redactCredentialPatterns` catches
     // credential SHAPES nobody listed; the exact-value pass catches configured
@@ -727,7 +721,7 @@ function persistRunLog(input) {
     // exact pass here — the one sink all three target kinds funnel through —
     // covers every arm once rather than per-arm; prompt/workflow runs already
     // scrub upstream, and redaction is idempotent, so the overlap is free.
-    const sensitive = taskLogSensitiveValues(input.redactNames);
+    const sensitive = taskLogSensitiveValues(input.redactNames, input.environment);
     const scrub = (text) => sensitive.length > 0
         ? redactSensitiveText(redactCredentialPatterns(text), sensitive)
         : redactCredentialPatterns(text);
@@ -914,13 +908,7 @@ function taskHistoryRowToResult(row) {
         : row.target_kind === "command"
             ? { kind: "command" }
             : row.target_kind === "prompt"
-                ? meta.metadataVersion === 1
-                    ? {
-                        kind: "prompt",
-                        engine: null,
-                        ...(meta.legacyProfile !== undefined ? { legacyProfile: meta.legacyProfile } : {}),
-                    }
-                    : { kind: "prompt", engine: meta.engine ?? null }
+                ? { kind: "prompt", engine: meta.engine ?? null }
                 : { kind: "unknown" };
     return {
         id: row.task_id,