akm-cli 0.9.1 → 0.9.2-alpha.2

package/dist/workflows/ir/source-freeze-v4.js

@@ -0,0 +1,506 @@
+// 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/.
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import fs from "node:fs";
+import path from "node:path";
+import { prepareCommandInvocation } from "../../commands/command/command-execution.js";
+import { loadAdapterExecutionSource } from "../../commands/command/execution-source-loader.js";
+import { makeBundleRef, parseBundleRef } from "../../core/asset/asset-ref.js";
+import { parseEnvRef } from "../../core/env-secret-ref.js";
+import { ConfigError, UsageError } from "../../core/errors.js";
+import { captureFrozenDirectoryIdentity } from "../../execution/directory-identity.js";
+import { freezeExecutableIdentity } from "../../execution/executable-identity.js";
+import { canonicalResolvedExecutionRequest, decodeResolvedExecutionRequest, } from "../../execution/resolved-request.js";
+import { deriveInstallations } from "../../indexer/installations.js";
+import { resolveSourceEntries } from "../../indexer/search/search-source.js";
+import { fallbackAnnouncement } from "../../integrations/agent/engine-fallback.js";
+import { requireAuthorizedExecutionPlan } from "../../integrations/agent/execution-cascade.js";
+import { lowerResolvedExecutionRequest } from "../../integrations/agent/execution-lowering.js";
+import { prepareInlineExecution } from "../../integrations/agent/inline-execution.js";
+import { resolveAssetPath } from "../../sources/resolve.js";
+import { prepareTaskV3Execution, } from "../../tasks/runtime-v3.js";
+import { parseTaskV3Yaml } from "../../tasks/source-v3.js";
+import { defaultLlmEngineConcurrency } from "../concurrency-policy.js";
+import { DEFAULT_EXEC_TIMEOUT_MS } from "../resource-limits.js";
+import { compileWorkflowSource } from "../source-ir/compile.js";
+import { sourceStepProgramUnit, sourceStepRef, workflowShellCommand } from "../source-ir/program.js";
+import { classifyWorkflowStepUses } from "../source-ir/semantics.js";
+import { freezeWorkflowEnvironment } from "./environment-v4.js";
+/** Resolve every authored target through the shared command/task authorities before v4 publication. */
+export async function resolveWorkflowSourceV4(asset, workflowSource, config, collector) {
+    const compiled = compileWorkflowSource(workflowSource.content, { path: asset.path, workspaceRoot: asset.sourcePath });
+    if (!compiled.ok) {
+        throw new UsageError(`Workflow source cannot be frozen: ${compiled.errors.map((error) => error.message).join("; ")}`, "INVALID_FLAG_VALUE");
+    }
+    if (compiled.ir.jobs.length !== 1) {
+        throw new UsageError("Multi-job workflow cannot execute until job boundaries and needs have a durable runtime representation.", "INVALID_FLAG_VALUE");
+    }
+    const context = { asset, config, collector, sourceIr: compiled.ir };
+    const units = new Map();
+    const judges = new Map();
+    let engineAnnouncement;
+    const sourceSteps = compiled.ir.jobs[0]?.steps ?? [];
+    for (const sourceStep of sourceSteps) {
+        if (!sourceStep.route) {
+            const resolved = await resolveStep(sourceStep, context);
+            units.set(sourceStep.id, Object.freeze(resolved));
+            engineAnnouncement ??= resolved.engineAnnouncement;
+        }
+        if (sourceStep.gate?.rubric?.trim()) {
+            const judge = resolveJudge(sourceStep, context);
+            if (judge.target.kind !== "command")
+                throw new Error(`workflow judge ${sourceStep.id} did not resolve to a command target`);
+            judges.set(sourceStep.id, judge.target);
+            engineAnnouncement ??= judge.engineAnnouncement;
+        }
+    }
+    return Object.freeze({
+        sourceIr: compiled.ir,
+        units,
+        judges,
+        ...(engineAnnouncement ? { engineAnnouncement } : {}),
+    });
+}
+async function resolveStep(source, context) {
+    const baseUnit = sourceStepProgramUnit(source);
+    if (source.exec || source.run !== undefined)
+        return directShell(source, baseUnit, context);
+    if (!source.uses)
+        return inlineDispatch(source, baseUnit, context);
+    const target = classifyWorkflowStepUses(source.uses);
+    if (target.kind === "task")
+        return taskDispatch(source, baseUnit, target.ref, context);
+    if (target.kind === "script")
+        return directScript(source, baseUnit, target.ref, context);
+    if (target.kind === "command" || target.kind === "builtin-command") {
+        const action = target.kind === "builtin-command"
+            ? source.with
+            : { ref: qualifyRef(target.ref, "commands", context.asset, context.config) };
+        return commandDispatch(source, baseUnit, action, context);
+    }
+    throw new UsageError(`Workflow target ${source.uses} is not executable in 0.9.2.`, "INVALID_FLAG_VALUE");
+}
+async function commandDispatch(source, baseUnit, action, context) {
+    const prepared = await prepareCommandInvocation({
+        action,
+        config: context.config,
+        invocationKind: "workflow",
+        ...(context.sourceIr.defaults
+            ? { invocationDefaults: executionUnitValues(context.sourceIr.defaults, context.asset.sourcePath) }
+            : {}),
+        ...(source.commandMode === "literal" ? { inlineContentMode: "literal" } : {}),
+        current: executionValues(source, context.asset.sourcePath),
+        sourceLoader: (ref, kind) => guardedExecutionSource(ref, kind, context),
+    });
+    return commandResult(source, baseUnit, prepared, context);
+}
+function inlineDispatch(source, baseUnit, context) {
+    const content = source.instructions ?? `Execute workflow step ${source.id}.`;
+    const prepared = prepareInlineExecution({
+        content,
+        config: context.config,
+        invocationKind: "workflow",
+        ...(context.sourceIr.defaults
+            ? { invocationDefaults: executionUnitValues(context.sourceIr.defaults, context.asset.sourcePath) }
+            : {}),
+        current: executionValues(source, context.asset.sourcePath),
+    });
+    return commandResult(source, baseUnit, prepared, context);
+}
+function resolveJudge(source, context) {
+    const engine = context.config.workflow?.judgeEngine;
+    if (!engine) {
+        throw new ConfigError("This workflow declares completion criteria but no verification engine is configured. Set workflow.judgeEngine to a named LLM or agent engine.", "INVALID_CONFIG_FILE");
+    }
+    const content = source.gate?.rubric?.trim() ?? "Judge workflow completion.";
+    const prepared = prepareInlineExecution({
+        content,
+        config: context.config,
+        invocationKind: "workflow",
+        current: { engine },
+    });
+    return commandResult(source, { onError: "fail", source: sourceStepRef(source) }, prepared, context);
+}
+async function taskDispatch(source, baseUnit, refInput, context) {
+    const owned = await resolveOwnedAsset(refInput, "task", context);
+    const retained = captureOwned(owned, context.collector);
+    const task = parseTaskV3Yaml({ yaml: retained.content, filePath: owned.file, workspaceRoot: owned.root });
+    if (task.target.kind === "uses" && task.target.uses.kind === "workflow") {
+        throw new UsageError("A workflow task step cannot compose a nested workflow target.", "INVALID_FLAG_VALUE");
+    }
+    const prepared = await prepareTaskV3Execution(task, {
+        taskId: parseBundleRef(owned.ref).conceptId.slice("tasks/".length),
+        taskRef: owned.ref,
+        bundleName: owned.bundle,
+        bundleRoot: owned.root,
+        config: context.config,
+        commandSourceLoader: (ref, kind) => guardedExecutionSource(ref, kind, context),
+        resolveAsset: async ({ ref, type }) => {
+            const target = await resolveOwnedAsset(ref, type, context);
+            captureOwned(target, context.collector);
+            return { file: target.file, bundleRoot: target.root };
+        },
+        readFile: (file, root = owned.root) => context.collector.readBytes(file, root),
+    });
+    if (prepared.kind === "workflow") {
+        throw new UsageError("A workflow task step cannot compose a nested workflow target.", "INVALID_FLAG_VALUE");
+    }
+    const taskLiterals = Object.entries(prepared.environment).map(([name, value]) => Object.freeze({ kind: "literal", name, value }));
+    if (prepared.kind === "command") {
+        return commandResult(source, baseUnit, prepared.invocation, context, taskLiterals);
+    }
+    if (prepared.kind === "shell") {
+        const authoredExec = {
+            command: workflowShellCommand(prepared.shell, prepared.command),
+            ...(prepared.cwdIdentity.realCwd !== prepared.cwdIdentity.realRoot
+                ? { cwd: path.relative(prepared.cwdIdentity.realRoot, prepared.cwdIdentity.realCwd) }
+                : {}),
+        };
+        const exec = freezeExecSpec(source, authoredExec, context);
+        const environment = Object.freeze([...taskLiterals, ...freezeEnvironment(source, authoredExec, context)]);
+        const executable = freezeExecutableIdentity(exec.command[0], { cwd: prepared.cwdIdentity.realCwd });
+        const target = Object.freeze({
+            kind: "shell",
+            contentHash: "",
+            exec,
+            cwdIdentity: prepared.cwdIdentity,
+            executable,
+            ...gitIdentity(baseUnit, prepared.cwdIdentity.realRoot),
+        });
+        return {
+            target,
+            environment,
+            unit: { ...baseUnit, exec: authoredExec },
+            instructions: source.instructions ?? `Run task ${owned.ref}.`,
+        };
+    }
+    return scriptResult(source, baseUnit, prepared, context, taskLiterals);
+}
+async function directScript(source, baseUnit, refInput, context) {
+    const owned = await resolveOwnedAsset(refInput, "script", context);
+    captureOwned(owned, context.collector);
+    const synthetic = parseTaskV3Yaml({
+        yaml: `version: 3\nuses: ${owned.ref}\nakm:\n  schedule: "@daily"\n`,
+        filePath: `${context.asset.path}#${source.id}`,
+        workspaceRoot: context.asset.sourcePath,
+    });
+    const prepared = await prepareTaskV3Execution(synthetic, {
+        taskId: source.id,
+        taskRef: `${context.asset.ref}#${source.id}`,
+        bundleName: parseBundleRef(context.asset.ref).bundle ?? owned.bundle,
+        bundleRoot: context.asset.sourcePath,
+        config: context.config,
+        resolveAsset: async () => ({ file: owned.file, bundleRoot: owned.root }),
+        readFile: () => context.collector.readBytes(owned.file, owned.root),
+    });
+    if (prepared.kind !== "script")
+        throw new Error("direct script did not project as a script");
+    return scriptResult(source, baseUnit, prepared, context, []);
+}
+function scriptResult(source, baseUnit, prepared, context, literals) {
+    const requestedExecutable = scriptExecutable(prepared.interpreter);
+    const executable = freezeExecutableIdentity(requestedExecutable, { cwd: prepared.cwdIdentity.realCwd });
+    const authoredExec = { command: [executable.absolutePath, "<frozen-script>"] };
+    const exec = freezeExecSpec(source, authoredExec, context);
+    const environment = Object.freeze([...literals, ...freezeEnvironment(source, authoredExec, context)]);
+    const target = Object.freeze({
+        kind: "script",
+        ref: prepared.sourceRef,
+        contentHash: prepared.sha256,
+        exec,
+        interpreter: prepared.interpreter,
+        extension: prepared.extension,
+        bytesBase64: prepared.bytesBase64,
+        byteLength: prepared.byteLength,
+        cwdIdentity: prepared.cwdIdentity,
+        materialization: "ephemeral-0700-delete",
+        executable,
+        ...gitIdentity(baseUnit, prepared.cwdIdentity.realRoot),
+    });
+    return {
+        target,
+        environment,
+        unit: { ...baseUnit, exec: authoredExec },
+        instructions: source.instructions ?? `Run script ${prepared.sourceRef}.`,
+    };
+}
+function directShell(source, baseUnit, context) {
+    const authoredExec = baseUnit.exec;
+    if (!authoredExec)
+        throw new Error(`workflow shell step ${source.id} lost its source-IR execution spec`);
+    const exec = freezeExecSpec(source, authoredExec, context);
+    const cwdIdentity = captureFrozenDirectoryIdentity(context.asset.sourcePath, authoredExec.cwd);
+    const executable = freezeExecutableIdentity(authoredExec.command[0], { cwd: cwdIdentity.realCwd });
+    const environment = Object.freeze(freezeEnvironment(source, authoredExec, context));
+    const target = Object.freeze({
+        kind: "shell",
+        contentHash: "",
+        exec,
+        cwdIdentity,
+        executable,
+        ...gitIdentity(baseUnit, cwdIdentity.realRoot),
+    });
+    return {
+        target,
+        environment,
+        unit: { ...baseUnit, exec },
+        instructions: source.instructions ?? `Run ${source.run ?? authoredExec.command.join(" ")}.`,
+    };
+}
+function commandResult(source, baseUnit, prepared, context, literals = []) {
+    const request = durableRequest(requireAuthorizedExecutionPlan(prepared.plan));
+    const lowered = lowerResolvedExecutionRequest(request, prepared.config);
+    const cwdIdentity = captureFrozenDirectoryIdentity(context.asset.sourcePath);
+    let runner = lowered.runner;
+    let executable;
+    if (runner.kind === "agent") {
+        executable = freezeExecutableIdentity(runner.profile.bin, { cwd: cwdIdentity.realCwd });
+        runner = Object.freeze({ ...runner, profile: Object.freeze({ ...runner.profile, bin: executable.absolutePath }) });
+    }
+    const unit = {
+        ...baseUnit,
+        engine: request.engine.name,
+        ...(request.model ? { model: request.model.resolved } : {}),
+        ...(Object.hasOwn(request.runtime, "timeoutMs") ? { timeoutMs: request.runtime.timeoutMs } : {}),
+        ...(request.inference ? { llm: request.inference } : {}),
+        ...(request.outputSchema ? { output: request.outputSchema } : {}),
+    };
+    const environment = Object.freeze([...literals, ...freezeEnvironment(source, undefined, context)]);
+    const target = Object.freeze({
+        kind: "command",
+        ref: request.command.source?.ref ?? null,
+        contentHash: createHash("sha256").update(request.command.content).digest("hex"),
+        request: JSON.parse(canonicalResolvedExecutionRequest(request)),
+        runner,
+        ...(targetConcurrency(runner, context.config) ? { concurrency: targetConcurrency(runner, context.config) } : {}),
+        cwdIdentity,
+        ...(executable ? { executable } : {}),
+        ...gitIdentity(baseUnit, cwdIdentity.realRoot),
+    });
+    const engineAnnouncement = fallbackAnnouncement(prepared.fallbackEngineName, request.engine.name);
+    return {
+        target,
+        environment,
+        unit,
+        instructions: request.command.content,
+        ...(engineAnnouncement ? { engineAnnouncement } : {}),
+    };
+}
+function freezeExecSpec(source, exec, context) {
+    const declared = Object.hasOwn(source.unit ?? {}, "timeoutMs")
+        ? source.unit?.timeoutMs
+        : context.sourceIr.defaults && Object.hasOwn(context.sourceIr.defaults, "timeoutMs")
+            ? context.sourceIr.defaults.timeoutMs
+            : undefined;
+    return {
+        ...exec,
+        command: exec.command,
+        timeoutMs: declared === undefined ? DEFAULT_EXEC_TIMEOUT_MS : declared,
+    };
+}
+function targetConcurrency(runner, config) {
+    if (runner.kind === "llm") {
+        const configured = typeof runner.engine === "string" ? config.engines?.[runner.engine] : undefined;
+        return defaultLlmEngineConcurrency(runner.connection.endpoint, configured?.kind === "llm" ? configured.concurrency : undefined);
+    }
+    if (runner.kind !== "sdk" || !runner.fallbackConnection)
+        return undefined;
+    const selected = typeof runner.engine === "string" ? config.engines?.[runner.engine] : undefined;
+    const fallbackName = selected?.kind === "agent" ? (selected.llmEngine ?? config.defaults?.llmEngine) : undefined;
+    const fallback = fallbackName ? config.engines?.[fallbackName] : undefined;
+    return defaultLlmEngineConcurrency(runner.fallbackConnection.endpoint, fallback?.kind === "llm" ? fallback.concurrency : undefined);
+}
+function durableRequest(request) {
+    const wire = JSON.parse(canonicalResolvedExecutionRequest(request));
+    const runtime = { ...wire.runtime };
+    delete runtime.environment;
+    wire.runtime = runtime;
+    return decodeResolvedExecutionRequest(wire);
+}
+function executionValues(source, workspace) {
+    return executionUnitValues(source.unit, workspace);
+}
+function executionUnitValues(unit, workspace) {
+    return Object.freeze({
+        ...(unit && Object.hasOwn(unit, "engine") ? { engine: unit.engine } : {}),
+        ...(unit && Object.hasOwn(unit, "model") ? { model: unit.model } : {}),
+        ...(unit && Object.hasOwn(unit, "llm") ? { inference: unit.llm } : {}),
+        ...(unit && Object.hasOwn(unit, "timeoutMs") ? { timeout: unit.timeoutMs } : {}),
+        ...(unit && "output" in unit && Object.hasOwn(unit, "output") ? { outputSchema: unit.output } : {}),
+        workspace,
+    });
+}
+function freezeEnvironment(source, exec, context) {
+    const literals = Object.entries(source.env ?? {}).map(([name, value]) => Object.freeze({ kind: "literal", name, value: String(value) }));
+    const passThrough = (exec?.passEnv ?? []).map((name) => Object.freeze({ kind: "pass-through", name }));
+    const refs = source.unit?.env ?? [];
+    const envRefs = freezeWorkflowEnvironment(refs, {
+        collector: context.collector,
+        resolveRef: (ref) => {
+            const parsedEnv = parseEnvRef(ref);
+            if (parsedEnv.type !== "env")
+                throw new UsageError(`Expected an env ref; got ${ref}.`, "INVALID_FLAG_VALUE");
+            const owned = resolveOwnedAssetSync(ref, "env", context);
+            return { ref: owned.ref, bundle: owned.bundle, adapter: owned.adapter, root: owned.root, path: owned.file };
+        },
+    });
+    return [...literals, ...passThrough, ...envRefs];
+}
+async function guardedExecutionSource(ref, kind, context) {
+    const owned = await resolveOwnedAsset(ref, kind === "command" ? "command" : "agent", context);
+    captureOwned(owned, context.collector);
+    const options = {
+        config: context.config,
+        fileContext: () => context.collector.fileContext(owned.root, owned.file),
+    };
+    const rendered = kind === "command"
+        ? await loadAdapterExecutionSource(owned.ref, "command", options)
+        : await loadAdapterExecutionSource(owned.ref, "persona", options);
+    context.collector.bindIdentity(owned.file, owned.root, rendered.identity);
+    return rendered;
+}
+async function resolveOwnedAsset(ref, type, context) {
+    return resolveOwnedAssetCore(ref, type, context, false);
+}
+function resolveOwnedAssetSync(ref, type, context) {
+    return resolveOwnedAssetCore(ref, type, context, true);
+}
+function resolveOwnedAssetCore(refInput, type, context, sync) {
+    const parsed = parseBundleRef(refInput);
+    const plural = type === "env" ? "env" : `${type}s`;
+    const conceptId = parsed.conceptId.startsWith(`${plural}/`) ? parsed.conceptId : `${plural}/${parsed.conceptId}`;
+    const name = conceptId.slice(plural.length + 1);
+    const direct = parsed.bundle ? configuredOwner(parsed.bundle, context.config) : undefined;
+    const sources = resolveSourceEntries(undefined, context.config);
+    const installations = deriveInstallations(sources);
+    const candidates = direct
+        ? [direct]
+        : sources.flatMap((source, index) => {
+            const installation = installations[index];
+            if (!installation || (parsed.bundle && installation.id !== parsed.bundle))
+                return [];
+            return [
+                {
+                    bundle: installation.id,
+                    root: source.path,
+                    adapter: source.adapterId ?? installation.components[0]?.adapter ?? "akm",
+                },
+            ];
+        });
+    const findSync = () => {
+        for (const candidate of candidates) {
+            const directory = path.join(candidate.root, plural);
+            for (const extension of assetExtensions(type)) {
+                const file = path.resolve(directory, `${name}${extension}`);
+                if (fs.existsSync(file) && fs.statSync(file).isFile()) {
+                    return { ...candidate, ref: makeBundleRef(candidate.bundle, conceptId), file };
+                }
+            }
+        }
+        throw new UsageError(`Workflow source target ${refInput} was not found.`, "INVALID_FLAG_VALUE");
+    };
+    if (sync)
+        return findSync();
+    return (async () => {
+        for (const candidate of candidates) {
+            try {
+                const file = await resolveAssetPath(candidate.root, type, name);
+                return { ...candidate, ref: makeBundleRef(candidate.bundle, conceptId), file };
+            }
+            catch {
+                // Continue in installation priority order.
+            }
+        }
+        return findSync();
+    })();
+}
+function configuredOwner(bundle, config) {
+    const entry = config.bundles?.[bundle];
+    if (!entry || typeof entry.path !== "string")
+        return undefined;
+    const components = entry.components ? Object.values(entry.components) : [];
+    const component = components[0];
+    return {
+        bundle,
+        root: path.resolve(entry.path, component?.root ?? "."),
+        adapter: component?.adapter ?? "akm",
+    };
+}
+function assetExtensions(type) {
+    if (type === "script")
+        return [
+            "",
+            ".sh",
+            ".ts",
+            ".js",
+            ".py",
+            ".rb",
+            ".go",
+            ".pl",
+            ".php",
+            ".lua",
+            ".r",
+            ".swift",
+            ".kt",
+            ".kts",
+            ".ps1",
+            ".cmd",
+            ".bat",
+        ];
+    if (type === "env")
+        return ["", ".env"];
+    return ["", ".md", ".yml"];
+}
+function captureOwned(owned, collector) {
+    trackAncestry(collector, owned.root, owned.file);
+    const retained = collector.capture(owned.file, owned.root, { authored: true });
+    return collector.bindIdentity(owned.file, owned.root, {
+        ref: owned.ref,
+        bundle: owned.bundle,
+        adapter: owned.adapter,
+        file: retained.relativePath,
+        hash: retained.sha256,
+    });
+}
+function trackAncestry(collector, rootInput, file) {
+    const root = path.resolve(rootInput);
+    collector.trackDirectory(root, root);
+    const relative = path.relative(root, path.dirname(file));
+    if (relative.startsWith("..") || path.isAbsolute(relative)) {
+        throw new UsageError(`${file} resolves outside its owning root.`, "PATH_ESCAPE_VIOLATION");
+    }
+    let current = root;
+    for (const segment of relative === "" ? [] : relative.split(path.sep)) {
+        current = path.join(current, segment);
+        collector.trackDirectory(current, root);
+    }
+}
+function qualifyRef(ref, plural, asset, config) {
+    const parsed = parseBundleRef(ref);
+    if (parsed.bundle)
+        return ref;
+    const bundle = parseBundleRef(asset.ref).bundle ?? config.defaultBundle;
+    if (!bundle)
+        throw new UsageError(`Workflow ref ${ref} has no owning bundle.`, "INVALID_FLAG_VALUE");
+    const concept = parsed.conceptId.startsWith(`${plural}/`) ? parsed.conceptId : `${plural}/${parsed.conceptId}`;
+    return makeBundleRef(bundle, concept);
+}
+function scriptExecutable(interpreter) {
+    if (interpreter === "bun" || interpreter === "bun-standalone")
+        return process.execPath;
+    if (interpreter === "kotlin")
+        return "kotlin";
+    return interpreter;
+}
+function gitIdentity(unit, root) {
+    if (unit.isolation !== "worktree")
+        return {};
+    const result = spawnSync("git", ["-C", root, "rev-parse", "HEAD"], { encoding: "utf8" });
+    const oid = result.status === 0 ? result.stdout.trim() : "";
+    if (!/^(?:[0-9a-f]{40}|[0-9a-f]{64})$/.test(oid)) {
+        throw new UsageError(`Worktree-isolated workflow root ${root} has no immutable Git HEAD OID.`, "INVALID_FLAG_VALUE");
+    }
+    return { gitCommitOid: oid };
+}

package/dist/workflows/parser.js

@@ -62,7 +62,7 @@ const DEFAULTS_KEYS = ["engine", "model", "timeout", "on_error", "llm"];
 const BUDGET_KEYS = ["max_tokens", "max_units"];
 const STEP_KEYS = ["id", "unit", "map", "route", "inputs", "output", "gate"];
 const UNIT_KEYS = ["exec", "engine", "model", "llm", "timeout", "retry", "on_error", "output", "env", "isolation"];
-const EXEC_KEYS = ["command", "cwd", "pass_env", "inherit_env"];
+const EXEC_KEYS = ["command", "cwd", "pass_env"];
 /** Unit keys that name an ENGINE dispatch and therefore cannot appear beside `exec:`. */
 const UNIT_ENGINE_KEYS = ["engine", "model", "llm"];
 const MAP_KEYS = ["over", "concurrency", "reducer", "unit"];
@@ -74,19 +74,6 @@ const ACTOR_STAMP_KEYS = ["by", "at"];
 const TIMEOUT_VALUE = /^(\d+)(ms|s|m)?$/;
 const TIMEOUT_HINT = `Use "<n>ms", "<n>s", "<n>m" (e.g. "10m"), or "none"`;
 const LIFECYCLE_STATUSES = new Set(["draft", "stable", "deprecated"]);
-/**
- * Cheap structural probe retained ONLY for callers that still need a fast
- * "is this workflow-shaped" content check without touching the filesystem's
- * directory. Recognition itself no longer sniffs content (spec §2.5) — this
- * is a best-effort convenience for content-only contexts (e.g. a proposal
- * whose ref carries no path). It looks for `type: workflow` in frontmatter.
- */
-export function looksLikeWorkflow(raw) {
-    const fmBlock = parseFrontmatterBlock(raw);
-    if (!fmBlock)
-        return false;
-    return /^type:\s*['"]?workflow['"]?\s*(#.*)?$/m.test(fmBlock.frontmatter);
-}
 export function parseWorkflow(markdown, source) {
     if (utf8Bytes(markdown) > WORKFLOW_MAX_SOURCE_BYTES) {
         return {
@@ -155,6 +142,7 @@ export function parseWorkflow(markdown, source) {
     const ctx = {
         filePath: path,
         errors,
+        ...(source.validateExecCwd ? { validateExecCwd: source.validateExecCwd } : {}),
         lineAt,
         lineAtOffset: (offset) => Math.max(1, lineCounter.linePos(offset).line + lineOffset),
         nodeAt: (p) => (p.length === 0 ? doc.contents : doc.getIn(p, true)),
@@ -700,15 +688,6 @@ function parseExec(ctx, raw, path, stepLabel) {
     const passEnv = parseExecPassEnv(ctx, raw.pass_env, [...path, "pass_env"], stepLabel);
     if (passEnv !== undefined)
         exec.passEnv = passEnv;
-    if (raw.inherit_env !== undefined) {
-        if (typeof raw.inherit_env !== "boolean") {
-            ctx.err([...path, "inherit_env"], `${stepLabel} "exec.inherit_env" must be true or false. true gives the command akm's whole environment ` +
-                `instead of the default allowlist; omit it (or write false) to keep the allowlist.`);
-        }
-        else if (raw.inherit_env) {
-            exec.inheritEnv = true;
-        }
-    }
     return exec;
 }
 /**
@@ -726,7 +705,7 @@ function parseExecPassEnv(ctx, raw, path, stepLabel) {
     }
     if (raw.length > WORKFLOW_MAX_EXEC_PASS_ENV) {
         ctx.err(path, `${stepLabel} "exec.pass_env" must have at most ${WORKFLOW_MAX_EXEC_PASS_ENV} entries. A command needing ` +
-            `more than that wants "inherit_env: true", which says so explicitly.`);
+            `more than that should use explicit named "env:" bindings instead.`);
         return undefined;
     }
     const names = [];
@@ -761,6 +740,10 @@ function parseExecCommand(ctx, raw, path, stepLabel) {
             ctx.err(path, `${stepLabel} "exec.command[${index}]" must be a non-empty string.`);
             return undefined;
         }
+        if (entry.includes("\0")) {
+            ctx.err([...path, index], `${stepLabel} "exec.command[${index}]" may not contain NUL bytes.`);
+            return undefined;
+        }
         if (utf8Bytes(entry) > WORKFLOW_MAX_EXEC_ARG_BYTES) {
             ctx.err(path, `${stepLabel} "exec.command[${index}]" exceeds ${WORKFLOW_MAX_EXEC_ARG_BYTES} bytes.`);
             return undefined;
@@ -791,6 +774,18 @@ function parseExecCwd(ctx, raw, path, stepLabel) {
             `directory — absolute paths, Windows drive letters, "~", and ".." segments are rejected.`);
         return undefined;
     }
+    if (ctx.validateExecCwd) {
+        const semantic = ctx.validateExecCwd(value);
+        if (!semantic.ok) {
+            ctx.errors.push({
+                code: semantic.code,
+                line: ctx.lineAt(path),
+                message: semantic.message,
+            });
+            return undefined;
+        }
+        return semantic.value;
+    }
     return value;
 }
 function parseMap(ctx, raw, path, stepLabel) {
@@ -1077,6 +1072,7 @@ function parseLlmOverrides(ctx, raw, path, label) {
         "extra_params",
         "context_length",
         "enable_thinking",
+        "reasoning_effort",
     ];
     checkUnknownKeys(ctx, raw, path, keys, label);
     const result = {};
@@ -1129,6 +1125,13 @@ function parseLlmOverrides(ctx, raw, path, label) {
         else
             ctx.err([...path, "enable_thinking"], `${label}.enable_thinking must be a boolean.`);
     }
+    if (raw.reasoning_effort !== undefined) {
+        if (typeof raw.reasoning_effort === "string" && raw.reasoning_effort.trim().length > 0) {
+            result.reasoningEffort = raw.reasoning_effort;
+        }
+        else
+            ctx.err([...path, "reasoning_effort"], `${label}.reasoning_effort must be a non-empty string.`);
+    }
     return Object.keys(result).length > 0 ? result : undefined;
 }
 function parseSchemaObject(ctx, raw, path, label) {

package/dist/workflows/program/schema.js

@@ -30,7 +30,7 @@ const RETRY_REASON_SET = {
 export const PROGRAM_RETRY_REASONS = Object.keys(RETRY_REASON_SET);
 /**
  * Step ids: `[A-Za-z_][A-Za-z0-9_-]*` (also pinned in the JSON Schema) — the
- * ONE id grammar for the unified format (workflow-format-unification, spec
+ * ONE id grammar for the shared source IR (workflow-format-unification, spec
  * §2.2). This is EXACTLY the `<ident>` grammar `readIdent` accepts in
  * `program/expressions.ts` for `steps.<id>.output` references: a
  * letter/underscore first char, then letters/digits/underscores/dashes, and
@@ -70,6 +70,5 @@ export function projectExecCore(exec) {
         command: [...exec.command],
         ...(exec.cwd ? { cwd: exec.cwd } : {}),
         ...(exec.passEnv && exec.passEnv.length > 0 ? { passEnv: [...exec.passEnv] } : {}),
-        ...(exec.inheritEnv ? { inheritEnv: true } : {}),
     };
 }