akm-cli 0.10.261012-beta → 0.10.261014-beta

package/dist/commands/tasks/tasks.js

@@ -22,19 +22,22 @@ import { assetPathForName } from "../../core/asset/asset-placement.js";
 import { makeBundleRef, parseBundleRef } from "../../core/asset/asset-ref.js";
 import { conceptIdFromTypeName, isFullRefInput } from "../../core/asset/resolve-ref.js";
 import { isWithin, resolveStashDir } from "../../core/common.js";
-import { loadConfig, mutateConfig, resetConfigCache } from "../../core/config/config.js";
-import { bundleKeyForContentRoot, resolveActiveConfiguredSources, resolveConfiguredSources, } from "../../core/config/config-sources.js";
+import { defaultConnection, defaultHarness, loadConfig, mutateConfig, resetConfigCache, } from "../../core/config/config.js";
+import { bundleKeyForContentRoot, resolveConfiguredSources } from "../../core/config/config-sources.js";
 import { IMPROVE_AUTONOMY_CONFIG_KEY, isImproveAutonomyEnabled } from "../../core/config/experimental.js";
 import { ConfigError, NotFoundError, UsageError } from "../../core/errors.js";
-import { getTaskHistoryDir, getTaskLogDir } from "../../core/paths.js";
+import { getTaskLogDir } from "../../core/paths.js";
 import { warn } from "../../core/warn.js";
-import { commitWriteTargetBoundary, isWriteCapableSourceKind, prepareWriteTargetForMutation, resolveWorkingStashTarget, resolveWriteTarget, writeAssetToSource, } from "../../core/write-source.js";
-import { withEngineFallback } from "../../integrations/agent/engine-fallback.js";
+import { assertBundleNotDisabled, commitWriteTargetBoundary, isWriteCapableSourceKind, prepareWriteTargetForMutation, resolveWorkingStashTarget, resolveWriteTarget, writeAssetToSource, } from "../../core/write-source.js";
+import { deriveInstallations } from "../../indexer/installations.js";
+import { retiredEngineSelection } from "../../integrations/agent/resolution.js";
+import { resolveSourcesForOrigin } from "../../registry/origin-resolve.js";
 import { resolveAssetPath } from "../../sources/resolve.js";
 import { enabledRefsFromInstalled, schedulerEnabledRefs, setSchedulerRefEnabled } from "../../tasks/activation-config.js";
 import { backendNameForPlatform, selectBackend } from "../../tasks/backends/index.js";
 import { prepareTaskV3Execution } from "../../tasks/prepare/prepare.js";
 import { isCheckoutInvocation, resolveAkmInvocation } from "../../tasks/resolve-akm-bin.js";
+import { activeTaskSources, resolveBundleAsset } from "../../tasks/run/load-task.js";
 import { createExecutionProvenanceContext } from "../../tasks/run/provenance.js";
 import { runTask } from "../../tasks/run/run-task.js";
 import { readTaskHistory } from "../../tasks/run/task-history.js";
@@ -63,13 +66,15 @@ export async function akmTasksAdd(input, deps = {}) {
     if (!isWithin(assetPath, typeRoot)) {
         throw new UsageError(`Resolved task path escapes the stash: "${id}".`, "PATH_ESCAPE_VIOLATION");
     }
+    const engineAs = input.engine === undefined ? undefined : retiredEngineSelection(bundle.config, input.engine);
     const yaml = renderTaskYaml({
         id,
         schedule: input.schedule,
         workflow: input.workflow,
         prompt: input.prompt,
         command: input.command,
-        engine: input.engine,
+        connection: input.connection ?? (engineAs?.kind === "connection" ? engineAs.name : undefined),
+        harness: input.harness ?? (engineAs?.kind === "harness" ? engineAs.name : undefined),
         model: input.model,
         timeoutMs: input.timeoutMs,
         params: input.params,
@@ -78,7 +83,7 @@ export async function akmTasksAdd(input, deps = {}) {
         when_to_use: input.when_to_use,
         tags: input.tags,
     });
-    const parsedTask = parseTaskSource({ yaml, filePath: assetPath, workspaceRoot: stashDir });
+    const parsedTask = parseTaskSource({ yaml, filePath: assetPath });
     const task = projectTaskSourceV4(parsedTask.v4);
     const qualifiedRef = makeBundleRef(bundle.bundleName, `tasks/${id}`);
     await prepareTaskV3Execution(task, {
@@ -152,13 +157,17 @@ function assertTaskAddTargetShape(input) {
     if (targetCount !== 1) {
         throw new UsageError("Pass exactly one of --workflow <ref>, --prompt <inline-text>, or --command <shell-command>.", "INVALID_FLAG_VALUE");
     }
-    // `--timeout-ms` is the workflow's whole-run bound. Engine and model stay
-    // prompt-only because workflow engines come from the frozen plan.
-    if (input.workflow && (input.engine !== undefined || input.model !== undefined)) {
-        throw new UsageError("Workflow tasks accept --params and --timeout-ms; engine and model are prompt-task fields.", "INVALID_FLAG_VALUE");
+    // `--timeout-ms` is the workflow's whole-run bound. Connection, harness and
+    // model stay prompt-only because a workflow's connections and harnesses come from the frozen plan.
+    const selects = input.connection !== undefined ||
+        input.harness !== undefined ||
+        input.engine !== undefined ||
+        input.model !== undefined;
+    if (input.workflow && selects) {
+        throw new UsageError("Workflow tasks accept --params and --timeout-ms; connection, harness and model are prompt-task fields.", "INVALID_FLAG_VALUE");
     }
-    if (hasCommand && (input.engine !== undefined || input.model !== undefined)) {
-        throw new UsageError("Command tasks accept --timeout-ms but not --engine or --model.", "INVALID_FLAG_VALUE");
+    if (hasCommand && selects) {
+        throw new UsageError("Command tasks accept --timeout-ms but not --connection, --harness or --model.", "INVALID_FLAG_VALUE");
     }
     if (input.prompt !== undefined)
         assertInlineTaskPrompt(input.prompt);
@@ -169,24 +178,18 @@ export async function akmTasksRun(id, options = {}) {
     const adapterId = bundle.source.adapterId ?? detectAdapterId(bundle.source.path);
     const resolvedId = taskIdForAdapter(parsed.id, adapterId);
     const scheduled = options.scheduled === true;
-    // D5 "Construction" (spec docs/plans/specs/p1b-model-extraction.md §1.2/
-    // §5.2): built ONCE at this invocation boundary. eventSource is "task"
-    // whether or not --scheduled was passed (§1.6 D5-N1) — scheduled stays a
+    // Built ONCE at this invocation boundary. eventSource is "task"
+    // whether or not --scheduled was passed — scheduled stays a
     // separate field carrying its own pre-existing meaning (activation policy,
     // scheduler env), never selecting the event source.
     const provenance = createExecutionProvenanceContext(scheduled);
-    // F-3 (spec §5.4): RunTaskOptions.stashDir renamed to bundleDir — VALUE-
-    // preserving, no CLI flag change.
-    //
-    // P2a Lane C (spec docs/plans/specs/p2a-task-source-v4.md §5.1): the raw,
-    // exact-name input flags `tasks-cli.ts`'s Stage 1 captures ride through
-    // unchanged to `runTask` -> `loadPreparedTask`'s Stage 2 materializer,
+    // The raw, exact-name input flags `tasks-cli.ts`'s Stage 1 captures ride
+    // through unchanged to `runTask` -> `loadPreparedTask`'s Stage 2 materializer,
     // which owns declaring `inputFlags` on `RunTaskOptions` and attaching the
     // materialized literals to the constructed `TaskInvocation`. This is only
-    // the pass-through surface: a valid flag set stays byte-identical to the
-    // same run without flags (§0), and P2a delivers nothing to the target.
+    // the pass-through surface.
     //
-    // No `as` cast (test-review finding, spec §6 F-5): `RunTaskOptions` (this
+    // No `as` cast: `RunTaskOptions` (this
     // literal's inferred type is checked directly against it, below) declares
     // every one of these fields, so the compiler — not a suppressed excess-
     // property check — enforces this seam. A future rename or removal on
@@ -202,11 +205,9 @@ export async function akmTasksRun(id, options = {}) {
     // The runner owns the prepare-before-reserve boundary. Invalid source,
     // projectability, and resolver failures therefore create no history row.
     const result = await runTask(resolvedId, runOptions);
-    // C-7 (spec §5.6): after D8's result-vocabulary re-code, "command" means
-    // the agent/LLM arm — the native shell/script arm now reports "shell" /
-    // "script". Rewired in the SAME commit as the vocabulary re-code so a
-    // shell/script task's process exit 78 still passes through as CLI exit 78
-    // (documented behavior, src/assets/hints/cli-hints-short.md:95).
+    // "command" means the agent/LLM arm — the native shell/script arm reports
+    // "shell" / "script" — so a shell/script task's process exit 78 still passes
+    // through as CLI exit 78 (documented behavior, src/assets/hints/cli-hints-short.md).
     const exitCode = result.status === "failed" &&
         (result.target.kind === "shell" || result.target.kind === "script") &&
         result.detail?.exitCode === 78
@@ -234,7 +235,6 @@ function resolveTaskActivation(ref, target, requireSchedulable) {
         const parsedSource = parseTaskSource({
             yaml: fs.readFileSync(sourcePath, "utf8"),
             filePath: sourcePath,
-            workspaceRoot: bundle.source.path,
         });
         if (parsedSource.v4.schedule.length === 0) {
             throw new UsageError(`Task ${JSON.stringify(ref)} has no schedule to enable.`, "INVALID_FLAG_VALUE");
@@ -361,24 +361,26 @@ async function buildSchedulerSyncPlan(deps, bundleTarget, options) {
         if (options.dryRun !== true)
             config = loadConfig();
     }
-    const activeSources = resolveActiveConfiguredSources(config);
+    // The one active-bundle set search, show and workflows walk, working stash included.
+    // A working stash that is a disabled configured bundle is left out: an
+    // unscoped sync still removes that bundle's rows (below) and syncs the others,
+    // and a scoped sync reports it as disabled only when it is the selected one.
+    const sources = activeTaskSources(config);
+    const ids = deriveInstallations(sources).map((installation) => installation.id);
+    const kinds = sources.map((source) => source.type);
+    const configuredSources = resolveConfiguredSources(config);
     if (bundleTarget) {
         // Only filesystem and git bundles can carry scheduler state.
-        const targetSource = activeSources.find((source) => source.name === bundleTarget);
-        if (targetSource && !isWriteCapableSourceKind(targetSource.type)) {
-            throw new UsageError(`Bundle "${bundleTarget}" has kind "${targetSource.type}"; task scheduling is only supported for filesystem and git bundles.`, "INVALID_FLAG_VALUE");
+        const targetType = kinds[ids.indexOf(bundleTarget)];
+        if (targetType !== undefined && !isWriteCapableSourceKind(targetType)) {
+            throw new UsageError(`Bundle "${bundleTarget}" has kind "${targetType}"; task scheduling is only supported for filesystem and git bundles.`, "INVALID_FLAG_VALUE");
         }
     }
-    const configuredSources = resolveConfiguredSources(config);
-    const schedulable = activeSources
-        .filter((source) => isWriteCapableSourceKind(source.type))
-        .map((source) => source.name);
-    // No configured bundle at all: the working stash (e.g. `AKM_BUNDLE_DIR`).
-    const selected = bundleTarget
-        ? [bundleTarget]
-        : schedulable.length > 0 || configuredSources.length > 0
-            ? schedulable
-            : [undefined];
+    const schedulable = ids.filter((_, index) => {
+        const type = kinds[index];
+        return type !== undefined && isWriteCapableSourceKind(type);
+    });
+    const selected = bundleTarget ? [bundleTarget] : schedulable;
     const enabledRefSet = new Set(enabledRefs);
     const desired = [];
     const failures = [];
@@ -591,19 +593,18 @@ export async function akmTasksDoctor(deps = {}) {
         }
     }
     const bindings = groupInstalledBindings(installed);
-    // Report the EFFECTIVE engine view — the same one the runner resolves —
-    // so doctor never says "no engine" on an install where tasks actually run.
-    const { config } = withEngineFallback(loadConfig());
-    const defaultEngine = config.defaults?.engine;
-    const engines = Object.keys(config.engines ?? {});
+    // Report the EFFECTIVE view — the default harness (else connection) agent work runs on, and what is configured.
+    const config = loadConfig();
+    const defaultEngine = (defaultHarness(config) ?? defaultConnection(config))?.name;
+    const engines = [...Object.keys(config.connections ?? {}), ...Object.keys(config.harnesses ?? {})];
     // §6.1: surface the effective triage settings for the default improve
     // strategy. The struct is a fixed shape, so this is a deliberate addition.
-    const improveStrategyName = typeof config.defaults?.improveStrategy === "string" ? config.defaults.improveStrategy : "default";
+    const improveStrategyName = config.improve?.strategy ?? "default";
     // D8 — report the EFFECTIVE strategy, not the raw one. Resolving the raw
     // strategy here would report `applyMode: "promote"` for a promote strategy
     // under a review-first config, while the run actually uses "queue" — a doctor
     // command lying about the thing it exists to diagnose.
-    const rawStrategy = resolveImproveStrategy(config.defaults?.improveStrategy, config).config;
+    const rawStrategy = resolveImproveStrategy(config.improve?.strategy, config).config;
     const { config: effectiveStrategy, gated } = applyAutonomyGate(rawStrategy, config);
     const autonomyEnabled = isImproveAutonomyEnabled(config);
     // Memory cleanup has no strategy flag to downgrade, so add that direct lane
@@ -631,7 +632,6 @@ export async function akmTasksDoctor(deps = {}) {
             ? { remediation: "akm task sync --rebind" }
             : {}),
         logDir: getTaskLogDir(),
-        historyDir: getTaskHistoryDir(),
         engine: { defaultEngine, available: engines },
         scheduleSubset: SCHEDULE_SUPPORTED_SUBSET_HINT,
         warnings,
@@ -696,17 +696,11 @@ function taskProjectionAssetResolver(config, bundleName, bundleRoot) {
         if (bundle === bundleName) {
             return { file: await resolveAssetPath(bundleRoot, type, name), bundleRoot };
         }
-        // `bundle` is the qualifier of an asset ref in the task, not a flag.
-        const target = resolveWriteTarget(config, bundle, { requireWritable: false, flag: "The asset ref's bundle" });
-        return {
-            file: await resolveAssetPath(target.source.path, type, name),
-            bundleRoot: target.source.path,
-        };
+        return resolveBundleAsset(config, { bundle, type, name });
     };
 }
 /**
- * Exported for `src/commands/tasks/explain.ts` (P2b Lane B, spec
- * docs/plans/specs/p2b-input-bindings.md §4.5, B-N4): `akm task explain`
+ * Exported for `src/commands/tasks/explain.ts`: `akm task explain`
  * resolves its `--bundle` axis identically to every other read-only task
  * verb here (`akm task history`, `akm task run`) — the SAME resolver, not a
  * second one.
@@ -722,44 +716,27 @@ export function resolveTaskReadBundle(refBundle, flagBundle) {
         resolved = resolveWorkingStashTarget(config, { requireWritable: false });
     }
     else {
-        const configured = resolveActiveConfiguredSources(config).some((source) => source.name === selector);
-        const implicit = configured ? undefined : resolveImplicitScheduledBundleTarget(config, selector);
-        resolved =
-            implicit ??
-                resolveWriteTarget(config, selector, {
-                    requireWritable: false,
-                    // The selector is `--bundle` when given, else the task ref's own bundle qualifier.
-                    flag: flagBundle !== undefined ? "--bundle" : "The task ref's bundle",
-                });
+        // Reading needs no write target: any bundle of the active set resolves.
+        const sources = activeTaskSources(config);
+        const source = resolveSourcesForOrigin(selector, sources)[0];
+        if (!source) {
+            assertBundleNotDisabled(config, selector);
+            throw new UsageError(`${flagBundle !== undefined ? "--bundle" : "The task ref's bundle"} must reference a source name from your config. No source named "${selector}" is configured. Run \`akm bundle list\` to see available sources.`, "INVALID_FLAG_VALUE");
+        }
+        resolved = {
+            source: {
+                kind: source.type ?? "filesystem",
+                name: selector,
+                path: source.path,
+                adapterId: source.adapterId ?? detectAdapterId(source.path),
+            },
+        };
     }
     if (refBundle && resolved.source.name !== refBundle) {
         throw new UsageError(`Task ref bundle ${JSON.stringify(refBundle)} does not match the resolved source.`, "INVALID_FLAG_VALUE");
     }
     return resolved;
 }
-/**
- * New scheduler bindings always carry a canonical `--bundle <owner>` token,
- * including an env-selected working stash. That stash need not be persisted in
- * config (CI, one-shot tools, and fresh installs commonly use only
- * AKM_BUNDLE_DIR), so its scheduled child — every row sets AKM_BUNDLE_DIR to
- * the working stash it was synced from — must accept precisely its derived
- * owner name.
- *
- * This is intentionally narrower than an unknown-bundle fallback: a configured
- * source always wins, and an unconfigured selector is accepted only when it is
- * exactly the current env-selected working stash identity.
- */
-function resolveImplicitScheduledBundleTarget(config, selector) {
-    if (!process.env.AKM_BUNDLE_DIR?.trim())
-        return undefined;
-    try {
-        const working = resolveWorkingStashTarget(config, { requireWritable: false });
-        return working.source.name === selector ? working : undefined;
-    }
-    catch {
-        return undefined;
-    }
-}
 /** True when `candidate` resolves to the same directory as the primary stash. */
 function isPrimaryStashPath(candidate) {
     let primary;
@@ -776,8 +753,7 @@ function errorMessage(cause) {
 }
 /**
  * Infer a JSON-Schema-subset `type` keyword from one `--params` value's
- * runtime shape (spec docs/plans/specs/p4-deletions-closeout.md §3.2.6, row
- * B-20). `null` is not one of the five runtime types the spec enumerates
+ * runtime shape. `null` is not one of the five runtime types
  * (string/number/boolean/object/array) but is a value JSON.parse can still
  * produce for a param; `src/core/json-schema.ts`'s subset validator accepts
  * `"null"` as a `type`, so it is handled rather than mis-typed.
@@ -830,8 +806,10 @@ function renderTaskYaml(input) {
         obj.when_to_use = input.when_to_use;
     if (input.tags && input.tags.length > 0)
         obj.tags = input.tags;
-    if (input.engine !== undefined)
-        obj.engine = input.engine;
+    if (input.connection !== undefined)
+        obj.connection = input.connection;
+    if (input.harness !== undefined)
+        obj.harness = input.harness;
     if (input.model !== undefined)
         obj.model = input.model;
     if (input.timeoutMs !== undefined)

package/dist/commands/ui/api.js

@@ -319,16 +319,24 @@ function config() {
         value,
         source: configSource(path),
     }));
-    const engines = Object.entries((effective.engines ?? {})).map(([name, engine]) => ({
+    const named = (entries) => Object.entries((entries ?? {})).map(([name, entry]) => ({
         name,
-        ...engine,
+        ...entry,
     }));
     const env = Object.keys(process.env)
         .filter((name) => name.startsWith("AKM_"))
         .sort()
         .map((name) => ({ name, value: isSecretEnvName(name) ? "[redacted]" : (process.env[name] ?? "") }));
     const configPath = getConfigPath();
-    return { path: configPath, exists: fs.existsSync(configPath), config: effective, entries, engines, env };
+    return {
+        path: configPath,
+        exists: fs.existsSync(configPath),
+        config: effective,
+        entries,
+        connections: named(effective.connections),
+        harnesses: named(effective.harnesses),
+        env,
+    };
 }
 // ── /api/proposals ───────────────────────────────────────────────────────────
 export function proposalSummary(proposal) {

package/dist/commands/ui/redact.js

@@ -7,41 +7,15 @@
  * anything secret-like by key name, because the UI shows config the CLI's
  * `config list` never had to defend against a browser leaking.
  *
- * Symbolic references (`$VAR`, `${VAR}`, `secret://name`) are kept: they say
+ * Symbolic references (`$VAR`, `${VAR}`, `${secrets/name}`) are kept: they say
  * where a credential comes from without being one.
  */
-const REDACTED = "[redacted]";
+import { isApiKeyReference } from "../../core/config/schema/primitives.js";
+import { REDACTED, redactUrlCredentials } from "../../core/redaction.js";
 /** Key names whose string values are credentials, or sit in a bag of them. */
 const SECRET_KEY = /(api[-_]?key|token|password|passwd|secret|credential|authorization|bearer|private[-_]?key)/i;
 /** A whole subtree of values (`env`, `secrets`) that is data, not settings. */
 const SECRET_BAG_KEY = /^(env|secrets?)$/i;
-const SYMBOLIC_REFERENCE = /^(\$[A-Za-z_][A-Za-z0-9_]*|\$\{[A-Za-z_][A-Za-z0-9_]*\}|secret:\/\/.+)$/;
-/** Query parameters that carry a credential in a URL. */
-const SECRET_QUERY_PARAM = /^(api[-_]?key|key|token|access[-_]?token|auth|password|secret|sig|signature)$/i;
-/** `scheme://user:pass@host/?token=x` with the credentials masked. Anything that is not a URL is returned as is. */
-export function redactUrlCredentials(value) {
-    if (!/^[a-z][a-z0-9+.-]*:\/\//i.test(value))
-        return value;
-    try {
-        const url = new URL(value);
-        let changed = false;
-        if (url.username || url.password) {
-            url.username = "";
-            url.password = "";
-            changed = true;
-        }
-        for (const key of [...url.searchParams.keys()]) {
-            if (SECRET_QUERY_PARAM.test(key)) {
-                url.searchParams.set(key, REDACTED);
-                changed = true;
-            }
-        }
-        return changed ? url.toString() : value;
-    }
-    catch {
-        return value;
-    }
-}
 /** `text` with the credentials in every URL it contains masked (`llm default: https://host/?token=x`). */
 export function redactUrlsInText(text) {
     return text.includes("://") ? text.replace(/https?:\/\/[^\s"'<>)\]]+/gi, (url) => redactUrlCredentials(url)) : text;
@@ -65,7 +39,7 @@ export function redactForUi(value, inSecretBag = false) {
     if (Array.isArray(value))
         return value.map((child) => redactForUi(child, inSecretBag));
     if (typeof value === "string") {
-        if (SYMBOLIC_REFERENCE.test(value))
+        if (isApiKeyReference(value))
             return value;
         return inSecretBag ? REDACTED : redactUrlCredentials(value);
     }
@@ -73,7 +47,7 @@ export function redactForUi(value, inSecretBag = false) {
         return inSecretBag && value !== null ? REDACTED : value;
     const result = {};
     for (const [key, child] of Object.entries(value)) {
-        if (typeof child === "string" && SECRET_KEY.test(key) && !SYMBOLIC_REFERENCE.test(child)) {
+        if (typeof child === "string" && SECRET_KEY.test(key) && !isApiKeyReference(child)) {
             result[key] = REDACTED;
         }
         else {

package/dist/commands/ui/workspace-actions.js

@@ -44,7 +44,7 @@ function positional(body, key) {
 }
 function preserveUnrelatedConfig(config = loadConfig()) {
     if (!isDeepStrictEqual(sanitizeConfigForWrite(config, { quiet: true }), config)) {
-        throw new UsageError("AKM's config sanitizer would remove unrelated credentials. Move literal API keys to $VAR or secret:// references and remove registry URL credentials using the CLI before changing bundle configuration in the UI.");
+        throw new UsageError("AKM's config sanitizer would remove unrelated credentials. Remove registry URL credentials using the CLI before changing bundle configuration in the UI.");
     }
 }
 /** The error kind behind each exit code of the CLI contract (`EXIT_CODES`, `src/cli/shared.ts`). */

package/dist/commands/workflow/plan.js

@@ -8,18 +8,22 @@
  * (`loadWorkflowAsset`, `freezeWorkflow`) and NOTHING else — never
  * `publishWorkflowRunV4`, `startWorkflowRun`, `appendEvent`, or `akmIndex`.
  *
- * SECRET-FREE, by construction (§4.6's closed print list): a resolved
- * reference VALUE is never printed (references resolve at pre-attempt, not
+ * SECRET-FREE, by construction (§4.6's closed print list): a step's
+ * `orchestration` is the authored argv, cwd and env names plus the
+ * bundle-qualified refs they resolve to (the projection `akm show` prints,
+ * never a value or a path); a resolved reference VALUE is never printed (references resolve at pre-attempt, not
  * here); a `literal` **environment** binding's value is never printed (only
- * `environment[].kind`/`.name`, and an `env-ref`'s `.ref`/`.keys`/
- * `.secretNames` — all NAMES); `request.command.content`,
+ * `environment[].kind`/`.name`, and an `env-ref`'s `.ref` — all NAMES);
+ * `request.command.content`,
  * `request.persona`, `request.conversation`, `request.runtime.environment`,
  * and a script target's `bytesBase64` are never read at all.
  */
 import { loadConfig } from "../../core/config/config.js";
+import { NotFoundError } from "../../core/errors.js";
 import { buildExecutionFromWire } from "../../integrations/agent/execution.js";
 import { freezeWorkflow } from "../../workflows/freeze/freeze.js";
 import { computePlanHash } from "../../workflows/ir/plan-hash.js";
+import { resolveOrchestrationRefs, summarizeStepOrchestration } from "../../workflows/renderer.js";
 import { loadWorkflowAsset } from "../../workflows/runtime/workflow-asset-loader.js";
 /** The step's dispatch unit — the map template for a fan-out, else the root unit. Undefined for a step not yet frozen. */
 function stepUnit(step) {
@@ -30,7 +34,7 @@ function stepUnit(step) {
 }
 function projectEnvironmentBinding(binding) {
     if (binding.kind === "env-ref") {
-        return { kind: binding.kind, ref: binding.ref, keys: binding.keys, secretNames: binding.secretNames };
+        return { kind: binding.kind, ref: binding.ref };
     }
     // literal / pass-through: kind + name only — a literal's VALUE is never printed.
     return { kind: binding.kind, name: binding.name };
@@ -46,14 +50,23 @@ function childExpansion(target) {
         via: "child",
         childRef: target.ref,
         childPlanHash: target.planHash,
-        steps: target.frozenPlan.steps.map((step, index) => projectStep(step, index)),
+        steps: target.frozenPlan.steps.map((step, index) => projectStep(step, index, stepOrchestration(step, target.frozenPlan))),
     };
 }
 /** The child expansion boundary for one step (§4.6). */
 function stepExpansion(frozenTarget) {
     return frozenTarget?.kind === "child-workflow" ? childExpansion(frozenTarget) : { via: "direct" };
 }
-function projectStep(step, sequenceIndex) {
+/**
+ * The step's `show` orchestration projection plus the refs it resolves to.
+ * `authored` is the compiled step (it keeps the spelling the author wrote);
+ * a child plan's steps have only their frozen form.
+ */
+function stepOrchestration(step, plan) {
+    const summary = summarizeStepOrchestration(step, plan.defaults);
+    return summary && resolveOrchestrationRefs(summary);
+}
+function projectStep(step, sequenceIndex, orchestration) {
     const unit = stepUnit(step);
     const frozenTarget = unit?.frozenTarget;
     const kind = step.root?.kind === "map" ? "map" : "unit";
@@ -65,12 +78,13 @@ function projectStep(step, sequenceIndex) {
         targetKind: frozenTarget?.kind ?? null,
         ...(step.root?.kind === "map" ? { concurrency: step.root.concurrency } : {}),
         inputs: unit?.inputs ?? [],
+        ...(orchestration ? { orchestration } : {}),
         environment: (unit?.environment ?? []).map(projectEnvironmentBinding),
         ...(inputBindings && inputBindings.length > 0 ? { inputBindings: inputBindings.map(projectInputBinding) } : {}),
         gate: {
             criteria: step.gate.criteria,
             maxLoops: step.gate.maxLoops,
-            judgeEngine: step.gate.frozenJudge ? step.gate.frozenJudge.request.engine.name : null,
+            judgeEngine: step.gate.frozenJudge ? step.gate.frozenJudge.request.target.name : null,
         },
         ...(step.outputSchema !== undefined ? { outputSchema: step.outputSchema } : {}),
         expansion: stepExpansion(frozenTarget),
@@ -102,15 +116,40 @@ function collectLoweringNotices(plan, config) {
     }
     return notices;
 }
+/** Every ref the steps' orchestration names that no bundle owns, as `ref (where of step "id")`. */
+function unresolvedRefs(steps, orchestrations) {
+    return orchestrations.flatMap((orchestration, index) => (orchestration?.unresolved ?? []).map((missing) => `${missing.ref} (${missing.in} of step "${steps[index]?.stepId}")`));
+}
+/** The unresolved refs of every embedded child plan, recursively, each prefixed with the child workflow it is in. */
+function unresolvedInChildren(plan) {
+    return plan.steps.flatMap((step) => {
+        const target = stepUnit(step)?.frozenTarget;
+        if (target?.kind !== "child-workflow")
+            return [];
+        const child = target.frozenPlan;
+        const own = unresolvedRefs(child.steps, child.steps.map((childStep) => stepOrchestration(childStep, child)));
+        return [...own.map((entry) => `${entry} in child ${target.ref}`), ...unresolvedInChildren(child)];
+    });
+}
+function failOnUnresolved(ref, unresolved) {
+    if (unresolved.length === 0)
+        return;
+    throw new NotFoundError(`Workflow ${ref} names asset(s) that no bundle owns: ${unresolved.join(", ")}.`, "FILE_NOT_FOUND");
+}
 /**
  * Compile + freeze `ref` and project the frozen plan into the read-only
  * `akm workflow plan` envelope. Never publishes, never writes, never warns.
  */
 export async function akmWorkflowPlan(ref) {
     const asset = await loadWorkflowAsset(ref);
+    // Resolve what the authored steps name before freezing: a `${ref}`, env ref or child workflow no bundle owns fails the plan.
+    const orchestrations = asset.plan.steps.map((step) => stepOrchestration(step, asset.plan));
+    failOnUnresolved(asset.ref, unresolvedRefs(asset.plan.steps, orchestrations));
     const config = loadConfig();
     const frozen = await freezeWorkflow(asset, config);
     const plan = frozen.plan;
+    // A child workflow's steps exist only once frozen; they fail the plan exactly as the top level's do.
+    failOnUnresolved(asset.ref, unresolvedInChildren(plan));
     return {
         ok: true,
         ref: asset.ref,
@@ -123,7 +162,7 @@ export async function akmWorkflowPlan(ref) {
         execution: plan.execution,
         ...(plan.budget ? { budget: plan.budget } : {}),
         ...(plan.params ? { params: plan.params } : {}),
-        steps: plan.steps.map((step, index) => projectStep(step, index)),
+        steps: plan.steps.map((step, index) => projectStep(step, index, orchestrations[index])),
         notices: collectLoweringNotices(plan, config),
         warnings: frozen.warnings.map((warning) => warning.message),
     };