akm-cli 0.10.261012-beta → 0.10.261013-beta

package/dist/setup/steps/tasks.js

@@ -89,7 +89,6 @@ export function listSetupTaskDefinitions() {
             const parsed = parseTaskSource({
                 yaml: fs.readFileSync(filePath, "utf8"),
                 filePath,
-                workspaceRoot: target.source.path,
             });
             const document = parsed.v4;
             if (document.schedule.length === 0)
@@ -129,7 +128,7 @@ export async function prepareSetupTaskDefinitions(tasks, deps = {}) {
             document.schedule = plan.schedule;
             yaml = yamlStringify(document);
         }
-        const parsed = parseTaskSource({ yaml, filePath, workspaceRoot: target.source.path });
+        const parsed = parseTaskSource({ yaml, filePath });
         for (const schedule of parsed.v4.schedule) {
             parseSchedule(schedule.cron, backendNameForPlatform());
         }

package/dist/sources/providers/provider-utils.js

@@ -82,6 +82,18 @@ export function buildInstallCacheDir(cacheRootDir, source, id, version) {
     const versionSlug = source === "local" ? uniqueSlug() : (version?.replace(/[^a-zA-Z0-9_.-]+/g, "-") ?? uniqueSlug());
     return path.join(cacheRootDir, slug || source, versionSlug);
 }
+/**
+ * The `<rev>` directory of a registry install that holds `contentDir`: the two
+ * path segments under `cacheRootDir` that {@link buildInstallCacheDir} lays out
+ * (`<source>-<id>/<version>`). Undefined for a directory outside that layout.
+ */
+export function installRevisionDir(cacheRootDir, contentDir) {
+    const relative = path.relative(path.resolve(cacheRootDir), path.resolve(contentDir));
+    if (relative === "" || relative.startsWith("..") || path.isAbsolute(relative))
+        return undefined;
+    const [slug, rev] = relative.split(path.sep);
+    return slug && rev ? path.join(path.resolve(cacheRootDir), slug, rev) : undefined;
+}
 /**
  * Apply an `akm.include` config (a `package.json` `akm.include` array — NOT
  * a `.akm-include` dotfile) if any, by copying the selected paths into a

package/dist/sources/resolve.js

@@ -6,11 +6,14 @@ import path from "node:path";
 import { recognizeMatch } from "../core/adapter/recognize-match.js";
 import { assetPathForName, deriveCanonicalAssetNameFromStashRoot, isRelevantAssetFile, stashDirFor, } from "../core/asset/asset-placement.js";
 import { conceptIdFromTypeName } from "../core/asset/resolve-ref.js";
-import { hasErrnoCode, isWithin } from "../core/common.js";
+import { hasErrnoCode, isContainedResolvedPath } from "../core/common.js";
 import { NotFoundError, UsageError } from "../core/errors.js";
 import { walkStashFlat } from "../indexer/walk/walker.js";
 /**
- * Resolve an asset path from a stash directory, type, and name.
+ * Resolve an asset path from a stash directory, type, and name. The path keeps
+ * the authored spelling, not the symlink target's: an asset that links to a
+ * file with another name (or none) is still the kind its own name says, and a
+ * read through it reaches the same bytes.
  */
 export async function resolveAssetPath(stashDir, type, name) {
     try {
@@ -31,25 +34,24 @@ export async function resolveAssetPath(stashDir, type, name) {
 function resolveInTypeDir(stashDir, typeDir, type, name) {
     const root = path.join(stashDir, typeDir);
     const target = assetPathForName(type, root, name);
-    const resolvedRoot = resolveAndValidateTypeRoot(root, type, name);
+    resolveAndValidateTypeRoot(root, type, name);
     const resolvedTarget = path.resolve(target);
-    if (!isWithin(resolvedTarget, resolvedRoot)) {
+    // Name grammar: the name must not climb out of the type directory (`..` or
+    // an absolute name). Lexical only: an asset that is a symlink to a file
+    // elsewhere resolves, because installing a bundle is the trust decision.
+    if (!isContainedResolvedPath(resolvedTarget, path.resolve(root))) {
         throw new UsageError("Ref resolves outside the stash root.", "PATH_ESCAPE_VIOLATION");
     }
     if (!fs.existsSync(resolvedTarget) || !fs.statSync(resolvedTarget).isFile()) {
         throw new NotFoundError(`Stash asset not found for ref: ${conceptIdFromTypeName(type, name)}`, "ASSET_NOT_FOUND");
     }
-    const realTarget = fs.realpathSync(resolvedTarget);
-    if (!isWithin(realTarget, resolvedRoot)) {
-        throw new UsageError("Ref resolves outside the stash root.", "PATH_ESCAPE_VIOLATION");
-    }
     if (!isRelevantAssetFile(type, path.basename(resolvedTarget))) {
         if (type === "script") {
             throw new NotFoundError("Script ref must resolve to a file with a supported script extension. Refer to the akm documentation for the complete list of supported script extensions.");
         }
         throw new NotFoundError(`Stash asset not found for ref: ${conceptIdFromTypeName(type, name)}`, "ASSET_NOT_FOUND");
     }
-    return realTarget;
+    return resolvedTarget;
 }
 function resolveAndValidateTypeRoot(root, type, name) {
     const rootStat = readTypeRootStat(root, type, name);
@@ -57,7 +59,6 @@ function resolveAndValidateTypeRoot(root, type, name) {
         throw new NotFoundError(`Asset directory for ${type} assets is not accessible — got a file where a directory was expected for ref: ${conceptIdFromTypeName(type, name)}. ` +
             "Run `akm index` to rebuild the index, or check your source configuration.", "ASSET_NOT_FOUND", "Run `akm bundle list` to see your configured sources and verify the source path exists.");
     }
-    return fs.realpathSync(root);
 }
 function readTypeRootStat(root, type, name) {
     try {
@@ -79,12 +80,7 @@ async function resolveByCanonicalName(stashDir, type, name) {
         const canonicalName = deriveCanonicalAssetNameFromStashRoot(type, stashDir, ctx.absPath);
         if (canonicalName !== normalizedName)
             continue;
-        const realTarget = fs.realpathSync(ctx.absPath);
-        const resolvedRoot = fs.realpathSync(stashDir);
-        if (!isWithin(realTarget, resolvedRoot)) {
-            throw new UsageError("Ref resolves outside the stash root.", "PATH_ESCAPE_VIOLATION");
-        }
-        return realTarget;
+        return ctx.absPath;
     }
     return undefined;
 }

package/dist/sources/snapshot-fetchers/secret-seam.js

@@ -1,8 +1,8 @@
 // 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 { resolveSecretPath } from "../../core/env-secret-ref.js";
+import { readValue } from "../../core/secret-value.js";
 /**
  * Reads a secret out of akm's secret store for the fetcher `resolveSecret`
  * seam (see `FetcherContext.resolveSecret`).
@@ -21,9 +21,7 @@ import { resolveSecretPath } from "../../core/env-secret-ref.js";
 export function resolveSecretFromStore(ref) {
     try {
         const { absPath } = resolveSecretPath(ref);
-        if (!fs.existsSync(absPath))
-            return null;
-        return fs.readFileSync(absPath, "utf8").trim() || null;
+        return readValue(absPath) || null;
     }
     catch {
         return null;

package/dist/sources/snapshot-fetchers/x.js

@@ -89,7 +89,7 @@ export function resolveXBearerToken(context) {
     if (fromEnv)
         return fromEnv;
     try {
-        return context?.resolveSecret?.(X_BEARER_TOKEN_SECRET_REF)?.trim() || null;
+        return context?.resolveSecret?.(X_BEARER_TOKEN_SECRET_REF) || null;
     }
     catch {
         return null;

package/dist/storage/repositories/proposals-repository.js

@@ -525,8 +525,8 @@ export function renameProposalsBundleRef(db, oldBundleId, newBundleId) {
     const prefix = `${escapeLikePattern(oldBundleId)}//`;
     return db.transaction(() => {
         const refs = Number(db
-            .prepare(`UPDATE proposals SET ref = ? || substr(ref, ?) WHERE ref LIKE ? ESCAPE '\\'`)
-            .run(newBundleId, oldBundleId.length + 1, `${prefix}%`).changes);
+            .prepare(`UPDATE proposals SET ref = ? || substr(ref, length(?) + 1) WHERE ref LIKE ? ESCAPE '\\'`)
+            .run(newBundleId, oldBundleId, `${prefix}%`).changes);
         const targets = Number(db
             .prepare(`UPDATE proposals SET metadata_json = json_set(metadata_json, '$.proposedTarget.source', ?)
            WHERE json_extract(metadata_json, '$.proposedTarget.source') = ?`)

package/dist/storage/repositories/task-history-repository.js

@@ -221,6 +221,6 @@ export function countTaskHistoryTargetRefs(db, oldBundleId) {
 export function renameTaskHistoryTargetRefs(db, oldBundleId, newBundleId) {
     const prefix = `${escapeLikePattern(oldBundleId)}//`;
     return Number(db
-        .prepare(`UPDATE task_history SET target_ref = ? || substr(target_ref, ?) WHERE target_ref LIKE ? ESCAPE '\\'`)
-        .run(newBundleId, oldBundleId.length + 1, `${prefix}%`).changes);
+        .prepare(`UPDATE task_history SET target_ref = ? || substr(target_ref, length(?) + 1) WHERE target_ref LIKE ? ESCAPE '\\'`)
+        .run(newBundleId, oldBundleId, `${prefix}%`).changes);
 }

package/dist/storage/repositories/workflow-runs-repository.js

@@ -42,75 +42,10 @@ export class WorkflowRunsRepository {
         return withImmediateTransaction(this.db, () => fn(this.db));
     }
     // ── reads (fully materialised) ─────────────────────────────────────────────
-    /**
-     * The top-level start guard `publishWorkflowRunV4` uses to refuse starting
-     * a SECOND active run of the same ref in the same scope. `AND
-     * parent_run_id IS NULL` (B-N10's FOURTH site, code-review round 4 finding
-     * 2 / Review log R2): a child run carries the PARENT's `scope_key` (P3a
-     * §5.2), so once a parent publishes a child of some ref, starting a
-     * TOP-LEVEL run of that same ref in that scope must never resolve to the
-     * child — the child is not "already an active run in this scope" from a
-     * fresh top-level invocation's point of view; the PARENT, if anything, is.
-     * Before this filter, `publishWorkflowRunV4` refused with
-     * `RESOURCE_ALREADY_EXISTS` naming the CHILD's own run id, instructing the
-     * operator to `akm workflow abandon` a child a parent is actively driving.
-     * For any database with no child rows the result is byte-identical, same
-     * as the other three B-N10 sites below.
-     *
-     * Always scope-local: `scopeKey` is a real scope, never "every scope" — see
-     * {@link findActiveRunOutsideScope} for the cross-scope warning's query.
-     */
-    findActiveRunForScope(workflowRefs, scopeKey) {
-        const refs = typeof workflowRefs === "string" ? [workflowRefs] : [...workflowRefs];
-        if (refs.length === 0)
-            return undefined;
-        return this.db
-            .prepare(`SELECT id, current_step_id FROM workflow_runs WHERE workflow_ref IN (${refs.map(() => "?").join(", ")}) AND scope_key = ? AND status = 'active' AND parent_run_id IS NULL ORDER BY updated_at DESC, created_at DESC LIMIT 1`)
-            .get(...refs, scopeKey);
-    }
-    /**
-     * The cross-scope start warning's query (#942): the most recently active
-     * run of these refs OUTSIDE `scopeKey` — i.e. `scope_key IS NULL OR
-     * scope_key != scopeKey`, not merely "the most recent active run of these
-     * refs anywhere". A same-scope active row must never win the `LIMIT 1` and
-     * mask a DIFFERENT scope's run: with `--new`/`--force`, the caller's own
-     * active run could otherwise sort first (most recently updated) and hide a
-     * third scope's run entirely, so `startWorkflowRun` silently warned about
-     * nothing while a genuinely stale run in another scope went unreported.
-     * `findActiveRunForScope` deliberately stays scope-local and is never used
-     * for this purpose.
-     */
-    findActiveRunOutsideScope(workflowRefs, scopeKey) {
-        const refs = typeof workflowRefs === "string" ? [workflowRefs] : [...workflowRefs];
-        if (refs.length === 0)
-            return undefined;
-        return (this.db
-            .prepare(`SELECT * FROM workflow_runs WHERE workflow_ref IN (${refs.map(() => "?").join(", ")}) AND (scope_key IS NULL OR scope_key != ?) AND status = 'active' AND parent_run_id IS NULL ORDER BY updated_at DESC, created_at DESC LIMIT 1`)
-            .get(...refs, scopeKey) ?? undefined);
-    }
     getRunById(runId) {
         return (this.db.prepare("SELECT * FROM workflow_runs WHERE id = ?").get(runId) ??
             undefined);
     }
-    /**
-     * The scope-attach lookup `akm workflow run <ref>` uses to find an
-     * in-progress top-level run to resume instead of starting a new one.
-     * `AND parent_run_id IS NULL` (B-N10): a child run must never be attached
-     * to directly through this path — a parent-driven child would then have
-     * TWO drivers. For any database with no child rows the result is
-     * byte-identical.
-     *
-     * Always scope-local: `scopeKey` is a real scope, never "every scope" — see
-     * {@link findActiveRunOutsideScope} for the cross-scope warning's query.
-     */
-    getActiveRunRowForScope(workflowRefs, scopeKey) {
-        const refs = typeof workflowRefs === "string" ? [workflowRefs] : [...workflowRefs];
-        if (refs.length === 0)
-            return undefined;
-        return (this.db
-            .prepare(`SELECT * FROM workflow_runs WHERE workflow_ref IN (${refs.map(() => "?").join(", ")}) AND scope_key = ? AND status = 'active' AND parent_run_id IS NULL ORDER BY updated_at DESC, created_at DESC LIMIT 1`)
-            .get(...refs, scopeKey) ?? undefined);
-    }
     hasRun(runId) {
         const row = this.db.prepare("SELECT 1 FROM workflow_runs WHERE id = ? LIMIT 1").get(runId);
         return !!row;
@@ -128,16 +63,9 @@ export class WorkflowRunsRepository {
         }
         throw new NotFoundError(`Workflow run "${prefix}" not found.`, "WORKFLOW_NOT_FOUND");
     }
-    listRuns(filter) {
+    listRuns(filter = {}) {
         const filters = [];
         const params = [];
-        // `scopeKey: null` (#942) is "every scope" — the predicate is omitted
-        // rather than bound as SQL NULL (which would match nothing, since a real
-        // `scope_key` column value is never NULL for a fresh run).
-        if (filter.scopeKey !== null) {
-            filters.push("scope_key = ?");
-            params.push(filter.scopeKey);
-        }
         if (filter.workflowRef) {
             filters.push("workflow_ref = ?");
             params.push(filter.workflowRef);
@@ -152,11 +80,7 @@ export class WorkflowRunsRepository {
             // human `resume`), so it must never appear under `--active`, or a script
             // treating `--active` output as executable work would pick up a blocked
             // run (owner manual-validation finding 1). Blocked runs stay visible in
-            // plain `list` (all statuses) with their `blocked` status. The
-            // active-OR-blocked scope semantics some call sites want (the `akm show`
-            // scope guard, which surfaces a blocked run as the scope's occupant) live
-            // in the SEPARATE {@link findActiveOrBlockedRunForScope} — never folded
-            // into this shared list filter.
+            // plain `list` (all statuses) with their `blocked` status.
             filters.push("status = 'active'");
         }
         // B-N10: a child run is invisible to this scope query unless the caller
@@ -178,32 +102,23 @@ export class WorkflowRunsRepository {
     getStep(runId, stepId) {
         return this.db.prepare("SELECT * FROM workflow_run_steps WHERE run_id = ? AND step_id = ?").get(runId, stepId);
     }
-    /**
-     * The `akm show` active-run guard: which run (if any) currently occupies
-     * this scope. `AND parent_run_id IS NULL` (B-N10) — a child a parent is
-     * driving must never be reported as "the" active run; the PARENT is. For
-     * any database with no child rows the result is byte-identical.
-     */
-    findActiveOrBlockedRunForScope(scopeKey) {
-        return (this.db
-            .prepare("SELECT id, current_step_id, workflow_ref FROM workflow_runs WHERE scope_key = ? AND status IN ('active', 'blocked') AND parent_run_id IS NULL ORDER BY updated_at DESC LIMIT 1")
-            .get(scopeKey) ?? null);
-    }
     // ── writes ─────────────────────────────────────────────────────────────────
     insertRun(input) {
         // R-R3 (P3a Review log; docs/plans/specs/p4-deletions-closeout.md §8):
-        // this 12-column list is hand-duplicated by publishChildWorkflowRun's own
+        // this column list is hand-duplicated by publishChildWorkflowRun's own
         // INSERT below, which extends it with parent_run_id/parent_unit_id/
         // invocation_key. A signature refactor to share one INSERT builder was
         // considered and deliberately deferred — see
         // docs/architecture/decisions/0009-child-run-publication-column-parity.md.
-        // Keep both column lists in sync by hand.
+        // Keep both column lists in sync by hand. `scope_key` and
+        // `workflow_entry_id` are legacy columns: read tolerantly, never written
+        // (#1239), so a fresh row carries NULL in both.
         this.db
             .prepare(`INSERT INTO workflow_runs (
-          id, workflow_ref, scope_key, workflow_entry_id, workflow_title, status, params_json, current_step_id, created_at, updated_at,
+          id, workflow_ref, workflow_title, status, params_json, current_step_id, created_at, updated_at,
           agent_harness, agent_session_id
-        ) VALUES (?, ?, ?, ?, ?, 'active', ?, ?, ?, ?, ?, ?)`)
-            .run(input.id, input.workflowRef, input.scopeKey, input.workflowEntryId, input.workflowTitle, input.paramsJson, input.currentStepId, input.createdAt, input.updatedAt, input.agentHarness, input.agentSessionId);
+        ) VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?)`)
+            .run(input.id, input.workflowRef, input.workflowTitle, input.paramsJson, input.currentStepId, input.createdAt, input.updatedAt, input.agentHarness, input.agentSessionId);
     }
     insertSteps(steps) {
         const insertStep = this.db.prepare(`INSERT INTO workflow_run_steps (
@@ -252,22 +167,6 @@ export class WorkflowRunsRepository {
      */
     publishWorkflowRunV4(input) {
         this.immediateTransaction((db) => {
-            if (!input.force) {
-                // The uniqueness guard must never silently skip its scope predicate
-                // (#942) — every real caller (`startWorkflowRun`) stamps a concrete
-                // scope key, so a null one here means the caller is misusing this
-                // top-level guard, not that scoping should be waived.
-                if (input.run.scopeKey === null) {
-                    throw new Error("publishWorkflowRunV4: run.scopeKey must not be null for the scope uniqueness guard.");
-                }
-                const existing = this.findActiveRunForScope(input.workflowRefs, input.run.scopeKey);
-                if (existing) {
-                    throw new UsageError(`Workflow ${input.run.workflowRef} already has an active run in this scope ` +
-                        `(id=${existing.id}, scope=${input.run.scopeKey}, step=${existing.current_step_id ?? "—"}). ` +
-                        `Use 'akm workflow run ${input.run.workflowRef}' to resume it or ` +
-                        `'akm workflow abandon ${existing.id}' to give up on it.`, "RESOURCE_ALREADY_EXISTS");
-                }
-            }
             this.insertRun(input.run);
             this.insertSteps(input.steps);
             db.prepare("UPDATE workflow_runs SET plan_json = ?, plan_hash = ?, plan_ir_version = ? WHERE id = ?").run(input.planJson, input.planHash, WORKFLOW_PLAN_VERSION, input.run.id);
@@ -294,9 +193,7 @@ export class WorkflowRunsRepository {
      * (`plan_ir_version` = the current plan version), and append its
      * `workflow_started` event — then return the freshly-inserted row.
      *
-     * Deliberately does NOT call {@link findActiveRunForScope} or raise
-     * `RESOURCE_ALREADY_EXISTS` (top-level scope-conflict rules do not apply to
-     * a child), and reads no source: the child plan was frozen into the parent's.
+     * Reads no source: the child plan was frozen into the parent's.
      *
      * This method's serialization guarantee holds only when it is the
      * OUTERMOST transaction on the connection (spec Review log R10,
@@ -332,14 +229,14 @@ export class WorkflowRunsRepository {
             if (existing)
                 return existing;
             // R-R3 (P3a Review log; docs/plans/specs/p4-deletions-closeout.md §8):
-            // the first 12 columns here must stay byte-identical to insertRun's own
+            // the first 10 columns here must stay byte-identical to insertRun's own
             // column list above (hand-duplicated, not shared, by deliberate choice
             // — see docs/architecture/decisions/0009-child-run-publication-column-parity.md).
             // Keep both column lists in sync by hand.
             db.prepare(`INSERT INTO workflow_runs (
-          id, workflow_ref, scope_key, workflow_entry_id, workflow_title, status, params_json, current_step_id, created_at, updated_at,
+          id, workflow_ref, workflow_title, status, params_json, current_step_id, created_at, updated_at,
           agent_harness, agent_session_id, parent_run_id, parent_unit_id, invocation_key
-        ) VALUES (?, ?, ?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.run.id, input.run.workflowRef, input.run.scopeKey, input.run.workflowEntryId, input.run.workflowTitle, input.run.paramsJson, input.run.currentStepId, input.run.createdAt, input.run.updatedAt, input.run.agentHarness, input.run.agentSessionId, input.parentRunId, input.spawnedByUnitId, input.invocationKey);
+        ) VALUES (?, ?, ?, 'active', ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run(input.run.id, input.run.workflowRef, input.run.workflowTitle, input.run.paramsJson, input.run.currentStepId, input.run.createdAt, input.run.updatedAt, input.run.agentHarness, input.run.agentSessionId, input.parentRunId, input.spawnedByUnitId, input.invocationKey);
             this.insertSteps(input.steps);
             db.prepare("UPDATE workflow_runs SET plan_json = ?, plan_hash = ?, plan_ir_version = ? WHERE id = ?").run(input.planJson, input.planHash, WORKFLOW_PLAN_VERSION, input.run.id);
             insertEventOnce(db, {
@@ -543,6 +440,31 @@ export class WorkflowRunsRepository {
         return this.db.prepare("SELECT * FROM workflow_run_units WHERE run_id = ? AND unit_id = ?").get(runId, unitId);
     }
 }
+/**
+ * Preview counterpart of {@link renameWorkflowRunRefs} for `akm bundle rename`:
+ * how many run rows name `oldBundleId`, and which of them are still `active`
+ * or `blocked` (their frozen `plan_json` keeps the old qualified refs, so the operator
+ * finishes or abandons them — the rename lists them rather than touching them).
+ */
+export function countWorkflowRunRefsForRename(db, oldBundleId) {
+    const like = `${escapeLikePattern(oldBundleId)}//%`;
+    const refs = db.prepare(`SELECT COUNT(*) AS n FROM workflow_runs WHERE workflow_ref LIKE ? ESCAPE '\\'`).get(like).n;
+    const active = db
+        .prepare(`SELECT id, workflow_ref AS workflowRef, status FROM workflow_runs WHERE workflow_ref LIKE ? ESCAPE '\\' AND status IN ('active', 'blocked') ORDER BY updated_at DESC, created_at DESC`)
+        .all(like);
+    return { refs, active };
+}
+/**
+ * Rewrite every `workflow_runs.workflow_ref` naming `oldBundleId` to
+ * `newBundleId` (`akm bundle rename`). A legacy unqualified ref is not matched
+ * by the `LIKE` prefix and is left alone. Returns the number of rows rewritten.
+ */
+export function renameWorkflowRunRefs(db, oldBundleId, newBundleId) {
+    const prefix = `${escapeLikePattern(oldBundleId)}//`;
+    return Number(db
+        .prepare(`UPDATE workflow_runs SET workflow_ref = ? || substr(workflow_ref, length(?) + 1) WHERE workflow_ref LIKE ? ESCAPE '\\'`)
+        .run(newBundleId, oldBundleId, `${prefix}%`).changes);
+}
 /**
  * Run `fn` against a {@link WorkflowRunsRepository} bound to state.db
  * ({@link StorageLocations.stateDb}, the post-cutover home of the

package/dist/tasks/embedded.js

@@ -69,7 +69,7 @@ export function listEmbeddedTasks() {
             }
             let parsed;
             try {
-                parsed = parseTaskSource({ yaml, filePath, workspaceRoot: TASKS_ASSETS_DIR });
+                parsed = parseTaskSource({ yaml, filePath });
             }
             catch {
                 continue;

package/dist/tasks/prepare/prepare-support.js

@@ -4,6 +4,7 @@
 import { makeBundleRef, parseBundleRef } from "../../core/asset/asset-ref.js";
 import { COMPOSITION_INVALID_MULTI_JOB_HINT, ConfigError, NotFoundError, UsageError } from "../../core/errors.js";
 import { DURATION_UNITS, parseDuration } from "../../core/time.js";
+import { warn } from "../../core/warn.js";
 import { isPortableExecutionAgentSelector } from "../../execution/source.js";
 import { buildExecution } from "../../integrations/agent/execution.js";
 import { resolveAssetPath } from "../../sources/resolve.js";
@@ -22,7 +23,7 @@ export function environmentSnapshot(environment) {
             continue;
         const value = String(raw);
         if (isInferredSecretName(key) || detectSecretShapedParams({ [key]: value }).length > 0) {
-            throw new UsageError(`Task env.${key} is a secret-shaped literal env value. Store credentials in a secret/env binding rather than durable task source.`, "TASK_SOURCE_INVALID");
+            warn(`Task env.${key} looks like a credential. Task source is durable and readable; keep the value in a secret or env file and inject it at run time with \`akm secret run\` or \`akm env run\` in the task's \`run:\`. (Heuristic warning; the value is used as written.)`);
         }
         Object.defineProperty(out, key, { value, enumerable: true, configurable: false, writable: false });
     }
@@ -120,7 +121,7 @@ export function validatePreparedCommand(invocation, context) {
 }
 export function validateWorkflowRuntimeSource(file, workspaceRoot, readFile) {
     const source = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(readFile(file, workspaceRoot));
-    const compiled = compileWorkflowSource(source, { path: file, workspaceRoot });
+    const compiled = compileWorkflowSource(source, { path: file });
     if (!compiled.ok) {
         // P4-N2's mapping (docs/plans/specs/p4-deletions-closeout.md §3.3.4): a
         // task-wrapped workflow target's own multi-job source is a composition

package/dist/tasks/prepare/prepare.js

@@ -19,25 +19,24 @@
  * `src/tasks/source/project-v4.ts`'s `projectTaskSourceV4()`.
  */
 import fs from "node:fs";
+import path from "node:path";
 import { prepareCommandInvocation } from "../../commands/command/command-execution.js";
 import { UsageError } from "../../core/errors.js";
 import { warn } from "../../core/warn.js";
 import { base, commandEnvironmentSnapshot, currentExecutionValues, defaultTaskShell, environmentSnapshot, qualifyOwnedRef, resolvedOwnedAsset, validatePreparedCommand, validateWorkflowRuntimeSource, } from "./prepare-support.js";
-import { captureDirectoryIdentity, captureScriptTarget } from "./script-capture.js";
+import { captureScriptTarget } from "./script-capture.js";
 /** Project one canonical task-v3 source into immutable executable work. */
 export async function prepareTaskV3Execution(document, context) {
     const environment = environmentSnapshot(document.env);
     const commandEnvironment = commandEnvironmentSnapshot(environment, context.schedulerContext);
     const common = base(document, context, environment);
     if (document.target.kind === "run") {
-        const cwdIdentity = captureDirectoryIdentity(context.bundleRoot, document.target.workingDirectory);
         return Object.freeze({
             ...common,
             kind: "shell",
             command: document.target.run,
             shell: document.target.shell ?? defaultTaskShell(context.platform ?? process.platform),
-            cwd: cwdIdentity.realCwd,
-            cwdIdentity,
+            cwd: path.resolve(context.bundleRoot, document.target.workingDirectory ?? "."),
         });
     }
     const target = document.target.uses;

package/dist/tasks/prepare/script-capture.js

@@ -7,13 +7,12 @@
  * script arm (the moved prepareTaskV3Execution) and
  * prepare-script-target.ts's typed prepareScriptTarget() call
  * captureScriptTarget() below, so the two never drift into two copies of the
- * same capture logic. scriptInterpreter() and captureDirectoryIdentity() are
- * moved body-intact out of the pre-P1b src/tasks/runtime-v3.ts.
+ * same capture logic. scriptInterpreter() is moved body-intact out of the
+ * pre-P1b src/tasks/runtime-v3.ts.
  */
 import { createHash } from "node:crypto";
 import path from "node:path";
 import { UsageError } from "../../core/errors.js";
-import { captureFrozenDirectoryIdentity } from "../../execution/directory-identity.js";
 import { isBunStandaloneMain } from "../resolve-akm-bin.js";
 const SCRIPT_INTERPRETERS = Object.freeze({
     ".sh": "sh",
@@ -77,36 +76,23 @@ export function scriptInterpreter(extension, ref, bytes) {
     }
     throw new UsageError(`Task v3 script target ${JSON.stringify(ref)} requires Bun for ${extension} execution, but this runtime cannot provide it.`, "TASK_TARGET_UNSUPPORTED");
 }
-export function captureDirectoryIdentity(bundleRoot, workingDirectory) {
-    try {
-        return captureFrozenDirectoryIdentity(bundleRoot, workingDirectory);
-    }
-    catch (cause) {
-        if (cause instanceof UsageError)
-            throw cause;
-        throw new UsageError(`Task working directory ${JSON.stringify(workingDirectory ?? ".")} cannot be physically verified: ${cause instanceof Error ? cause.message : String(cause)}`, "TASK_SOURCE_INVALID");
-    }
-}
 /**
- * Read a script's bytes off disk (or the caller's own read seam) and freeze
- * the interpreter/digest/directory-identity shape every script dispatch
- * needs. `ref` is used only for interpreter-selection error messages — it is
- * the script's own qualified ref, never a synthetic task ref. `bundleRoot` is
- * where directory identity is captured from (one level above the script file
- * itself, matching prepareTaskV3Execution's historical behavior).
+ * Read a script's bytes off disk (or the caller's own read seam, following a
+ * symlink to wherever it points) and freeze the interpreter/digest shape every
+ * script dispatch needs. `ref` is used only for interpreter-selection error
+ * messages — it is the script's own qualified ref, never a synthetic task ref.
+ * `bundleRoot` is the script's working directory.
  */
 export function captureScriptTarget(ref, file, bundleRoot, readFile) {
     const extension = path.extname(file).toLowerCase();
     const raw = readFile(file, bundleRoot);
     const bytes = Uint8Array.from(raw);
-    const cwdIdentity = captureDirectoryIdentity(bundleRoot);
     return Object.freeze({
         interpreter: scriptInterpreter(extension, ref, bytes),
         extension,
         bytesBase64: Buffer.from(bytes).toString("base64"),
         byteLength: bytes.byteLength,
         sha256: createHash("sha256").update(bytes).digest("hex"),
-        cwd: cwdIdentity.realCwd,
-        cwdIdentity,
+        cwd: path.resolve(bundleRoot),
     });
 }

package/dist/tasks/run/load-task.js

@@ -11,11 +11,16 @@
 import fs from "node:fs";
 import { detectAdapterId } from "../../core/adapter/detect-adapter.js";
 import { makeBundleRef } from "../../core/asset/asset-ref.js";
+import { conceptIdFromTypeName } from "../../core/asset/resolve-ref.js";
+import { resolveStashDir } from "../../core/common.js";
 import { loadConfig } from "../../core/config/config.js";
-import { NotFoundError } from "../../core/errors.js";
-import { resolveWriteTarget } from "../../core/write-source.js";
+import { bundleKeyForContentRoot } from "../../core/config/config-sources.js";
+import { ConfigError, NotFoundError, UsageError } from "../../core/errors.js";
+import { assertBundleNotDisabled } from "../../core/write-source.js";
 import { applyInputDefaults, materializeInputFlags, validateInputs, } from "../../execution/input-contract.js";
-import { resolveAdapterConceptOwner } from "../../indexer/lookup/adapter-concept-owner.js";
+import { resolveAdapterConceptOwner, resolveConceptOwner } from "../../indexer/lookup/adapter-concept-owner.js";
+import { resolveSourceEntries } from "../../indexer/search/search-source.js";
+import { resolveSourcesForOrigin } from "../../registry/origin-resolve.js";
 import { resolveAssetPath } from "../../sources/resolve.js";
 import { prepareTaskV3Execution } from "../prepare/prepare.js";
 import { scheduledTaskContextEnv } from "../scheduler-invocation.js";
@@ -34,6 +39,42 @@ const CONFIG_FREE_TASK_RUNTIME = Object.freeze({
     configVersion: "0.9.0",
     semanticSearchMode: "off",
 });
+/**
+ * The active source set a task read walks. A working stash that is a disabled
+ * configured bundle makes that set throw; it is simply not in the set, so the
+ * other bundles still resolve.
+ */
+export function activeTaskSources(config) {
+    try {
+        return resolveSourceEntries(undefined, config);
+    }
+    catch (cause) {
+        const working = bundleKeyForContentRoot(config, resolveStashDir());
+        const entry = working ? config.bundles?.[working] : undefined;
+        if (!(cause instanceof ConfigError) || !working || !entry || entry.enabled !== false)
+            throw cause;
+        const enabled = { ...config, bundles: { ...config.bundles, [working]: { ...entry, enabled: true } } };
+        return resolveSourceEntries(undefined, enabled).filter((source) => source.registryId !== working);
+    }
+}
+/**
+ * Resolve an asset a task names in another bundle (`uses:`) through the one
+ * ref-to-file walk. Reading needs no write target, so a bundle of any kind
+ * (git, npm, website) resolves. The file is the authored path, not the symlink
+ * target, so the script interpreter follows the name the author gave it.
+ */
+export function resolveBundleAsset(config, { bundle, type, name }) {
+    const conceptId = conceptIdFromTypeName(type, name);
+    const sources = activeTaskSources(config);
+    const match = resolveConceptOwner({ bundle, conceptId }, sources);
+    if (match)
+        return { file: match.owner.path, bundleRoot: match.source.path };
+    if (resolveSourcesForOrigin(bundle, sources).length === 0) {
+        assertBundleNotDisabled(config, bundle);
+        throw new UsageError(`Bundle ${JSON.stringify(bundle)} is not configured. Run \`akm bundle list\` to see available bundles.`, "INVALID_FLAG_VALUE");
+    }
+    throw new NotFoundError(`Task asset ${makeBundleRef(bundle, conceptId)} was not found.`, "ASSET_NOT_FOUND");
+}
 /** Resolve, parse, and project one task-v3 asset into a frozen, executable projection. */
 export async function loadPreparedTask(id, options) {
     const bundleDir = options.bundleDir;
@@ -49,7 +90,7 @@ export async function loadPreparedTask(id, options) {
     }
     const filePath = owner.path;
     const yaml = fs.readFileSync(filePath, "utf8");
-    const parsed = parseTaskSource({ yaml, filePath, workspaceRoot: bundleDir });
+    const parsed = parseTaskSource({ yaml, filePath });
     const source = projectTaskSourceV4(parsed.v4);
     const requiresCommandConfig = source.target.kind === "uses" &&
         (source.target.uses.kind === "builtin-command" || source.target.uses.kind === "command");
@@ -106,16 +147,7 @@ export async function loadPreparedTask(id, options) {
             if (bundle === bundleName) {
                 return { file: await resolveAssetPath(bundleDir, type, name), bundleRoot: bundleDir };
             }
-            const resolutionConfig = requiresCommandConfig ? config : loadConfig();
-            // `bundle` is the qualifier of an asset ref in the task, not a flag.
-            const resolvedBundle = resolveWriteTarget(resolutionConfig, bundle, {
-                requireWritable: false,
-                flag: "The asset ref's bundle",
-            });
-            return {
-                file: await resolveAssetPath(resolvedBundle.source.path, type, name),
-                bundleRoot: resolvedBundle.source.path,
-            };
+            return resolveBundleAsset(requiresCommandConfig ? config : loadConfig(), { bundle, type, name });
         },
     });
 }

package/dist/tasks/run/run-native-task.js

@@ -20,7 +20,6 @@
 import path from "node:path";
 import { assertNever } from "../../core/assert.js";
 import { runManagedSubprocess, streamCaptureFailure } from "../../core/subprocess.js";
-import { assertFrozenDirectoryContained } from "../../execution/directory-identity.js";
 import { cleanupFrozenScript, frozenScriptCommand, materializeFrozenScript } from "../frozen-script.js";
 import { resolveAkmInvocation } from "../resolve-akm-bin.js";
 import { finishAttempt } from "./attempt-lifecycle.js";
@@ -163,13 +162,6 @@ export async function runNativeTask(input) {
     process.once("SIGTERM", onSigterm);
     process.once("SIGINT", onSigint);
     try {
-        // Re-resolve the authored root/cwd immediately before spawn so a
-        // symlink, ancestor, bundle-root, or directory/file swap cannot redirect
-        // execution outside that physical workspace. This is a live containment
-        // check, not an identity comparison — it does not care whether the
-        // underlying device/inode changed (e.g. a remount), only whether the
-        // resolved cwd still lives inside its root.
-        assertFrozenDirectoryContained(task.cwdIdentity);
         if (task.kind === "script") {
             materialized = materializeFrozenScript(task);
             cmd = frozenScriptCommand(task, materialized.file);