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

package/dist/tasks/parser.js

@@ -29,13 +29,14 @@
  * tags: [scheduled, backup]
  * ```
  *
- * Validation lives in {@link validateTaskDocument}. The parser only enforces
- * shape; cron syntax, target reachability, and profile availability are
+ * Validation lives in {@link validateTaskDocument}. The parser enforces the
+ * strict source shape; cron syntax and target reachability are
  * checked separately so callers can choose how strictly to surface errors.
  */
 import path from "node:path";
 import { parse as parseYaml } from "yaml";
 import { UsageError } from "../core/errors.js";
+import { formatExtraParamsIssue, validateExtraParams } from "../core/extra-params.js";
 import { TASK_SCHEMA_VERSION } from "./schema.js";
 export function parseTaskDocument(input) {
     const { yaml, filePath, id } = input;
@@ -52,15 +53,17 @@ export function parseTaskDocument(input) {
             throw err;
         throw new UsageError(`Task "${id}" has invalid YAML: ${err instanceof Error ? err.message : String(err)}. File: ${filePath}`, "INVALID_FLAG_VALUE");
     }
-    const schedule = readString(data.schedule, "schedule", filePath);
+    requireVersion(data, id, filePath);
+    rejectUnknownKeys(data, id, filePath);
+    const schedule = requireString(data.schedule, "schedule", filePath);
     if (!schedule) {
         throw new UsageError(`Task "${id}" is missing a schedule (YAML key "schedule"). File: ${filePath}`, "MISSING_REQUIRED_ARGUMENT");
     }
-    const enabled = data.enabled === undefined ? true : data.enabled === true;
-    const name = readString(data.name, "name", filePath);
-    const description = readString(data.description, "description", filePath);
-    const when_to_use = readString(data.when_to_use, "when_to_use", filePath);
-    const tags = readStringArray(data.tags);
+    const enabled = readEnabled(data.enabled, filePath);
+    const name = optionalString(data.name, "name", filePath);
+    const description = optionalString(data.description, "description", filePath);
+    const when_to_use = optionalString(data.when_to_use, "when_to_use", filePath);
+    const tags = readTags(data.tags, filePath);
     const hasWorkflow = "workflow" in data && data.workflow !== "" && data.workflow != null;
     const hasPrompt = "prompt" in data && data.prompt !== "" && data.prompt != null;
     const hasCommand = "command" in data && data.command !== "" && data.command != null;
@@ -73,7 +76,8 @@ export function parseTaskDocument(input) {
     }
     let target;
     if (hasWorkflow) {
-        const ref = readString(data.workflow, "workflow", filePath);
+        rejectTargetFields(data, ["params"], id, filePath);
+        const ref = requireString(data.workflow, "workflow", filePath);
         if (!ref) {
             throw new UsageError(`Task "${id}" has empty \`workflow\`. File: ${filePath}`, "INVALID_FLAG_VALUE");
         }
@@ -84,48 +88,81 @@ export function parseTaskDocument(input) {
         };
     }
     else if (hasCommand) {
+        rejectTargetFields(data, ["timeoutMs"], id, filePath);
         const cmd = readCommand(data.command, filePath, id);
         target = { kind: "command", cmd };
     }
     else {
-        const promptRaw = readString(data.prompt, "prompt", filePath);
+        rejectTargetFields(data, ["engine", "model", "timeoutMs", "llm"], id, filePath);
+        const promptRaw = requireString(data.prompt, "prompt", filePath);
         if (!promptRaw) {
             throw new UsageError(`Task "${id}" has empty \`prompt\`. File: ${filePath}`, "INVALID_FLAG_VALUE");
         }
-        const profile = readString(data.profile, "profile", filePath);
+        const engine = optionalString(data.engine, "engine", filePath);
+        const model = optionalString(data.model, "model", filePath);
+        const timeoutMs = readTimeout(data.timeoutMs, filePath);
+        const llm = readLlmOverrides(data.llm, filePath);
         target = {
             kind: "prompt",
             source: resolvePromptSource(promptRaw, filePath, id),
-            profile: profile && profile.length > 0 ? profile : undefined,
+            ...(engine ? { engine } : {}),
+            ...(model ? { model } : {}),
+            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
+            ...(llm ? { llm } : {}),
         };
     }
-    // null / 0 / negative → disabled (no timeout). Positive number → override.
-    // Omitted → undefined (inherits config.agent.timeoutMs).
-    let timeoutMs;
-    if ("timeoutMs" in data) {
-        const raw = data.timeoutMs;
-        if (raw === null || raw === "null" || raw === 0 || (typeof raw === "number" && raw < 0)) {
-            timeoutMs = null;
-        }
-        else if (typeof raw === "number" && raw > 0) {
-            timeoutMs = raw;
-        }
-        // non-numeric / unrecognised → leave as undefined (inherit)
-    }
+    const timeoutMs = hasCommand ? readTimeout(data.timeoutMs, filePath) : undefined;
     return {
+        version: TASK_SCHEMA_VERSION,
         schemaVersion: TASK_SCHEMA_VERSION,
         id,
         schedule,
         enabled,
         target,
-        name: name && name.length > 0 ? name : undefined,
-        description: description && description.length > 0 ? description : undefined,
-        when_to_use: when_to_use && when_to_use.length > 0 ? when_to_use : undefined,
-        tags: tags && tags.length > 0 ? tags : undefined,
+        ...(name ? { name } : {}),
+        ...(description ? { description } : {}),
+        ...(when_to_use ? { when_to_use } : {}),
+        ...(tags ? { tags } : {}),
         source: { path: filePath },
         timeoutMs,
     };
 }
+const TASK_KEYS = new Set([
+    "version",
+    "name",
+    "description",
+    "when_to_use",
+    "tags",
+    "schedule",
+    "enabled",
+    "workflow",
+    "prompt",
+    "command",
+    "params",
+    "engine",
+    "model",
+    "timeoutMs",
+    "llm",
+]);
+const SHARED_KEYS = new Set(["version", "name", "description", "when_to_use", "tags", "schedule", "enabled"]);
+function requireVersion(data, id, filePath) {
+    if (data.version === TASK_SCHEMA_VERSION)
+        return;
+    const actual = data.version === undefined ? "missing" : JSON.stringify(data.version);
+    throw new UsageError(`TASK_SCHEMA_VERSION_UNSUPPORTED: Task "${id}" uses task schema version ${actual}; version: 2 is required. File: ${filePath}`, "TASK_SCHEMA_VERSION_UNSUPPORTED", "Rewrite the task using version: 2 and replace profile with engine.");
+}
+function rejectUnknownKeys(data, id, filePath) {
+    const unknown = Object.keys(data).filter((key) => !TASK_KEYS.has(key));
+    if (unknown.length > 0) {
+        throw new UsageError(`Task "${id}" has unknown key(s): ${unknown.join(", ")}. File: ${filePath}`, "INVALID_FLAG_VALUE");
+    }
+}
+function rejectTargetFields(data, allowed, id, filePath) {
+    const forbidden = Object.keys(data).filter((key) => !SHARED_KEYS.has(key) && !allowed.includes(key) && !["workflow", "prompt", "command"].includes(key));
+    if (forbidden.length > 0) {
+        throw new UsageError(`Task "${id}" has field(s) not valid for this target: ${forbidden.join(", ")}. File: ${filePath}`, "INVALID_FLAG_VALUE");
+    }
+}
 /**
  * Resolve a `prompt:` value into a {@link TaskPromptSource} variant.
  *
@@ -150,32 +187,44 @@ function resolvePromptSource(raw, filePath, id) {
     }
     return { kind: "inline", text: trimmed };
 }
-function readString(value, key, filePath) {
+function optionalString(value, key, filePath) {
     if (value === undefined || value === null)
         return undefined;
     if (typeof value === "string")
-        return value.trim();
-    if (typeof value === "number" || typeof value === "boolean")
-        return String(value);
+        return value;
     throw new UsageError(`Key "${key}" must be a string. File: ${filePath}`, "INVALID_FLAG_VALUE");
 }
-function readStringArray(value) {
+function requireString(value, key, filePath) {
+    const result = optionalString(value, key, filePath);
+    if (result === undefined || result.length === 0) {
+        throw new UsageError(`Key "${key}" must be a non-empty string. File: ${filePath}`, "INVALID_FLAG_VALUE");
+    }
+    return result;
+}
+function readEnabled(value, filePath) {
+    if (value === undefined)
+        return true;
+    if (typeof value !== "boolean")
+        throw new UsageError(`Key "enabled" must be a boolean. File: ${filePath}`, "INVALID_FLAG_VALUE");
+    return value;
+}
+function readTags(value, filePath) {
     if (value === undefined || value === null)
         return undefined;
-    if (typeof value === "string") {
-        return value
-            .split(/[\s,]+/)
-            .map((s) => s.trim())
-            .filter(Boolean);
-    }
     if (Array.isArray(value)) {
-        return value.filter((v) => typeof v === "string" && v.trim().length > 0);
+        if (!value.every((entry) => typeof entry === "string" && entry.length > 0)) {
+            throw new UsageError(`Key "tags" must be an array of non-empty strings. File: ${filePath}`, "INVALID_FLAG_VALUE");
+        }
+        return value;
     }
-    return undefined;
+    throw new UsageError(`Key "tags" must be an array of strings. File: ${filePath}`, "INVALID_FLAG_VALUE");
 }
 function readCommand(value, filePath, id) {
     if (Array.isArray(value)) {
-        const parts = value.filter((v) => typeof v === "string" && v.trim().length > 0);
+        if (!value.every((entry) => typeof entry === "string" && entry.length > 0)) {
+            throw new UsageError(`Task "${id}" command array must contain non-empty strings. File: ${filePath}`, "INVALID_FLAG_VALUE");
+        }
+        const parts = value;
         if (parts.length === 0) {
             throw new UsageError(`Task "${id}" has empty \`command\` array. File: ${filePath}`, "INVALID_FLAG_VALUE");
         }
@@ -196,16 +245,53 @@ function readParams(value, filePath) {
     if (typeof value === "object" && !Array.isArray(value)) {
         return value;
     }
-    if (typeof value === "string" && value.trim()) {
-        try {
-            const parsed = JSON.parse(value);
-            if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) {
-                return parsed;
-            }
+    throw new UsageError(`Key "params" must be a mapping. File: ${filePath}`, "INVALID_FLAG_VALUE");
+}
+function readTimeout(value, filePath) {
+    if (value === undefined)
+        return undefined;
+    if (value === null)
+        return null;
+    if (typeof value === "number" && Number.isInteger(value) && value > 0)
+        return value;
+    throw new UsageError(`Key "timeoutMs" must be a positive integer or null. File: ${filePath}`, "INVALID_FLAG_VALUE");
+}
+function readLlmOverrides(value, filePath) {
+    if (value === undefined)
+        return undefined;
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+        throw new UsageError(`Key "llm" must be a mapping. File: ${filePath}`, "INVALID_FLAG_VALUE");
+    }
+    const data = value;
+    const allowed = new Set([
+        "temperature",
+        "maxTokens",
+        "supportsJsonSchema",
+        "extraParams",
+        "contextLength",
+        "enableThinking",
+    ]);
+    const unknown = Object.keys(data).filter((key) => !allowed.has(key));
+    if (unknown.length)
+        throw new UsageError(`Key "llm" has unknown field(s): ${unknown.join(", ")}. File: ${filePath}`, "INVALID_FLAG_VALUE");
+    if (data.temperature !== undefined && (typeof data.temperature !== "number" || !Number.isFinite(data.temperature))) {
+        throw new UsageError(`Key "llm.temperature" must be a finite number. File: ${filePath}`, "INVALID_FLAG_VALUE");
+    }
+    for (const key of ["maxTokens", "contextLength"]) {
+        if (data[key] !== undefined && (!Number.isInteger(data[key]) || data[key] <= 0)) {
+            throw new UsageError(`Key "llm.${key}" must be a positive integer. File: ${filePath}`, "INVALID_FLAG_VALUE");
         }
-        catch {
-            // fall through
+    }
+    for (const key of ["supportsJsonSchema", "enableThinking"]) {
+        if (data[key] !== undefined && typeof data[key] !== "boolean") {
+            throw new UsageError(`Key "llm.${key}" must be a boolean. File: ${filePath}`, "INVALID_FLAG_VALUE");
+        }
+    }
+    if (data.extraParams !== undefined) {
+        const issue = validateExtraParams(data.extraParams)[0];
+        if (issue) {
+            throw new UsageError(`${formatExtraParamsIssue('Key "llm.extraParams"', issue)}. File: ${filePath}`, "INVALID_FLAG_VALUE");
         }
     }
-    throw new UsageError(`Key "params" must be a mapping or a JSON object. File: ${filePath}`, "INVALID_FLAG_VALUE");
+    return data;
 }

package/dist/tasks/runner.js

@@ -15,7 +15,7 @@
  *   3. Refuse to run when `enabled === false` (defense-in-depth).
  *   4. Dispatch by target kind:
  *        • workflow → `startWorkflowRun(ref, params)`
- *        • prompt   → `runAgent(profile, prompt, { stdio: "captured" })`
+ *        • 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`
  *      (see docs/technical/logs-audit.md).
@@ -35,17 +35,18 @@ import { buildTaskRunId, insertTaskLogLines, openLogsDatabase, } from "../core/l
 import { getTaskLogDir } from "../core/paths.js";
 import { withStateDb } from "../core/state-db.js";
 import { error } from "../core/warn.js";
-import { requireAgentProfile, runAgent } from "../integrations/agent/index.js";
-import { resolveProcessAgentProfile } from "../integrations/agent/config.js";
-import { resolveRunner } from "../integrations/agent/runner.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 { getTaskHistory, queryTaskHistory, upsertTaskHistory } from "../storage/repositories/task-history-repository.js";
+import { decodeTaskHistoryMetadata, getTaskHistory, queryTaskHistory, upsertTaskHistory, } from "../storage/repositories/task-history-repository.js";
 import { startWorkflowRun } from "../workflows/runtime/runs.js";
 import { parseTaskDocument } from "./parser.js";
 export async function runTask(id, options = {}) {
     const stashDir = options.stashDir ?? resolveStashDir();
-    const runAgentImpl = options.runAgentImpl ?? runAgent;
+    const runAgentImpl = options.runAgentImpl;
     const startWorkflowRunImpl = options.startWorkflowRunImpl ?? startWorkflowRun;
     const now = options.now ?? (() => new Date());
     const logDir = options.logDir ?? getTaskLogDir();
@@ -63,8 +64,8 @@ export async function runTask(id, options = {}) {
         const disabledTarget = task.target.kind === "workflow"
             ? { kind: "workflow", ref: task.target.ref }
             : task.target.kind === "command"
-                ? { kind: "prompt", profile: undefined }
-                : { kind: "prompt", profile: task.target.profile };
+                ? { kind: "command", cmd: task.target.cmd }
+                : { kind: "prompt", engine: task.target.engine ?? null };
         const result = {
             id,
             status: "disabled",
@@ -98,9 +99,6 @@ export async function runTask(id, options = {}) {
     if (task.target.kind === "command") {
         return await runCommandTask({ task, logPath, startedAt, now });
     }
-    // Resolve config once here so runPromptTask does not call loadConfig()
-    // on every dispatch in a batch run (Fix C6).
-    const config = loadConfig();
     return await runPromptTask({
         task,
         stashDir,
@@ -109,8 +107,7 @@ export async function runTask(id, options = {}) {
         now,
         runAgentImpl,
         agentOptions: options.agentOptions,
-        agentConfig: config,
-        agentTimeoutMs: undefined,
+        chatCompletionImpl: options.chatCompletionImpl ?? chatCompletion,
     });
 }
 // ── command target ──────────────────────────────────────────────────────────
@@ -201,7 +198,7 @@ async function runCommandTask(input) {
         finishedAt: finishedAt.toISOString(),
         durationMs: finishedAt.getTime() - startedAt.getTime(),
         log: logPath,
-        target: { kind: "prompt", profile: undefined },
+        target: { kind: "command", cmd },
         detail: { exitCode },
     };
     appendHistory(result);
@@ -300,70 +297,70 @@ function renderWorkflowLog(input) {
 }
 // ── prompt target ───────────────────────────────────────────────────────────
 async function runPromptTask(input) {
-    const { task, stashDir, logPath, startedAt, now, runAgentImpl, agentOptions } = input;
+    const { task, stashDir, logPath, startedAt, now, agentOptions } = input;
     if (task.target.kind !== "prompt")
         throw new Error("invariant: prompt target");
-    // Use pre-resolved agent config when available to avoid redundant loadConfig()
-    // calls in batch task runs (Fix C6). Fall back to loadConfig() for callers
-    // that invoke runPromptTask directly without threading config.
-    const fullConfig = loadConfig();
-    const agentCfg = input.agentConfig !== undefined ? input.agentConfig : fullConfig;
-    // Resolve the profile for this task. When the task doc specifies a profile,
-    // use it directly. Otherwise fall back to the per-process config for "task"
-    // (agent.processes["task"]), which itself falls back to agent.default.
-    let profile;
-    let processTimeoutMs;
-    if (task.target.profile) {
-        // v2: if profiles.agent is configured, resolve through new runner
-        if (fullConfig.profiles?.agent) {
-            const mode = task.target.mode ?? "agent";
-            if (mode !== "llm") {
-                const runnerSpec = resolveRunner(mode, task.target.profile, fullConfig);
-                if (runnerSpec.kind === "agent" || runnerSpec.kind === "sdk") {
-                    profile = runnerSpec.profile;
-                    processTimeoutMs = runnerSpec.timeoutMs;
-                }
-                else {
-                    profile = requireAgentProfile(agentCfg, task.target.profile);
-                }
-            }
-            else {
-                profile = requireAgentProfile(agentCfg, task.target.profile);
-            }
-        }
-        else {
-            // v1: Task doc explicitly names a profile — honour it directly.
-            profile = requireAgentProfile(agentCfg, task.target.profile);
-        }
+    const promptTarget = task.target;
+    const config = loadConfig();
+    const engineName = promptTarget.engine ?? config.defaults?.engine;
+    if (!engineName)
+        throw new NotFoundError(`Task "${task.id}" has no selected engine.`, "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 {
-        // No per-task profile: use process config for "task" as a fallback.
-        const resolved = resolveProcessAgentProfile("task", agentCfg);
-        profile = resolved.profile;
-        processTimeoutMs = resolved.timeoutMs;
+        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 } : {}) },
+            ...(promptTarget.timeoutMs !== undefined ? { timeoutMs: promptTarget.timeoutMs } : {}),
+        };
     }
-    // Task-level timeoutMs (including null = disabled) wins over global config.
-    // Resolution: task.timeoutMs → process entry timeoutMs → input.agentTimeoutMs → agentCfg.timeoutMs.
-    const agentTimeoutMs = task.timeoutMs !== undefined
-        ? task.timeoutMs
-        : processTimeoutMs !== undefined
-            ? processTimeoutMs
-            : input.agentTimeoutMs !== undefined
-                ? input.agentTimeoutMs
-                : undefined;
     const promptText = await resolvePromptText(task, stashDir);
-    const result = await runAgentImpl(profile, promptText, {
+    const result = await executeRunner(runner, promptText, {
         stdio: "captured",
-        timeoutMs: agentTimeoutMs,
         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.
         env: { AKM_EVENT_SOURCE: "task", ...agentOptions?.env },
+    }, {
+        ...(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 };
+        },
     });
     const finishedAt = now();
-    const log = renderPromptLog({ task, profileName: profile.name, result });
+    const log = renderPromptLog({ task, engineName, result });
     persistRunLog({
         taskId: task.id,
         startedAtIso: startedAt.toISOString(),
@@ -380,7 +377,7 @@ async function runPromptTask(input) {
         finishedAt: finishedAt.toISOString(),
         durationMs: finishedAt.getTime() - startedAt.getTime(),
         log: logPath,
-        target: { kind: "prompt", profile: profile.name },
+        target: { kind: "prompt", engine: engineName },
         detail: result.ok
             ? { exitCode: result.exitCode }
             : { reason: result.reason, error: result.error, exitCode: result.exitCode },
@@ -410,7 +407,7 @@ async function resolvePromptText(task, stashDir) {
 function renderPromptLog(input) {
     const lines = [];
     const dbLines = [];
-    const header = `[akm tasks] task=${input.task.id} kind=prompt profile=${input.profileName}`;
+    const header = `[akm tasks] 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 });
@@ -481,9 +478,10 @@ function appendHistory(result) {
                 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,
-                    profile: result.target.kind === "prompt" ? result.target.profile : undefined,
+                    ...(result.target.kind === "prompt" ? { engine: result.target.engine } : {}),
                 }),
             });
         });
@@ -515,16 +513,14 @@ export function readTaskHistory(options = {}) {
  * that callers of `readTaskHistory()` expect.
  */
 function taskHistoryRowToResult(row) {
-    let meta = {};
-    try {
-        meta = JSON.parse(row.metadata_json);
-    }
-    catch {
-        // ignore corrupt JSON
-    }
+    const meta = decodeTaskHistoryMetadata(row.metadata_json);
     const target = row.target_kind === "workflow"
         ? { kind: "workflow", ref: row.target_ref ?? "" }
-        : { kind: "prompt", profile: meta.profile };
+        : row.target_kind === "command"
+            ? { kind: "command" }
+            : meta.metadataVersion === 2
+                ? { kind: "prompt", engine: meta.engine ?? null }
+                : { kind: "prompt", engine: null, ...(meta.legacyProfile ? { legacyProfile: meta.legacyProfile } : {}) };
     return {
         id: row.task_id,
         status: row.status,
@@ -533,7 +529,7 @@ function taskHistoryRowToResult(row) {
         durationMs: meta.durationMs ?? 0,
         log: row.log_path ?? "",
         target,
-        ...(meta.detail !== undefined ? { detail: meta.detail } : {}),
+        ...(meta.detail !== undefined && meta.detail !== null ? { detail: meta.detail } : {}),
     };
 }
 /**

package/dist/tasks/schema.js

@@ -12,4 +12,4 @@
  * Tasks are stored as pure YAML files at `<stash>/tasks/<id>.yml`. Multi-line
  * inline prompts use a YAML block scalar (`prompt: |`).
  */
-export const TASK_SCHEMA_VERSION = 1;
+export const TASK_SCHEMA_VERSION = 2;

package/dist/tasks/validator.js

@@ -8,7 +8,7 @@
  *   • the schedule is parseable and translates to the active backend
  *   • the workflow ref resolves (workflow targets)
  *   • the asset/file source exists (prompt targets)
- *   • the agent profile resolves (prompt targets)
+ *   • the selected engine resolves (prompt targets)
  *
  * Validation is deliberately split from parsing: callers that only want to
  * read frontmatter (e.g. `tasks list`) can skip these checks, while
@@ -20,7 +20,7 @@ import { parseAssetRef } from "../core/asset/asset-ref.js";
 import { resolveStashDir } from "../core/common.js";
 import { loadConfig } from "../core/config/config.js";
 import { NotFoundError } from "../core/errors.js";
-import { requireAgentProfile } from "../integrations/agent/index.js";
+import { resolveEngine } from "../integrations/agent/engine-resolution.js";
 import { resolveAssetPath } from "../sources/resolve.js";
 import { parseSchedule } from "./schedule.js";
 export async function validateTaskDocument(task, options) {
@@ -38,13 +38,18 @@ export async function validateTaskDocument(task, options) {
     if (task.target.kind !== "prompt") {
         return;
     }
-    // Prompt target. Resolve the profile unconditionally — when no profile is
-    // set on the task, requireAgentProfile falls back to defaults.agent and
-    // throws a clear error if neither is configured. Catching this at
+    // Prompt target. Resolve the engine unconditionally — when no engine is
+    // set on the task, defaults.engine is required. Catching this at
     // `tasks add` / `tasks sync` time is much more useful than failing only
     // when the OS scheduler fires.
     const config = loadConfig();
-    requireAgentProfile(config, task.target.profile);
+    const engine = task.target.engine ?? config.defaults?.engine;
+    if (!engine)
+        throw new NotFoundError(`Task "${task.id}" has no selected engine.`, "ASSET_NOT_FOUND");
+    const resolved = resolveEngine(engine, config);
+    if (task.target.llm !== undefined && resolved.kind !== "llm") {
+        throw new NotFoundError(`Task "${task.id}" uses llm overrides with non-LLM engine "${engine}".`, "ASSET_NOT_FOUND");
+    }
     const src = task.target.source;
     if (src.kind === "asset") {
         const stashDir = options.stashDir ?? resolveStashDir();

package/dist/text-import-hook.mjs

@@ -16,7 +16,7 @@
 import { readFile } from "node:fs/promises";
 import { fileURLToPath } from "node:url";
 
-const TEXT_EXTENSIONS = new Set([".md", ".xml", ".txt", ".sql"]);
+const TEXT_EXTENSIONS = new Set([".md", ".xml", ".txt", ".sql", ".yaml", ".yml"]);
 
 function isTextImport(url, importAttributes) {
   if (importAttributes && importAttributes.type === "text") return true;

package/dist/wiki/wiki.js

@@ -48,7 +48,7 @@ import ingestWorkflowTemplate from "../assets/wiki/ingest-workflow-template.md"
 import { akmSearch } from "../commands/read/search.js";
 import { parseFrontmatter, parseFrontmatterBlock } from "../core/asset/frontmatter.js";
 import { isWithin, todayIso } from "../core/common.js";
-import { getSources, loadUserConfig, saveConfig } from "../core/config/config.js";
+import { getSources, mutateConfig } from "../core/config/config.js";
 import { NotFoundError, UsageError } from "../core/errors.js";
 import { resolveSourceEntries } from "../indexer/search/search-source.js";
 import { buildIndexMd, buildLogMd, buildSchemaMd } from "./wiki-templates.js";
@@ -443,13 +443,14 @@ export function removeWiki(stashDir, name, options = {}) {
     const external = registeredWikiSources(stashDir).find((source) => source.name === name);
     const isStashWiki = fs.existsSync(wikiDir) && isRecognizedStashWiki(wikiDir);
     if (!isStashWiki && external) {
-        const config = loadUserConfig();
-        const filteredSources = getSources(config).filter((entry) => entry.wikiName !== name);
-        const installed = (config.installed ?? []).filter((entry) => entry.wikiName !== name);
-        saveConfig({
-            ...config,
-            sources: filteredSources.length > 0 ? filteredSources : undefined,
-            installed: installed.length > 0 ? installed : undefined,
+        mutateConfig((config) => {
+            const filteredSources = getSources(config).filter((entry) => entry.wikiName !== name);
+            const installed = (config.installed ?? []).filter((entry) => entry.wikiName !== name);
+            return {
+                ...config,
+                sources: filteredSources.length > 0 ? filteredSources : undefined,
+                installed: installed.length > 0 ? installed : undefined,
+            };
         });
         return {
             name,