akm-cli 0.9.1 → 0.9.2-alpha.2

package/dist/tasks/parser.js

@@ -1,380 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// 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/.
-/**
- * Parse a task YAML file into a {@link TaskDocument}.
- *
- * The on-disk shape is a pure YAML file at `<stash>/tasks/<id>.yml`:
- *
- * ```yaml
- * schedule: "0 9 * * *"
- * # one of:
- * workflow: workflows/daily-backup
- * params:
- *   region: us-east-1
- * timeoutMs: 3600000               # whole-run bound; omit for the unattended
- *                                  # default, `null` to opt out entirely
- * maxSteps: 20                     # optional run bounds, same as the
- * maxRetries: 1                    # `akm workflow run` flags
- * # ...or:
- * prompt: agents/my-agent           # asset ref
- * # ...or:
- * prompt: ./prompts/my-prompt.md    # relative file path
- * # ...or:
- * prompt: |                         # inline multi-line prompt (block scalar)
- *   Do the thing.
- *   And the other thing.
- * # ...or:
- * command: akm improve --strategy quick --limit 25
- * enabled: true                     # default true
- * name: Daily backup
- * description: …
- * when_to_use: …
- * tags: [scheduled, backup]
- * redact: [ACME_DEPLOY_TOKEN]     # optional: env var NAMES (never values) to
- *                                 # scrub from this task's persisted log
- * ```
- *
- * 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 { isFullRefInput } from "../core/asset/resolve-ref.js";
-import { UsageError } from "../core/errors.js";
-import { formatExtraParamsIssue, validateExtraParams } from "../core/extra-params.js";
-import { WORKFLOW_ENV_VAR_NAME_PATTERN, WORKFLOW_MAX_RETRIES } from "../workflows/resource-limits.js";
-import { TASK_MAX_REDACT_NAMES, TASK_MAX_TIMEOUT_MS, TASK_SCHEMA_VERSION, } from "./schema.js";
-import { validateTaskId } from "./task-id.js";
-export function parseTaskDocument(input) {
-    const { yaml, filePath } = input;
-    const id = validateTaskId(input.id);
-    let data;
-    try {
-        const parsed = parseYaml(yaml);
-        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
-            throw new UsageError(`Task "${id}" YAML must be a mapping (key: value pairs). File: ${filePath}`, "INVALID_FLAG_VALUE");
-        }
-        data = parsed;
-    }
-    catch (err) {
-        if (err instanceof UsageError)
-            throw err;
-        throw new UsageError(`Task "${id}" has invalid YAML: ${err instanceof Error ? err.message : String(err)}. File: ${filePath}`, "INVALID_FLAG_VALUE");
-    }
-    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 = 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;
-    const targetCount = [hasWorkflow, hasPrompt, hasCommand].filter(Boolean).length;
-    if (targetCount > 1) {
-        throw new UsageError(`Task "${id}" sets more than one of \`workflow\`, \`prompt\`, \`command\`; pick exactly one. File: ${filePath}`, "INVALID_FLAG_VALUE");
-    }
-    if (targetCount === 0) {
-        throw new UsageError(`Task "${id}" must set one of \`workflow\`, \`prompt\`, or \`command\`. File: ${filePath}`, "MISSING_REQUIRED_ARGUMENT");
-    }
-    let target;
-    if (hasWorkflow) {
-        rejectTargetFields(data, ["params", "timeoutMs", "maxSteps", "maxRetries"], id, filePath);
-        const ref = requireString(data.workflow, "workflow", filePath);
-        if (!ref) {
-            throw new UsageError(`Task "${id}" has empty \`workflow\`. File: ${filePath}`, "INVALID_FLAG_VALUE");
-        }
-        // The three run bounds `akm workflow run` takes as flags, declared in the
-        // task file instead: an unattended run gets the same abort path the
-        // interactive CLI has. `timeoutMs` left unset falls back to the runner's
-        // default (see DEFAULT_WORKFLOW_TASK_TIMEOUT_MS); `null` opts out.
-        const workflowTimeoutMs = readTimeout(data.timeoutMs, filePath);
-        const maxSteps = readBoundedInteger(data.maxSteps, "maxSteps", 1, undefined, filePath);
-        const maxRetries = readBoundedInteger(data.maxRetries, "maxRetries", 0, WORKFLOW_MAX_RETRIES, filePath);
-        target = {
-            kind: "workflow",
-            ref,
-            params: readParams(data.params, filePath),
-            ...(workflowTimeoutMs !== undefined ? { timeoutMs: workflowTimeoutMs } : {}),
-            ...(maxSteps !== undefined ? { maxSteps } : {}),
-            ...(maxRetries !== undefined ? { maxRetries } : {}),
-        };
-    }
-    else if (hasCommand) {
-        rejectTargetFields(data, ["timeoutMs"], id, filePath);
-        target = { kind: "command", cmd: readCommand(data.command, filePath, id) };
-    }
-    else {
-        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 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),
-            ...(engine ? { engine } : {}),
-            ...(model ? { model } : {}),
-            ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-            ...(llm ? { llm } : {}),
-        };
-    }
-    const timeoutMs = hasCommand ? readTimeout(data.timeoutMs, filePath) : undefined;
-    const redact = readRedactNames(data.redact, filePath);
-    return {
-        version: TASK_SCHEMA_VERSION,
-        schemaVersion: TASK_SCHEMA_VERSION,
-        id,
-        schedule,
-        enabled,
-        target,
-        ...(name ? { name } : {}),
-        ...(description ? { description } : {}),
-        ...(when_to_use ? { when_to_use } : {}),
-        ...(tags ? { tags } : {}),
-        source: { path: filePath },
-        timeoutMs,
-        ...(redact ? { redact } : {}),
-    };
-}
-const TASK_KEYS = new Set([
-    "version",
-    "name",
-    "description",
-    "when_to_use",
-    "tags",
-    "schedule",
-    "enabled",
-    "workflow",
-    "prompt",
-    "command",
-    "params",
-    "engine",
-    "model",
-    "timeoutMs",
-    "maxSteps",
-    "maxRetries",
-    "llm",
-    "redact",
-]);
-const SHARED_KEYS = new Set([
-    "version",
-    "name",
-    "description",
-    "when_to_use",
-    "tags",
-    "schedule",
-    "enabled",
-    // `redact:` is target-agnostic: every kind funnels through the same log sink.
-    "redact",
-]);
-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", "Use task schema version: 2.");
-}
-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.
- *
- *   • "[bundle//]<subdir>/<name>" (asset ref)  → asset
- *   • "./foo.md", "../foo.md", "/abs"          → file
- *   • "C:\\abs" (Windows absolute)             → file
- *   • anything else (including colon text and block scalars) → inline text
- */
-function resolvePromptSource(raw, filePath, id) {
-    const trimmed = raw.trim();
-    if (!trimmed) {
-        throw new UsageError(`Task "${id}" has empty \`prompt\`. File: ${filePath}`, "MISSING_REQUIRED_ARGUMENT");
-    }
-    if (trimmed.startsWith("./") || trimmed.startsWith("../") || path.isAbsolute(trimmed)) {
-        return { kind: "file", path: trimmed };
-    }
-    if (/^[A-Za-z]:[\\/]/.test(trimmed)) {
-        return { kind: "file", path: trimmed };
-    }
-    // Canonical 0.9.0 asset ref: `[bundle//]<stash-subdir>/<name>`. Detection is
-    // delegated to the canonical parser (never a hand-rolled regex) — only a
-    // conceptId whose leading segment is a real stash subdir counts as a ref; a
-    // bare `word/word` inline prompt (no known subdir) stays inline text (D-R3).
-    if (isFullRefInput(trimmed)) {
-        return { kind: "asset", ref: trimmed };
-    }
-    return { kind: "inline", text: trimmed };
-}
-function optionalString(value, key, filePath) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value === "string")
-        return value;
-    throw new UsageError(`Key "${key}" must be a string. File: ${filePath}`, "INVALID_FLAG_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 (Array.isArray(value)) {
-        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;
-    }
-    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)) {
-        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");
-        }
-        return parts;
-    }
-    if (typeof value === "string") {
-        const parts = value.trim().split(/\s+/).filter(Boolean);
-        if (parts.length === 0) {
-            throw new UsageError(`Task "${id}" has empty \`command\`. File: ${filePath}`, "INVALID_FLAG_VALUE");
-        }
-        return parts;
-    }
-    throw new UsageError(`Key "command" must be a string or array of strings. File: ${filePath}`, "INVALID_FLAG_VALUE");
-}
-function readParams(value, filePath) {
-    if (value === undefined || value === null)
-        return {};
-    if (typeof value === "object" && !Array.isArray(value)) {
-        return value;
-    }
-    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;
-    // The ceiling is `setTimeout`'s, not a policy: a larger delay overflows and
-    // fires immediately, turning a generous timeout into an instant abort.
-    if (typeof value === "number" && Number.isInteger(value) && value > 0 && value <= TASK_MAX_TIMEOUT_MS)
-        return value;
-    throw new UsageError(`Key "timeoutMs" must be an integer from 1 through ${TASK_MAX_TIMEOUT_MS}, or null. File: ${filePath}`, "INVALID_FLAG_VALUE");
-}
-/**
- * Read the `redact:` opt-in list — environment variable NAMES whose values are
- * scrubbed from this task's persisted log (#755).
- *
- * A value that looks like a secret rather than a name is rejected outright, not
- * silently accepted: a literal in a task file would be indexed, searchable and
- * printed verbatim by `akm show`, so accepting one would leak the secret
- * through a wider channel than the redaction closes.
- */
-function readRedactNames(value, filePath) {
-    if (value === undefined || value === null)
-        return undefined;
-    const invalid = (detail) => {
-        throw new UsageError(`Key "redact" ${detail}. File: ${filePath}`, "INVALID_FLAG_VALUE");
-    };
-    if (!Array.isArray(value))
-        return invalid("must be a list of environment variable names");
-    if (value.length > TASK_MAX_REDACT_NAMES) {
-        return invalid(`accepts at most ${TASK_MAX_REDACT_NAMES} names (got ${value.length})`);
-    }
-    const names = [];
-    for (const entry of value) {
-        if (typeof entry !== "string" || !WORKFLOW_ENV_VAR_NAME_PATTERN.test(entry)) {
-            return invalid(`takes environment variable NAMES only (matching ${WORKFLOW_ENV_VAR_NAME_PATTERN.source}), not values — ` +
-                `got ${JSON.stringify(entry)}. A secret written here would be indexed and printed by \`akm show\``);
-        }
-        if (!names.includes(entry))
-            names.push(entry);
-    }
-    return names.length > 0 ? names : undefined;
-}
-function readBoundedInteger(value, key, minimum, maximum, filePath) {
-    if (value === undefined || value === null)
-        return undefined;
-    if (typeof value === "number" &&
-        Number.isSafeInteger(value) &&
-        value >= minimum &&
-        (maximum === undefined || value <= maximum)) {
-        return value;
-    }
-    const range = maximum === undefined ? `at least ${minimum}` : `from ${minimum} through ${maximum}`;
-    throw new UsageError(`Key "${key}" must be an integer ${range}. 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");
-        }
-    }
-    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");
-        }
-    }
-    return data;
-}

package/dist/tasks/schema.js

@@ -1,123 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// 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/.
-/**
- * Task asset schema. A task pairs a cron-style schedule with exactly one of:
- *
- *   • a workflow target  — executed via `runWorkflowSteps()`
- *   • a prompt target    — invoked via `runAgent()` against the configured
- *                          agent harness (e.g. `opencode run`)
- *   • a command target   — invoked directly via `Bun.spawn()`, no AI agent
- *
- * Tasks are stored as pure YAML files at `<stash>/tasks/<id>.yml`. Multi-line
- * inline prompts use a YAML block scalar (`prompt: |`).
- */
-import { parse as parseYaml } from "yaml";
-import { WORKFLOW_MAX_EXEC_PASS_ENV, WORKFLOW_MAX_TIMEOUT_MS } from "../workflows/resource-limits.js";
-export const TASK_SCHEMA_VERSION = 2;
-/** The ONE recognized on-disk task extension (spec §6 task row). */
-export const TASK_EXTENSION = ".yml";
-/**
- * The near-miss spelling. `.yaml` is NOT a task extension: the indexer's
- * `tasks` matcher (`indexer/walk/matchers.ts`) gates on `.yml`, so a
- * `tasks/<id>.yaml` file is never indexed, never scheduled, and never runs.
- * It is recognized HERE only so lint can say so out loud instead of walking
- * past it (issue #760).
- */
-export const TASK_NEAR_MISS_EXTENSION = ".yaml";
-/**
- * Largest expressible `timeoutMs` — `setTimeout`'s 32-bit signed ceiling
- * (2^31-1, ~24.8 days). A larger delay overflows and fires almost immediately,
- * which would silently abort a run seconds after it started instead of hours
- * later. One definition with the workflow bound (`WORKFLOW_MAX_TIMEOUT_MS`) —
- * it is a platform fact, not a per-surface policy. Mirrored as `maximum` on
- * `timeoutMs` in `schemas/akm-task.json`.
- */
-export const TASK_MAX_TIMEOUT_MS = WORKFLOW_MAX_TIMEOUT_MS;
-/**
- * Most names a task's `redact:` list may carry. Shares its bound with exec
- * units' `pass_env:` — both are "name the one or two the defaults miss", not a
- * way to declare the whole environment secret. Mirrored as `maxItems` on
- * `redact` in `schemas/akm-task.json`.
- */
-export const TASK_MAX_REDACT_NAMES = WORKFLOW_MAX_EXEC_PASS_ENV;
-/**
- * Lint-level shape problems for a parsed task YAML mapping: the field rules
- * `src/tasks/parser.ts` enforces at load time, phrased as diagnostics. The ONE
- * definition shared by both task linters (`core/adapter/adapters/akm-lint.ts`
- * and `akm-task-adapter.ts`) so lint and runtime cannot disagree — they
- * previously did, in both directions: lint demanded `enabled` (which the
- * parser defaults to `true`, so a runnable task was flagged) and never checked
- * `version` (which the parser hard-requires as `2`, so a lint-clean task died
- * at runtime with TASK_SCHEMA_VERSION_UNSUPPORTED). `schemas/akm-task.json`
- * agrees with the parser: `required: [version, schedule]`, `version:
- * {const: 2}`, `enabled` optional but boolean. Target-arity rules stay with
- * each caller (they legitimately differ: at-least-one vs exactly-one), but
- * what COUNTS as a target is shared — see {@link isPresentTarget}.
- */
-/**
- * Whether a task-target field counts as declared.
- *
- * The arity rules differ between the two linters, but the presence test must
- * not: the runtime parser treats `""` as absent, so a key-existence check let
- * `workflow: ""` lint clean and then die with MISSING_REQUIRED_ARGUMENT. An
- * array target (`command`) counts only when it has entries, for the same
- * reason. Kept beside {@link taskFieldProblems} so all three definitions of
- * "valid task" stay in one file.
- */
-export function isPresentTarget(value) {
-    if (value === undefined || value === null)
-        return false;
-    if (typeof value === "string")
-        return value.trim() !== "";
-    if (Array.isArray(value))
-        return value.length > 0;
-    return true;
-}
-export function taskFieldProblems(data) {
-    const problems = [];
-    if (data.version !== TASK_SCHEMA_VERSION)
-        problems.push(`version (must be ${TASK_SCHEMA_VERSION})`);
-    if (typeof data.schedule !== "string" || data.schedule.trim() === "")
-        problems.push("schedule");
-    if ("enabled" in data && typeof data.enabled !== "boolean")
-        problems.push("enabled (must be a boolean when present)");
-    return problems;
-}
-/**
- * Parse a task YAML document into a plain mapping. Non-mapping documents (a
- * scalar, a sequence, an empty file) are NOT a parse failure — they parse fine
- * and simply carry no fields, which the field rules above already describe.
- *
- * The ONE parse used by all three task-lint surfaces (`commands/lint/index.ts`'s
- * akm sweep, the `akm` adapter's `validate`, and the `akm-task` adapter) so a
- * malformed file cannot be a finding on one surface and silence on another.
- */
-export function parseTaskYaml(raw) {
-    try {
-        const doc = parseYaml(raw);
-        if (doc && typeof doc === "object" && !Array.isArray(doc))
-            return { ok: true, data: doc };
-        return { ok: true, data: {} };
-    }
-    catch (e) {
-        // yaml's errors carry a multi-line source excerpt; keep the first line so
-        // the diagnostic stays one readable finding.
-        const message = (e instanceof Error ? e.message : String(e)).split("\n")[0]?.trim() ?? "unknown parse error";
-        return { ok: false, data: {}, error: message };
-    }
-}
-/** The `invalid-task-yaml` detail for a file whose YAML could not be parsed. */
-export function taskYamlParseDetail(error) {
-    return `task YAML does not parse: ${error}`;
-}
-/**
- * The `invalid-task-yaml` detail for a task file using the `.yaml` near-miss
- * spelling. See {@link TASK_NEAR_MISS_EXTENSION} for why this is an error and
- * not a style nit.
- */
-export function taskExtensionDetail(relPath) {
-    const base = relPath.replace(/\.yaml$/i, "");
-    return (`task file uses the ${TASK_NEAR_MISS_EXTENSION} extension; akm recognizes tasks only as ` +
-        `${TASK_EXTENSION}, so this file is never indexed or scheduled — rename it to ${base}${TASK_EXTENSION}.`);
-}

package/dist/tasks/validator.js

@@ -1,80 +0,0 @@
-// This Source Code Form is subject to the terms of the Mozilla Public
-// 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/.
-/**
- * Validate a parsed {@link TaskDocument} for runnability.
- *
- * Enforces:
- *   • the schedule is parseable and translates to the active backend
- *   • the workflow ref resolves (workflow targets)
- *   • the asset/file source exists (prompt targets)
- *   • the selected engine resolves (prompt targets)
- *
- * Validation is deliberately split from parsing: callers that only inspect
- * task metadata (e.g. `akm show`) can skip these checks, while
- * `task add` and `task run` should always run them.
- */
-import fs from "node:fs";
-import path from "node:path";
-import { placementSpecFor } from "../core/asset/asset-placement.js";
-import { parseRefInput } from "../core/asset/resolve-ref.js";
-import { loadConfig } from "../core/config/config.js";
-import { NotFoundError } from "../core/errors.js";
-import { NO_ENGINE_MESSAGE_SUFFIX, withEngineFallback } from "../integrations/agent/engine-fallback.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) {
-    // Schedule must parse and translate.
-    parseSchedule(task.schedule, options.backend);
-    if (task.target.kind === "workflow") {
-        const stashDir = options.stashDir;
-        const ref = parseRefInput(task.target.ref);
-        if (ref.type !== "workflow") {
-            throw new NotFoundError(`Task "${task.id}" workflow target must be a workflow ref (got "${task.target.ref}").`, "WORKFLOW_NOT_FOUND");
-        }
-        await resolveAssetPath(stashDir, "workflow", ref.name);
-        return;
-    }
-    if (task.target.kind !== "prompt") {
-        return;
-    }
-    // Prompt target. Resolve the engine unconditionally — when no engine is
-    // set on the task, defaults.engine is required. Catching this at
-    // `task add` / `task sync` time is much more useful than failing only
-    // when the OS scheduler fires.
-    // Resolve against the SAME effective config the runner will use
-    // (`tasks/runner.ts`), or validation rejects at `task add` / `task sync` a
-    // task the runner would have happily executed via the implicit fallback.
-    const { config } = withEngineFallback(loadConfig());
-    const engine = task.target.engine ?? config.defaults?.engine;
-    if (!engine)
-        throw new NotFoundError(`Task "${task.id}" ${NO_ENGINE_MESSAGE_SUFFIX}`, "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;
-        const ref = parseRefInput(src.ref);
-        // D11 — `parseRefInput` now also accepts an opaque adapter conceptId (a
-        // ref whose leading segment is not an AKM placement dir), but
-        // `resolveAssetPath` (src/sources/resolve.ts) is placement-dir-only: it
-        // has no stash-subdir to route an opaque type through. Surface a clean
-        // domain error here rather than let that helper crash on a missing
-        // directory mapping.
-        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");
-        }
-        await resolveAssetPath(stashDir, ref.type, ref.name);
-    }
-    else if (src.kind === "file") {
-        const taskDir = path.dirname(task.source.path);
-        const resolved = path.isAbsolute(src.path) ? src.path : path.resolve(taskDir, src.path);
-        if (!fs.existsSync(resolved) || !fs.statSync(resolved).isFile()) {
-            throw new NotFoundError(`Prompt file not found for task "${task.id}": ${src.path} (resolved to ${resolved}).`, "FILE_NOT_FOUND");
-        }
-    }
-    // inline source is always valid post-parse.
-}