akm-cli 0.10.261012-beta → 0.10.261013-beta

package/dist/workflows/exec/native-executor.js

@@ -23,13 +23,16 @@
  *  - Run `budget` ceilings are consumed per actual dispatch and abort the step
  *    when crossed, regardless of `on_error`.
  */
-import { appendEvent } from "../../core/events.js";
+import { resolveRefToken } from "../../commands/env/env-binding.js";
+import { isInstalledBundle } from "../../core/env-secret-ref.js";
+import { NotFoundError } from "../../core/errors.js";
 import { validateJsonSchemaSubset } from "../../core/json-schema.js";
+import { substituteRefTokens } from "../../core/ref-token.js";
 import { runStructured } from "../../core/structured.js";
 import { warn } from "../../core/warn.js";
-import { assertFrozenDirectoryContained } from "../../execution/directory-identity.js";
 import { withWorkflowRunsConnection, withWorkflowRunsRepo, } from "../../storage/repositories/workflow-runs-repository.js";
 import { WORKFLOW_UNIT_DIAGNOSTIC_CLIP } from "../resource-limits.js";
+import { resolveRunBundleRoot } from "../runtime/workflow-asset-loader.js";
 // The ONE child-workflow drive — publishes and drives a
 // `child-workflow`-targeted unit; this module's dispatch seam is its only
 // production caller.
@@ -167,22 +170,28 @@ function openDispatchBudget(ctx, dispatched) {
 }
 /** Resolve the live-at-dispatch prerequisites once, after durable-row reuse is known. */
 async function prepareStepDispatchPrerequisites(input) {
-    const { plan, workUnits, willDispatch, dispatched } = input;
+    const { plan, ctx, workUnits, willDispatch, dispatched } = input;
     let env;
     let sensitiveValues;
+    // The run's bundle is found again here, never frozen: a bundle update moves it to a new directory.
+    let cwd = ctx.bundleRootOverride;
+    if (willDispatch && cwd === undefined) {
+        try {
+            cwd = resolveRunBundleRoot(ctx.workflowRef);
+        }
+        catch (err) {
+            return {
+                ok: false,
+                result: failedStep(dispatched, `Step "${plan.stepId}" cannot run: ${message(err).replace(/\.$/, "")}.`),
+            };
+        }
+    }
     const frozenEnvironment = workUnits[0]?.environment;
     if (willDispatch && frozenEnvironment && frozenEnvironment.length > 0) {
         try {
             const materialized = materializeFrozenWorkflowEnvironment(frozenEnvironment);
             env = materialized.values;
             sensitiveValues = materialized.sensitiveValues;
-            for (const audit of materialized.audits) {
-                appendEvent({
-                    eventType: audit.eventType,
-                    ref: audit.ref,
-                    metadata: { keys: audit.keys, secretNames: audit.secretNames },
-                });
-            }
         }
         catch (err) {
             return {
@@ -193,6 +202,7 @@ async function prepareStepDispatchPrerequisites(input) {
     }
     return {
         ok: true,
+        ...(cwd !== undefined ? { cwd } : {}),
         ...(env ? { env } : {}),
         ...(sensitiveValues ? { sensitiveValues } : {}),
     };
@@ -229,13 +239,14 @@ async function executeStepPlanInConnection(plan, ctx) {
     const willDispatch = reuseDecisions.some((decision) => decision.kind === "dispatch");
     const prerequisites = await prepareStepDispatchPrerequisites({
         plan,
+        ctx,
         workUnits,
         willDispatch,
         dispatched,
     });
     if (!prerequisites.ok)
         return prerequisites.result;
-    const { env, sensitiveValues } = prerequisites;
+    const { cwd, env, sensitiveValues } = prerequisites;
     // Budget ceilings + lifetime-cap accounting, and the budget-chained abort
     // signal they trip. Extracted verbatim (behavior-identical) — see
     // {@link openDispatchBudget}.
@@ -246,6 +257,7 @@ async function executeStepPlanInConnection(plan, ctx) {
         outcomes = await scheduleUnits(workUnits, (workUnit, index) => runUnit({
             plan,
             workUnit,
+            cwd,
             env,
             sensitiveValues,
             ctx,
@@ -299,7 +311,7 @@ async function executeStepPlanInConnection(plan, ctx) {
     };
 }
 async function runUnit(input) {
-    const { plan, workUnit, env, sensitiveValues, ctx, dispatcher } = input;
+    const { plan, workUnit, cwd, env, sensitiveValues, ctx, dispatcher } = input;
     const unitId = workUnit.unitId;
     // Target validity is a WHOLE-LIST invariant, never a per-unit condition:
     // computeStepWorkList rejects a step before building any unit when its sole
@@ -317,10 +329,7 @@ async function runUnit(input) {
         prompt,
         frozenTarget: workUnit.frozenTarget,
         ...(workUnit.execContext ? { execContext: workUnit.execContext } : {}),
-        // An exec unit spawns in the engine invocation's working directory. Only
-        // exec units get it: handing an agent unit a cwd it never had would change
-        // harness behavior, and the agent path already takes its cwd from its profile.
-        ...(workUnit.frozenTarget.kind !== "command" && ctx.workDir !== undefined ? { cwd: ctx.workDir } : {}),
+        ...(cwd !== undefined ? { cwd } : {}),
         timeoutMs: workUnit.timeoutMs,
         ...(workUnit.schema ? { schema: workUnit.schema } : {}),
         ...(env ? { env } : {}),
@@ -498,6 +507,7 @@ async function dispatchJournaledAttempt(input) {
     };
     // A child-workflow unit goes to the child executor instead of the
     // dispatcher, after its attempt row is reserved, so it journals like any unit.
+    const resolvedSecrets = new Set();
     const dispatched = request.frozenTarget.kind === "child-workflow"
         ? await driveChildWorkflowUnit({
             request,
@@ -507,17 +517,18 @@ async function dispatchJournaledAttempt(input) {
             inputHash: input.inputHash,
             dispatcher,
         })
-        : await dispatchUnit(request, dispatcher);
+        : await dispatchUnit(request, dispatcher, resolvedSecrets);
     // Credential and passthrough values are intentionally sampled only AFTER
     // the default dispatcher has authorized/lowered the frozen request and
     // materialized credentials at its terminal dispatch boundary. Custom test
     // dispatchers receive the same post-dispatch journal scrub. Secret-shaped
     // run params join the set: they must reach the prompt in clear (the unit
-    // needs them), but nothing about them needs to reach the journal.
+    // needs them), but nothing about them needs to reach the journal. So do the
+    // secrets the dispatcher resolved itself (an exec unit's argv/cwd tokens).
     const sensitiveValues = collectWorkflowDispatchSensitiveValues({
         ...(request.frozenTarget.kind === "command" ? { runner: request.frozenTarget.runner } : {}),
-        sensitiveValues: [...(request.sensitiveValues ?? []), ...secretShapedParamValues(ctx.params)],
-    }, request.env);
+        sensitiveValues: [...(request.sensitiveValues ?? []), ...resolvedSecrets, ...secretShapedParamValues(ctx.params)],
+    });
     const outcome = redactUnitOutcome(dispatched, sensitiveValues);
     const finishedAt = new Date().toISOString();
     // A dispatched unit's outcome is NEVER silently discarded: the attempt is
@@ -589,7 +600,9 @@ class UnitTransportError extends Error {
         this.name = "UnitTransportError";
     }
 }
-async function dispatchUnit(request, dispatcher) {
+async function dispatchUnit(request, dispatcher, 
+/** Receives the secret values the dispatcher resolved, for the caller's journal scrub. */
+resolvedSecrets) {
     let tokens = 0;
     let sawUsage = false;
     let loweringNotices;
@@ -600,6 +613,8 @@ async function dispatchUnit(request, dispatcher) {
     let sessionId;
     const dispatchOnce = async (feedback) => {
         const result = await dispatcher(request, feedback);
+        for (const value of result.sensitiveValues ?? [])
+            resolvedSecrets.add(value);
         if (result.usage) {
             sawUsage = true;
             tokens +=
@@ -700,12 +715,14 @@ async function dispatchUnit(request, dispatcher) {
 export const defaultUnitDispatcher = async (request, feedback) => {
     const frozenTarget = request.frozenTarget;
     if (frozenTarget.kind === "shell") {
-        if (frozenTarget.cwdIdentity)
-            assertFrozenDirectoryContained(frozenTarget.cwdIdentity);
-        return runExecUnit({
+        if (request.cwd === undefined) {
+            throw new Error(`exec unit "${request.unitId}" was dispatched with no working directory.`);
+        }
+        const { exec, secretValues } = substituteExecRefs(request.unitId, frozenTarget.exec);
+        const outcome = await runExecUnit({
             unitId: request.unitId,
-            exec: frozenTarget.exec,
-            baseDir: request.cwd ?? frozenTarget.cwdIdentity?.realCwd ?? process.cwd(),
+            exec,
+            baseDir: request.cwd,
             ...(request.env ? { env: request.env } : {}),
             ...(request.execContext ? { context: request.execContext } : {}),
             ...(request.schema ? { hasOutputSchema: true } : {}),
@@ -713,9 +730,36 @@ export const defaultUnitDispatcher = async (request, feedback) => {
             ...(request.signal ? { signal: request.signal } : {}),
             ...(request.eventSource !== undefined ? { eventSource: request.eventSource } : {}),
         });
+        // A secret substituted into argv joins the redaction set, like one bound through an env asset: the
+        // executor scrubs after the structured parse, so a quoted or numeric secret is not missed or corrupted.
+        return { ...outcome, sensitiveValues: secretValues };
     }
     return dispatchWorkflowExecution(request, feedback);
 };
+/**
+ * Replace the `${ref}` tokens in an exec unit's argv and `cwd` (prompts are not substituted): a
+ * `secrets/` ref with the secret's value, any other asset ref with its absolute path. A ref no
+ * bundle owns fails the unit before anything is spawned.
+ */
+function substituteExecRefs(unitId, exec) {
+    const slots = Object.fromEntries(exec.command.entries());
+    if (exec.cwd !== undefined)
+        slots.cwd = exec.cwd;
+    const { values, missing, secretValues } = substituteRefTokens(slots, resolveRefToken, isInstalledBundle);
+    if (missing.length > 0) {
+        throw new NotFoundError(`exec unit "${unitId}" references asset(s) that no bundle owns: ${missing.join(", ")}. Nothing was run.`, "FILE_NOT_FOUND", 
+        // biome-ignore lint/suspicious/noTemplateCurlyInString: literal `${ref}` token syntax documented for users, not interpolation
+        "Write each `${ref}` as a full akm ref that exists, e.g. `${team//scripts/run.sh}`.");
+    }
+    return {
+        exec: {
+            ...exec,
+            command: exec.command.map((_, index) => values[index]),
+            ...(exec.cwd !== undefined ? { cwd: values.cwd } : {}),
+        },
+        secretValues,
+    };
+}
 // ── Small helpers ────────────────────────────────────────────────────────────
 /**
  * Rehydrate a journaled completed unit row into a UnitOutcome (durable-row

package/dist/workflows/exec/run-workflow.js

@@ -14,16 +14,16 @@ import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { TransientError, UsageError } from "../../core/errors.js";
-import { releaseLock } from "../../core/file-lock.js";
+import { probeLock, releaseLock } from "../../core/file-lock.js";
 import { formatLockHolderPid, tryAcquireRunLock } from "../../core/run-lock.js";
 import { disposeDispatchResources } from "../../integrations/agent/runner-dispatch.js";
 import { resolveStorageLocations } from "../../storage/locations.js";
 import { withWorkflowRunsConnection, withWorkflowRunsRepo } from "../../storage/repositories/workflow-runs-repository.js";
 import { computePlanHash } from "../ir/plan-hash.js";
 import { decodeWorkflowPlan, readRunPlan } from "../runtime/run-plan.js";
-import { abandonWorkflowRun, getNextWorkflowStep, resumeWorkflowRun } from "../runtime/runs.js";
+import { abandonWorkflowRun, getNextWorkflowStep, listWorkflowRuns, resolveWorkflowRunTarget, resumeWorkflowRun, } from "../runtime/runs.js";
 import { loadWorkflowAsset } from "../runtime/workflow-asset-loader.js";
-import { frozenSummaryJudge } from "./frozen-judge.js";
+import { frozenSummaryJudge, resolveJudgeCwd } from "./frozen-judge.js";
 import { mergeLoweringNotices } from "./lowering-notices.js";
 import { defaultUnitDispatcher, executeStepPlan, } from "./native-executor.js";
 // Shared step semantics — gate-evaluation journaling, and the whole step-completion path
@@ -34,10 +34,6 @@ export async function runWorkflowSteps(options) {
     let target = options.target;
     let params = options.params;
     let parameterFlags = options.parameterFlags;
-    // `--new` only applies to the FIRST resolution of `target` (a ref); every
-    // retry re-targets the run id `startWorkflowRun` already created, so it is
-    // cleared alongside `params`/`parameterFlags` below (#919).
-    let newRun = options.newRun;
     let remainingRetries = options.maxRetries ?? 0;
     let remainingSteps = options.maxSteps;
     const executed = [];
@@ -53,7 +49,6 @@ export async function runWorkflowSteps(options) {
             target,
             ...(params !== undefined ? { params } : { params: undefined }),
             ...(parameterFlags !== undefined ? { parameterFlags } : { parameterFlags: undefined }),
-            newRun,
             ...(remainingSteps !== undefined ? { maxSteps: remainingSteps } : { maxSteps: undefined }),
         }, liveEvidence);
         executed.push(...result.executed);
@@ -81,14 +76,12 @@ export async function runWorkflowSteps(options) {
         target = result.run.id;
         params = undefined;
         parameterFlags = undefined;
-        newRun = undefined;
         remainingRetries -= 1;
     }
 }
 async function runWorkflowAttempt(options, liveEvidence) {
     const next = await getNextWorkflowStep(options.target, options.params, {
         parameterFlags: options.parameterFlags,
-        newRun: options.newRun,
     });
     // Refuse non-active runs BEFORE any dispatch — completeWorkflowStep would
     // reject the completion anyway, but only after the units already ran (and
@@ -125,7 +118,6 @@ async function runWorkflowAttempt(options, liveEvidence) {
                     executed: [],
                     stepsProcessed: 0,
                     warnings: [...warnings, message],
-                    ...(next.resumed ? { resumed: true } : {}),
                 };
             }
             plan = read.plan;
@@ -141,11 +133,10 @@ async function runWorkflowAttempt(options, liveEvidence) {
         // Creation/resume-time notices reach the caller only here: the run row
         // has no warnings column, and a later invocation of the same run must
         // stay silent about a decision it did not make. `driveRun` never sets
-        // `warnings` or `resumed` — both are properties of THIS resolution of
-        // `target`, not of the run row (#919).
+        // `warnings` — it is a property of THIS resolution of `target`, not of
+        // the run row.
         return {
             ...result,
-            ...(next.resumed ? { resumed: true } : {}),
             ...(warnings.length > 0 ? { warnings } : {}),
         };
     }
@@ -172,6 +163,27 @@ async function runWorkflowAttempt(options, liveEvidence) {
 export function workflowRunLockPath(runId) {
     return path.join(path.dirname(resolveStorageLocations().stateDb), "workflow-run-locks", `${runId}.lock`);
 }
+/**
+ * `--skip-if-locked` for a workflow REF (#1239): an active run of `ref` whose
+ * lock a live process holds, or `undefined`. A run id (which drives that one
+ * run, and fails with `RUN_LEASE_HELD` if it is held) is never a ref. Read-only:
+ * `probeLock` reports a dead holder as stale without reclaiming it.
+ */
+export async function findLiveLockedRunOfRef(target) {
+    if ((await resolveWorkflowRunTarget(target)) !== undefined)
+        return undefined;
+    const { runs } = await listWorkflowRuns({ workflowRef: target, activeOnly: true });
+    for (const run of runs) {
+        const probe = probeLock(workflowRunLockPath(run.id));
+        if (probe.state === "held") {
+            return {
+                runId: run.id,
+                holder: formatLockHolderPid({ pid: probe.holderPid, launcherPid: probe.launcherPid ?? null }),
+            };
+        }
+    }
+    return undefined;
+}
 /**
  * Take the run's O_EXCL lock file, or refuse with `RUN_LEASE_HELD` (exit 75)
  * naming the live holder. A lock whose holder pid is dead is reclaimed by
@@ -215,7 +227,7 @@ async function workflowSourceDriftWarning(runId, workflowRef, plan) {
     if (current === plan.sourceHash)
         return undefined;
     return (`Workflow run ${runId}: ${workflowRef} (${sourcePath}) has changed since this run was frozen; ` +
-        `continuing with the frozen plan. Start a new run with 'akm workflow run ${workflowRef} --new' to pick up the edit.`);
+        `continuing with the frozen plan. Start a new run with 'akm workflow run ${workflowRef}' to pick up the edit.`);
 }
 /**
  * A terminal run is a pure no-op: do not load or integrity-check its frozen
@@ -230,11 +242,11 @@ async function completedRunResult(runId) {
         ...(doneState.run.status === "completed" ? { done: true } : {}),
     };
 }
-function workflowSummaryJudge(options, stepPlan, signal, owner) {
+function workflowSummaryJudge(options, stepPlan, signal, owner, workflowRef) {
     if (options.summaryJudge !== undefined)
         return options.summaryJudge;
     // The judge dispatches under the real run/step identity and the same event source as units.
-    return frozenSummaryJudge(stepPlan.gate.frozenJudge, signal, options.dispatcher ?? defaultUnitDispatcher, owner, options.eventSource);
+    return frozenSummaryJudge(stepPlan.gate.frozenJudge, signal, options.dispatcher ?? defaultUnitDispatcher, owner, options.eventSource, options.bundleRootOverride ?? resolveJudgeCwd(stepPlan.gate.frozenJudge, workflowRef));
 }
 /**
  * Seed the run's budget from the append-only attempt journal so a resumed run
@@ -307,6 +319,7 @@ async function executeStepSubgraph(ctx, loop) {
         ...(options.eventSource !== undefined ? { eventSource: options.eventSource } : {}),
         ...(options.signal ? { signal: options.signal } : {}),
         ...(options.dispatcher ? { dispatcher: options.dispatcher } : {}),
+        ...(options.bundleRootOverride !== undefined ? { bundleRootOverride: options.bundleRootOverride } : {}),
         maxConcurrency: Math.min(options.maxConcurrency ?? Number.POSITIVE_INFINITY, plan.execution?.maxConcurrency ?? 1),
     });
 }
@@ -493,7 +506,7 @@ liveEvidence) {
             summaryJudge = workflowSummaryJudge(options, stepPlan, options.signal, {
                 runId: next.run.id,
                 stepId: step.id,
-            });
+            }, next.run.workflowRef);
         }
         catch (error) {
             const detail = error instanceof Error && error.message ? ` (${error.message})` : "";

package/dist/workflows/exec/step-work.js

@@ -837,8 +837,8 @@ function judgeFailureNotes(runId, stepId, cause) {
     return (`Step "${stepId}" could not be verified: ${cause}. ` +
         `This is a verification-judge failure, not a verdict — no gate loop was consumed and the step's ` +
         `journaled units are preserved. Fix the verifier configuration or service, then run ` +
-        `\`akm workflow resume ${runId}\` to re-evaluate the gate against the existing results ` +
-        `without re-dispatching units.`);
+        `\`akm workflow resume ${runId}\` and \`akm workflow run ${runId}\` to re-evaluate the gate ` +
+        `against the existing results without re-dispatching units.`);
 }
 /**
  * Complete a step `blocked` for a verifier-INFRASTRUCTURE failure and return
@@ -1059,7 +1059,8 @@ export async function finalizeExecutedStep(input) {
     }
     // Judge infrastructure failure: the fail-closed rejection is synthetic, not a
     // verdict. Consume NO gate loop; block the step (and therefore the run) so
-    // `akm workflow resume` retries the gate over the journaled units.
+    // `akm workflow resume` then `akm workflow run` retries the gate over the
+    // journaled units.
     if (rejection && judgeFailed) {
         return blockFinalizedStep(input, judgeFailure ?? "the verification judge failed");
     }

package/dist/workflows/exec/unit-dispatch.js

@@ -2,24 +2,17 @@
 // 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 { ConfigError } from "../../core/errors.js";
-import { assertFrozenDirectoryContained } from "../../execution/directory-identity.js";
 import { canonicalResolvedExecutionRequest } from "../../execution/resolved-request.js";
 import { buildExecutionFromWire } from "../../integrations/agent/execution.js";
 import { runExecution, unwrapHarnessReply } from "../../integrations/agent/runner-dispatch.js";
 /** Lower a frozen common request through its frozen runner only. */
 export function prepareWorkflowExecution(request, prompt = request.prompt) {
     const target = request.frozenTarget;
-    if (target.cwdIdentity)
-        assertFrozenDirectoryContained(target.cwdIdentity);
     const wire = JSON.parse(canonicalResolvedExecutionRequest(target.request));
     const command = { ...wire.command, content: prompt };
     const runtime = {
         ...wire.runtime,
-        ...(request.cwd !== undefined
-            ? { workspace: request.cwd }
-            : target.cwdIdentity
-                ? { workspace: target.cwdIdentity.realCwd }
-                : {}),
+        ...(request.cwd !== undefined ? { workspace: request.cwd } : {}),
         ...(request.env !== undefined ? { environment: request.env } : {}),
     };
     wire.command = command;

package/dist/workflows/freeze/environment.js

@@ -1,140 +1,35 @@
 // 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 fs from "node:fs";
-import path from "node:path";
-import dotenv from "dotenv";
-import { loadAdapterExecutionSource } from "../../commands/command/execution-source-loader.js";
 import { makeBundleRef, parseBundleRef } from "../../core/asset/asset-ref.js";
-import { compareCodePoints, isWithin, toPosix } from "../../core/common.js";
 import { parseEnvRef } from "../../core/env-secret-ref.js";
 import { UsageError } from "../../core/errors.js";
-import { deriveInstallations } from "../../indexer/installations.js";
+import { resolveConceptOwner } from "../../indexer/lookup/adapter-concept-owner.js";
 import { resolveSourceEntries } from "../../indexer/search/search-source.js";
-import { resolveAssetPath } from "../../sources/resolve.js";
-import { SECRET_TOKEN_RE } from "../exec/environment.js";
 /**
- * A step's frozen environment: `pass_env` names, then
- * one value-free descriptor per `unit.env` ref (owner, key set, secret-token
- * names). Values are read at dispatch (`exec/environment.ts`), never frozen.
+ * A step's frozen environment: `pass_env` names, then one bundle-qualified
+ * ref per `unit.env` entry. The env file, its keys and the secrets it names
+ * are read at dispatch (`exec/environment.ts`), never frozen.
  */
 export function freezeEnvironment(source, exec, context) {
     const passThrough = (exec?.passEnv ?? []).map((name) => Object.freeze({ kind: "pass-through", name }));
     const seen = new Set();
     const envRefs = [];
     for (const [precedence, ref] of (source.unit?.env ?? []).entries()) {
-        if (parseEnvRef(ref).type !== "env") {
-            throw new UsageError(`Expected an env ref; got ${ref}.`, "WORKFLOW_SOURCE_INVALID");
-        }
-        const owned = resolveOwnedAssetSync(ref, "env", context);
-        if (seen.has(owned.ref))
+        parseEnvRef(ref);
+        const qualified = qualifyEnvRef(ref, context);
+        if (seen.has(qualified))
             continue;
-        seen.add(owned.ref);
-        const parsed = dotenv.parse(fs.readFileSync(owned.file));
-        const secretNames = new Set();
-        for (const value of Object.values(parsed)) {
-            for (const match of value.matchAll(SECRET_TOKEN_RE))
-                if (match[1])
-                    secretNames.add(match[1]);
-        }
-        envRefs.push(Object.freeze({
-            kind: "env-ref",
-            ref: owned.ref,
-            owner: Object.freeze({
-                bundle: owned.bundle,
-                adapter: owned.adapter,
-                requestedRoot: owned.root,
-                requestedPath: owned.file,
-                relativePath: toPosix(path.relative(owned.root, owned.file)),
-            }),
-            keys: Object.keys(parsed).sort(compareCodePoints),
-            secretNames: [...secretNames].sort(compareCodePoints),
-            precedence,
-        }));
+        seen.add(qualified);
+        envRefs.push(Object.freeze({ kind: "env-ref", ref: qualified, precedence }));
     }
     return [...passThrough, ...envRefs];
 }
-/** Load a command or persona the workflow names, resolved through the workflow's own bundles. */
-export async function workflowExecutionSource(ref, kind, context) {
-    const owned = await resolveOwnedAsset(ref, kind === "command" ? "command" : "agent", context);
-    return kind === "command"
-        ? loadAdapterExecutionSource(owned.ref, "command", { config: context.config })
-        : loadAdapterExecutionSource(owned.ref, "persona", { config: context.config });
-}
-export async function resolveOwnedAsset(ref, type, context) {
-    return resolveOwnedAssetCore(ref, type, context, false);
-}
-export function resolveOwnedAssetSync(ref, type, context) {
-    return resolveOwnedAssetCore(ref, type, context, true);
-}
-function resolveOwnedAssetCore(refInput, type, context, sync) {
+/** Qualify an env ref a step names with the bundle that owns it right now, through the one walk. */
+function qualifyEnvRef(refInput, context) {
     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 candidates = direct ? [direct] : installedOwners(parsed.bundle, context.config);
-    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()) {
-                    if (!isWithin(file, candidate.root)) {
-                        throw new UsageError(`${file} resolves outside its owning root.`, "PATH_ESCAPE_VIOLATION");
-                    }
-                    return { ...candidate, ref: makeBundleRef(candidate.bundle, conceptId), file };
-                }
-            }
-        }
+    const match = resolveConceptOwner({ bundle: parsed.bundle, conceptId: parsed.conceptId }, resolveSourceEntries(undefined, context.config), { includeSensitive: true });
+    if (!match)
         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();
-    })();
-}
-/** Every installed bundle root (or just `bundle`'s), in installation priority order. */
-function installedOwners(bundle, config) {
-    const sources = resolveSourceEntries(undefined, config);
-    const installations = deriveInstallations(sources);
-    return sources.flatMap((source, index) => {
-        const installation = installations[index];
-        if (!installation || (bundle && installation.id !== bundle))
-            return [];
-        return [
-            {
-                bundle: installation.id,
-                root: source.path,
-                adapter: source.adapterId ?? installation.components[0]?.adapter ?? "akm",
-            },
-        ];
-    });
-}
-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 === "env")
-        return ["", ".env"];
-    return ["", ".md"];
+    return makeBundleRef(match.bundleId, parsed.conceptId);
 }

package/dist/workflows/freeze/freeze.js

@@ -107,7 +107,6 @@ function frozenRoot(stepId, source, resolved, plan, config) {
                 .update(canonicalJson({
                 exec: resolved.target.exec,
                 environment: resolved.environment,
-                cwdIdentity: resolved.target.cwdIdentity,
             }))
                 .digest("hex"),
         }

package/dist/workflows/freeze/step-values.js

@@ -45,14 +45,13 @@ export function durableRequest(request) {
     wire.runtime = runtime;
     return decodeResolvedExecutionRequest(wire);
 }
-export function executionUnitValues(unit, workspace) {
+export function executionUnitValues(unit) {
     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,
     });
 }
 /** Step ids declared BEFORE `stepId` — the same ordering `map.over` and `inputs:` rely on. */

package/dist/workflows/freeze/targets/child-workflow.js

@@ -11,7 +11,6 @@ import { UsageError } from "../../../core/errors.js";
 import { workflowParamContract } from "../../ir/params.js";
 import { canonicalJson, canonicalPlanJson } from "../../ir/plan-hash.js";
 import { loadWorkflowAsset } from "../../runtime/workflow-asset-loader.js";
-import { resolveOwnedAsset } from "../environment.js";
 import { declaredParamNames, earlierStepIds, } from "../step-values.js";
 import { freezeTaskInputBindings } from "../task-bindings.js";
 /** The child target's own content identity: its ref, embedded plan hash, and bindings. */
@@ -46,10 +45,9 @@ function assertNoCompositionCycle(stepId, childRef, refPath) {
 }
 export async function childWorkflowDispatch(input) {
     const { source, baseUnit, childRefInput, context } = input;
-    // Resolution failures propagate unchanged, in code and shape — the same
-    // authority every other asset reference resolves through.
-    const owned = await resolveOwnedAsset(childRefInput, "workflow", context);
-    const childAsset = await loadWorkflowAsset(owned.ref);
+    // The loader resolves the ref through the one walk, so a missing child fails
+    // like any other missing workflow.
+    const childAsset = await loadWorkflowAsset(childRefInput);
     const childRef = childAsset.ref;
     // The composition cycle check, before any child compilation.
     assertNoCompositionCycle(source.id, childRef, context.refPath);

package/dist/workflows/freeze/targets/command.js

@@ -3,29 +3,24 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 import { createHash } from "node:crypto";
 import { prepareCommandInvocation } from "../../../commands/command/command-execution.js";
-import { captureFrozenDirectoryIdentity } from "../../../execution/directory-identity.js";
 import { canonicalResolvedExecutionRequest, } from "../../../execution/resolved-request.js";
 import { fallbackAnnouncement } from "../../../integrations/agent/engine-fallback.js";
 import { buildExecution } from "../../../integrations/agent/execution.js";
-import { freezeEnvironment, workflowExecutionSource } from "../environment.js";
+import { freezeEnvironment } from "../environment.js";
 import { durableRequest, executionUnitValues, targetConcurrency, } from "../step-values.js";
 export async function commandDispatch(source, baseUnit, action, context) {
     const prepared = await prepareCommandInvocation({
         action,
         config: context.config,
-        ...(context.plan.defaults
-            ? { invocationDefaults: executionUnitValues(context.plan.defaults, context.asset.sourcePath) }
-            : {}),
+        ...(context.plan.defaults ? { invocationDefaults: executionUnitValues(context.plan.defaults) } : {}),
         inlineContentMode: "literal",
-        current: executionUnitValues(source.unit, context.asset.sourcePath),
-        sourceLoader: (ref, kind) => workflowExecutionSource(ref, kind, context),
+        current: executionUnitValues(source.unit),
     });
     return commandResult(source, baseUnit, prepared, context);
 }
 export function commandResult(source, baseUnit, prepared, context, literals = []) {
     const request = durableRequest(prepared.request);
     const lowered = buildExecution(request, prepared.runner);
-    const cwdIdentity = captureFrozenDirectoryIdentity(context.asset.sourcePath);
     const runner = lowered.runner;
     const unit = {
         ...baseUnit,
@@ -43,7 +38,9 @@ export function commandResult(source, baseUnit, prepared, context, literals = []
         request: JSON.parse(canonicalResolvedExecutionRequest(request)),
         runner,
         ...(targetConcurrency(runner, context.config) ? { concurrency: targetConcurrency(runner, context.config) } : {}),
-        cwdIdentity,
+        // Not a location. akm 0.10.0 and earlier decode a command-only plan and run it in the invoking directory,
+        // but their dispatch refuses a directory identity it cannot verify, so they stop here instead.
+        cwdIdentity: {},
     });
     const engineAnnouncement = fallbackAnnouncement(prepared.fallbackEngineName, request.engine.name);
     return {