akm-cli 0.9.16 → 0.9.17-alpha.10

package/dist/commands/tasks/tasks.js

@@ -7,8 +7,13 @@
  * Each handler exported here is a pure function that performs the real work;
  * `src/cli.ts` wraps these in citty `defineCommand`s and shapes their return
  * values via `output()`.
+ *
+ * Every command that writes the native scheduler (`add`, `enable`,
+ * `disable`, `sync`, `prune --yes`) runs under the one scheduler lock
+ * (`withSchedulerLock`): read the installed rows once, plan against the
+ * sources, then install, update, or remove row by row. One row that fails is
+ * reported and the rest still apply.
  */
-import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import { stringify as yamlStringify } from "yaml";
@@ -17,28 +22,28 @@ 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 } from "../../core/config/config.js";
-import { bundleComponentConfig, bundleKeyForContentRoot, resolveActiveConfiguredSources, resolveConfiguredSources, } from "../../core/config/config-sources.js";
+import { loadConfig, mutateConfig, resetConfigCache } from "../../core/config/config.js";
+import { bundleKeyForContentRoot, resolveActiveConfiguredSources, 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 { warn } from "../../core/warn.js";
-import { commitWriteTargetBoundary, deleteAssetFromSource, prepareWriteTargetForMutation, resolveWorkingStashTarget, resolveWriteTarget, writeAssetToSource, } from "../../core/write-source.js";
+import { commitWriteTargetBoundary, isWriteCapableSourceKind, prepareWriteTargetForMutation, resolveWorkingStashTarget, resolveWriteTarget, writeAssetToSource, } from "../../core/write-source.js";
 import { withEngineFallback } from "../../integrations/agent/engine-fallback.js";
 import { resolveAssetPath } from "../../sources/resolve.js";
-import { activeSchedulerActivations, isSchedulerRefEnabled, setSchedulerRefEnabled, } from "../../tasks/activation-config.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 { resolveAkmInvocation } from "../../tasks/resolve-akm-bin.js";
+import { isCheckoutInvocation, resolveAkmInvocation } from "../../tasks/resolve-akm-bin.js";
 import { createExecutionProvenanceContext } from "../../tasks/run/provenance.js";
 import { runTask } from "../../tasks/run/run-task.js";
 import { readTaskHistory } from "../../tasks/run/task-history.js";
 import { exitCodeForStatus } from "../../tasks/run/task-result.js";
 import { parseSchedule, SCHEDULE_SUPPORTED_SUBSET_HINT } from "../../tasks/schedule.js";
-import { assertSchedulerMutationArtifact, assertSchedulerNativeArtifactCardinality, compileTaskSchedulerBindings, schedulerBindingNativeId, schedulerBindingOrdinal, schedulerNativeArtifactKey, schedulerNativeBindingId, } from "../../tasks/scheduler-binding.js";
-import { schedulerContextDescriptor, schedulerContextPath, validateSchedulerContextDescriptor, writeSchedulerContextDescriptor, } from "../../tasks/scheduler-invocation.js";
-import { assertSchedulerBackendInspection, assertSchedulerNativeArtifactOwnership, assertSchedulerSourceSnapshot, buildSchedulerRemoveOperation, finalizeSchedulerSyncPlan, prepareSchedulerSyncSourceSet, } from "../../tasks/scheduler-sync.js";
-import { renderSchedulerPlanPreview, renderSchedulerSyncPlanPreview, } from "../../tasks/scheduler-sync-preview.js";
+import { compileTaskSchedulerBindings, schedulerBindingNativeId, } from "../../tasks/scheduler-binding.js";
+import { readLegacySchedulerContext, scheduledRowEnvironment } from "../../tasks/scheduler-invocation.js";
+import { withSchedulerLock } from "../../tasks/scheduler-lock.js";
+import { compileSchedulerSources, installedRowNativeId, installedRowOwner, installedRowScope, planSchedulerSync, renderSchedulerPlanPreview, scheduledInvocationBundle, } from "../../tasks/scheduler-sync.js";
 import { parseTaskSource } from "../../tasks/source/parse-task-source.js";
 import { projectTaskSourceV4 } from "../../tasks/source/project-v4.js";
 import { normaliseTaskConceptId, normaliseTaskId } from "../../tasks/task-id.js";
@@ -47,27 +52,17 @@ import { resolveImproveStrategy } from "../improve/improve-strategies.js";
 export async function akmTasksAdd(input, deps = {}) {
     const id = normaliseTaskId(input.id);
     assertTaskAddTargetShape(input);
-    // Validate the schedule for the active backend before writing anything.
-    // WI-9.10e: the injected backend (tests) carries its own name, so derive it
-    // from `deps.backend` when present — retiring the `_setBackendsForTests` seam.
+    // Validate the schedule for the active backend before writing anything. An
+    // injected backend (tests) carries its own name.
     const backend = deps.backend?.name ?? backendNameForPlatform();
     parseSchedule(input.schedule, backend);
-    const bundle = resolveTaskBundle(input.target, { requireWritable: true });
-    const writeTarget = bundle.resolved;
+    const bundle = resolveTaskBundle(input.target);
     const stashDir = bundle.stashDir;
-    const installOpts = bundle.installTarget !== undefined ? { target: bundle.installTarget } : undefined;
     const typeRoot = path.join(stashDir, "tasks");
     const assetPath = assetPathForName("task", typeRoot, id);
     if (!isWithin(assetPath, typeRoot)) {
         throw new UsageError(`Resolved task path escapes the stash: "${id}".`, "PATH_ESCAPE_VIOLATION");
     }
-    if (fs.existsSync(assetPath) && !input.force) {
-        throw new UsageError(`Task "${id}" already exists. Pass --force to overwrite, or delete its file and run \`akm task sync\` first.`, "RESOURCE_ALREADY_EXISTS");
-    }
-    const sourceExpectation = captureTaskSourceExpectation(assetPath, stashDir);
-    if (sourceExpectation.state === "present" && !input.force) {
-        throw new UsageError(`Task "${id}" appeared while add was preparing. Pass --force only after reviewing the current owner.`, "RESOURCE_ALREADY_EXISTS");
-    }
     const yaml = renderTaskYaml({
         id,
         schedule: input.schedule,
@@ -94,12 +89,9 @@ export async function akmTasksAdd(input, deps = {}) {
         config: bundle.config,
         resolveAsset: taskProjectionAssetResolver(bundle.config, bundle.bundleName, stashDir),
     });
-    // Bindings are compiled from the original parsed document so each
-    // schedule entry's inputs reach the generated invocation.
-    const taskBindings = compileTaskSchedulerBindings({
+    const bindings = compileTaskSchedulerBindings({
         id,
         qualifiedRef,
-        ...(bundle.installTarget ? { bundleTarget: bundle.installTarget } : {}),
         schedules: parsedTask.v4.schedule.map((schedule) => ({
             cron: schedule.cron,
             ordinal: schedule.ordinal,
@@ -107,136 +99,49 @@ export async function akmTasksAdd(input, deps = {}) {
             inputs: schedule.inputs,
         })),
     });
-    const taskBinding = taskBindings[0];
-    if (!taskBinding)
+    const first = bindings[0];
+    if (!first)
         throw new UsageError(`Task "${id}" has no schedulable trigger.`, "INVALID_FLAG_VALUE");
-    const ref = taskAssetRef(id);
     const sched = deps.backend ?? selectBackend();
-    const writeAsset = deps.writeAsset ?? writeAssetToSource;
-    const deleteAsset = deps.deleteAsset ?? deleteAssetFromSource;
-    const commitBoundary = deps.commitBoundary ?? commitWriteTargetBoundary;
-    if (input.disabled) {
-        // Revoke before publishing replacement bytes. If a write/commit/sync
-        // fails, the safe partial state is an inert task, never an activated new
-        // source (or a stale native binding that can still dispatch it).
-        setSchedulerRefEnabled("task", qualifiedRef, false);
-        await writeAsset(writeTarget.source, writeTarget.config, ref, yaml);
-        commitBoundary(writeTarget, `Update tasks/${id}`);
-        await akmTasksSync(deps, bundle.bundleName);
+    return withSchedulerLock(async () => {
+        if (fs.existsSync(assetPath) && !input.force) {
+            throw new UsageError(`Task "${id}" already exists. Pass --force to overwrite, or delete its file and run \`akm task sync\` first.`, "RESOURCE_ALREADY_EXISTS");
+        }
+        // Native ids are shared by every bundle and installation: refuse before
+        // writing anything when another one already schedules this id.
+        const scope = bundleScope(bundle.bundleName, stashDir);
+        const installed = await listInstalledRows(sched);
+        for (const binding of bindings) {
+            const row = installed.find((candidate) => installedRowNativeId(candidate) === schedulerBindingNativeId(binding));
+            if (row && !installedRowScope(row, [scope])) {
+                throw new UsageError(`Task id "${id}" is already scheduled from ${installedRowOwner(row)}; rename the task or disable the existing one first.`, "RESOURCE_ALREADY_EXISTS");
+            }
+        }
+        await ensureSchedulerChoice({ backend: sched });
+        if (input.disabled)
+            setSchedulerRefEnabled(qualifiedRef, false);
+        await (deps.writeAsset ?? writeAssetToSource)(bundle.resolved.source, bundle.resolved.config, taskAssetRef(id), yaml);
+        (deps.commitBoundary ?? commitWriteTargetBoundary)(bundle.resolved, `Update tasks/${id}`);
+        if (!input.disabled)
+            setSchedulerRefEnabled(qualifiedRef, true);
+        const sync = await akmTasksSync(deps, bundle.bundleName, { rebind: input.rebind === true });
+        for (const warning of sync.warnings ?? [])
+            warn(warning);
+        const failure = sync.failures.find((candidate) => candidate.ref === qualifiedRef);
+        if (failure) {
+            throw new ConfigError(`Task "${id}" was written to ${assetPath}${input.disabled ? "" : " and enabled"}, but it could not be scheduled: ${failure.reason}`, "INVALID_CONFIG_FILE", "Fix the cause and run `akm task sync`.");
+        }
         return {
             id,
             ref: conceptIdFromTypeName("task", id),
             path: assetPath,
             bundleDir: stashDir,
-            schedule: taskBinding.cron,
-            enabled: false,
+            schedule: first.cron,
+            enabled: input.disabled !== true,
             backend,
             target: task.target,
         };
-    }
-    const transaction = await prepareTaskAddSchedulerTransaction({
-        id,
-        installTarget: bundle.installTarget,
-        ownerTarget: bundle.bundleName,
-        installOpts,
-        taskBindings,
-        sched,
-        deps,
-        rebind: input.rebind === true,
-    });
-    let sourceMutationReceipt;
-    let sourcePublished = false;
-    let sourcePublicationAttempted = false;
-    const publishSource = async () => {
-        assertTaskSourceExpectation(sourceExpectation);
-        sourcePublicationAttempted = true;
-        await writeAsset(writeTarget.source, writeTarget.config, ref, yaml);
-        const publishedSource = captureTaskSourceExpectation(assetPath, stashDir);
-        if (publishedSource.state !== "present" || publishedSource.sha256 !== hashTaskSource(yaml)) {
-            throw new UsageError(`Task source ${JSON.stringify(assetPath)} changed during publication.`, "RESOURCE_ALREADY_EXISTS");
-        }
-        sourceMutationReceipt = publishedSource;
-        sourcePublished = true;
-        transaction.publishRuntime?.();
-    };
-    await applySchedulerTransaction(sched, transaction.operations, {
-        initialExpectations: transaction.initialExpectations,
-        assertReadSet: () => {
-            if (sourcePublished) {
-                if (!sourceMutationReceipt) {
-                    throw new ConfigError("Published task source lost its transaction receipt.", "INVALID_CONFIG_FILE");
-                }
-                assertTaskSourceExpectation(sourceMutationReceipt);
-            }
-            else {
-                assertTaskSourceExpectation(sourceExpectation);
-            }
-        },
-        beforeOperation: async (_operation, index) => {
-            if (index === transaction.publishOperationIndex && !sourcePublished)
-                await publishSource();
-        },
-        afterOperations: () => commitBoundary(writeTarget, `Update tasks/${id}`),
-        rollbackExternal: async () => {
-            if (!sourcePublicationAttempted)
-                return;
-            if (!sourceMutationReceipt) {
-                const current = captureTaskSourceExpectation(assetPath, stashDir);
-                if (sameTaskSourceExpectation(current, sourceExpectation))
-                    return;
-                if (current.state !== "present" || current.sha256 !== hashTaskSource(yaml)) {
-                    throw new UsageError(`Task source ${JSON.stringify(assetPath)} has an unowned publication state; refusing rollback over a possible concurrent owner.`, "RESOURCE_ALREADY_EXISTS");
-                }
-                sourceMutationReceipt = current;
-            }
-            assertTaskSourceExpectation(sourceMutationReceipt);
-            try {
-                if (sourceExpectation.state === "absent") {
-                    await deleteAsset(writeTarget.source, writeTarget.config, ref);
-                }
-                else {
-                    await writeAsset(writeTarget.source, writeTarget.config, ref, sourceExpectation.content);
-                    const providerRestored = captureTaskSourceExpectation(assetPath, stashDir);
-                    if (providerRestored.state !== "present" || providerRestored.sha256 !== sourceExpectation.sha256) {
-                        // Provider writers conventionally normalize a trailing newline.
-                        // Rollback is byte-exact, so finish the already-owned restore with
-                        // the frozen bytes before checking the physical source state.
-                        fs.writeFileSync(assetPath, Buffer.from(sourceExpectation.bytesBase64, "base64"));
-                    }
-                }
-                assertTaskSourceRestored(sourceExpectation);
-                commitBoundary(writeTarget, `Restore tasks/${id}`);
-            }
-            catch (cause) {
-                // A write/commit seam may report failure after it has already restored
-                // the exact source bytes. Prove that state before allowing native
-                // rollback; otherwise preserve the possible concurrent source owner.
-                try {
-                    assertTaskSourceRestored(sourceExpectation);
-                }
-                catch {
-                    throw cause;
-                }
-                throw new TaskSourceRestoredBoundaryError(cause);
-            }
-        },
-        suppressNativeRollbackWhenExternalFails: true,
-        allowNativeRollbackAfterExternalFailure: (error) => error instanceof TaskSourceRestoredBoundaryError,
     });
-    // Publish the host-local grant only after source and native state commit.
-    // A failure before this point therefore leaves any new binding inert at
-    // its scheduled-fire gate instead of authorizing partially committed code.
-    setSchedulerRefEnabled("task", qualifiedRef, true);
-    return {
-        id,
-        ref: conceptIdFromTypeName("task", id),
-        path: assetPath,
-        bundleDir: stashDir,
-        schedule: taskBinding.cron,
-        enabled: true,
-        backend,
-        target: task.target,
-    };
 }
 function assertTaskAddTargetShape(input) {
     const hasCommand = input.command !== undefined &&
@@ -264,11 +169,6 @@ 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;
-    const conceptId = adapterId === "akm" ? `tasks/${resolvedId}` : resolvedId;
-    const qualifiedRef = makeBundleRef(bundle.source.name, conceptId);
-    if (scheduled && !isSchedulerRefEnabled(loadConfig(), "task", qualifiedRef)) {
-        throw new UsageError(`Scheduled task ${JSON.stringify(qualifiedRef)} is not enabled in local scheduler config; run \`akm task enable ${qualifiedRef}\`.`, "INVALID_FLAG_VALUE");
-    }
     // 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
@@ -342,17 +242,41 @@ function resolveTaskActivation(ref, target, requireSchedulable) {
     }
     return { qualifiedRef: makeBundleRef(bundle.source.name, conceptId), sourcePath, bundleName: bundle.source.name };
 }
+/**
+ * A config that predates `scheduler.enabled` means "keep what is installed":
+ * write that as the host's explicit list before one ref is added or removed,
+ * so enabling or disabling a single task never silently drops the others.
+ */
+async function ensureSchedulerChoice(deps) {
+    const config = loadConfig();
+    if (schedulerEnabledRefs(config) !== undefined)
+        return;
+    initializeSchedulerChoice(await (deps.backend ?? selectBackend()).list(), config, { write: true });
+}
+function initializeSchedulerChoice(installed, config, options) {
+    const refs = enabledRefsFromInstalled(installed, config);
+    if (options.write) {
+        mutateConfig((current) => ({ ...current, scheduler: { ...current.scheduler, enabled: [...refs] } }));
+        resetConfigCache();
+    }
+    warn(`This host had no scheduler.enabled list; ${options.write ? "it was" : "it would be"} initialized from the ` +
+        `${refs.length} installed akm scheduler ${refs.length === 1 ? "binding" : "bindings"}` +
+        `${refs.length > 0 ? `: ${refs.join(", ")}` : ""}. Use \`akm task enable\`/\`akm task disable <ref>\` to change it.`);
+    return refs;
+}
 export async function akmTasksEnable(ref, options = {}, deps = {}) {
-    const resolved = resolveTaskActivation(ref, options.target, true);
-    const activation = setSchedulerRefEnabled("task", resolved.qualifiedRef, true);
-    const sync = await akmTasksSync(deps, resolved.bundleName);
-    return { ref: resolved.qualifiedRef, enabled: true, changed: activation.changed, sync };
+    return setTaskActivation(resolveTaskActivation(ref, options.target, true), true, deps);
 }
 export async function akmTasksDisable(ref, options = {}, deps = {}) {
-    const resolved = resolveTaskActivation(ref, options.target, false);
-    const activation = setSchedulerRefEnabled("task", resolved.qualifiedRef, false);
-    const sync = await akmTasksSync(deps, resolved.bundleName);
-    return { ref: resolved.qualifiedRef, enabled: false, changed: activation.changed, sync };
+    return setTaskActivation(resolveTaskActivation(ref, options.target, false), false, deps);
+}
+async function setTaskActivation(resolved, enabled, deps) {
+    return withSchedulerLock(async () => {
+        await ensureSchedulerChoice(deps);
+        const activation = setSchedulerRefEnabled(resolved.qualifiedRef, enabled);
+        const sync = await akmTasksSync(deps, resolved.bundleName);
+        return { ref: resolved.qualifiedRef, enabled, changed: activation.changed, sync };
+    });
 }
 export async function akmTasksHistory(input) {
     const limit = input.limit !== undefined && input.limit > 0 ? input.limit : 50;
@@ -365,340 +289,288 @@ export async function akmTasksHistory(input) {
 }
 /**
  * Reconcile host-local scheduler activation with authored tasks/workflows.
- *   • without --bundle, scan every enabled configured bundle in one transaction
- *   • with --bundle, reconcile only that bundle
- *   • only refs present in scheduler.enabled enter the desired set
- *   • install missing bindings only after that whole-set preflight succeeds
- *   • reinstall bindings whose authored schedule or runtime state changed
- *     (drift detected by comparing the backend's installed signature against
- *     the signature the current definition would produce)
- *   • remove orphan scheduler entries that no longer have a backing file
+ *
+ *   • without a bundle, every enabled configured filesystem/git bundle; with
+ *     one, only that bundle
+ *   • only refs listed in `scheduler.enabled` are read and scheduled
+ *   • a row is installed when missing, rewritten when its rendered definition
+ *     differs, and removed when its source is gone or no longer enabled
+ *   • rows another bundle or installation owns are never touched, and a row
+ *     whose source fails to compile is left as it is
+ *   • a disabled bundle's rows are removed by an unscoped sync
  */
+export async function akmTasksSync(deps = {}, bundleTarget, options = {}) {
+    return withSchedulerLock(async () => {
+        const { sched, plan, warnings } = await buildSchedulerSyncPlan(deps, bundleTarget, options);
+        const failed = new Set();
+        const failures = [...plan.failures];
+        for (const operation of plan.operations) {
+            try {
+                if (operation.kind === "remove")
+                    await sched.uninstall(operation.nativeId);
+                else
+                    await sched.install(operation.binding, operation.options);
+            }
+            catch (cause) {
+                if (operation.kind === "remove") {
+                    failed.add(operation.id);
+                    failures.push({ path: operation.nativeId, reason: errorMessage(cause) });
+                }
+                else {
+                    failed.add(operation.binding.id);
+                    failures.push({
+                        path: operation.binding.source,
+                        ref: operation.binding.logicalSource.ref,
+                        reason: errorMessage(cause),
+                    });
+                }
+            }
+        }
+        const applied = (ids) => ids.filter((id) => !failed.has(id));
+        return {
+            installed: applied(plan.installed),
+            updated: applied(plan.updated),
+            removed: applied(plan.removed),
+            unchanged: [...plan.unchanged],
+            skipped: [],
+            backend: sched.name,
+            failures: failures.map((failure) => ({ ...failure })),
+            ...(warnings.length > 0 ? { warnings } : {}),
+        };
+    });
+}
 /**
- * Compute (but never apply) a scheduler sync plan: everything through
- * `finalizeSchedulerSyncPlan`'s final call, stopping strictly before
- * `applySchedulerSyncPlan`. Shared by `akmTasksSync` (applies the plan) and
- * `akmTasksSyncPlan` (#849 `--dry-run`, never applies it) so the two paths
- * can never drift on what "the plan" means. `prepared?.publish`, the one
- * deferred write-producing closure in this pipeline, is returned but never
- * invoked here — only `applySchedulerSyncPlan` may call it.
+ * `akm task sync --dry-run` (#849): the exact plan `akmTasksSync` would
+ * apply, previewed. It writes nothing: no config, no row.
  */
+export async function akmTasksSyncPlan(deps = {}, bundleTarget, options = {}) {
+    const { sched, plan } = await buildSchedulerSyncPlan(deps, bundleTarget, { ...options, dryRun: true });
+    return renderSchedulerPlanPreview(sched.name, plan.operations, plan.unchanged, plan.failures);
+}
 async function buildSchedulerSyncPlan(deps, bundleTarget, options) {
-    const config = loadConfig();
+    let config = loadConfig();
     const sched = deps.backend ?? selectBackend();
-    if (!sched.inspectBindings) {
-        throw new ConfigError(`Scheduler backend "${sched.name}" cannot provide one coherent inspection for transactional sync.`, "INVALID_CONFIG_FILE");
+    const installed = await listInstalledRows(sched);
+    // A config that predates `scheduler.enabled` means "keep what is
+    // installed": the akm-written rows become the host's choice (written
+    // unless this is a dry run) before the desired set, which would otherwise
+    // remove them, is computed.
+    let enabledRefs = schedulerEnabledRefs(config);
+    if (enabledRefs === undefined) {
+        enabledRefs = initializeSchedulerChoice(installed, config, { write: options.dryRun !== true });
+        if (options.dryRun !== true)
+            config = loadConfig();
     }
-    const inspection = await sched.inspectBindings({ rebind: options.rebind === true });
-    const rawEntries = [...inspection.installed];
-    const allEntries = rawEntries.map((entry) => {
-        const contextPath = "contextPath" in entry ? entry.contextPath : "";
-        // #846: recover the resolved bundle path this entry was installed
-        // under from its own scheduler-context descriptor. Any failure (no
-        // descriptor, unreadable, corrupt, owned by another user) leaves
-        // ownerBundlePath unset — belongsToBundle must never treat that as
-        // "mine".
-        const ownerBundlePath = contextPath ? resolveInstalledOwnerPath(contextPath) : undefined;
-        return {
-            ...entry,
-            ...(entry.nativeId !== undefined ? { nativeId: entry.nativeId } : {}),
-            ...(entry.invocation !== undefined ? { invocation: Object.freeze([...entry.invocation]) } : {}),
-            binding: "binding" in entry ? [...entry.binding] : [],
-            contextPath,
-            ...(ownerBundlePath !== undefined ? { ownerBundlePath } : {}),
-        };
-    });
-    const nativeArtifacts = inspection.artifacts;
-    const configuredSources = resolveConfiguredSources(config);
     const activeSources = resolveActiveConfiguredSources(config);
-    const sourceNames = bundleTarget ? [bundleTarget] : activeSources.map((source) => source.name);
-    const inactiveOperations = bundleTarget
-        ? []
-        : inactiveBundleRemovalOperations(config, configuredSources, allEntries, nativeArtifacts);
-    if (!bundleTarget && sourceNames.length === 0 && configuredSources.length > 0) {
-        assertSchedulerBackendInspection({ installed: allEntries, artifacts: nativeArtifacts });
-        const plan = emptySchedulerSyncPlan(inactiveOperations);
-        return { sched, plan, sourceSnapshots: Object.freeze([]), prepared: undefined, warnings: [] };
-    }
-    const selectedNames = sourceNames.length > 0 ? sourceNames : [undefined];
-    const enabled = activeSchedulerActivations(config);
-    const enabledActivations = new Set(enabled.map((activation) => `${activation.kind}\0${activation.ref}`));
-    const preparedSets = [];
-    for (const sourceName of selectedNames) {
-        const resolved = resolveTaskReadBundle(undefined, sourceName);
-        const stashDir = resolved.source.path;
-        const syncTarget = sourceName !== undefined && !isPrimaryStashPath(stashDir) ? sourceName : undefined;
-        const common = {
-            sourceRoot: stashDir,
-            adapterId: resolved.source.adapterId ?? detectAdapterId(stashDir),
-            bundleName: resolved.source.name,
-            ...(syncTarget === undefined ? { bundlePath: path.resolve(stashDir) } : {}),
-            ...(syncTarget ? { bundleTarget: syncTarget } : {}),
-            backend: sched.name,
-            installed: allEntries,
-            nativeArtifacts,
-            inspection: Object.freeze({ installed: allEntries, artifacts: nativeArtifacts }),
-            enabledActivations,
-            rebind: options.rebind === true,
-            config,
-            resolveAsset: taskProjectionAssetResolver(config, resolved.source.name, stashDir),
-        };
-        preparedSets.push({
-            common,
-            preparedSources: await prepareSchedulerSyncSourceSet(common),
-            ...(syncTarget ? { syncTarget } : {}),
-        });
+    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");
+        }
     }
-    // Pass one validates every selected bundle and computes whether any desired
-    // activation needs a new runtime descriptor before native mutation begins.
-    const preflights = preparedSets.map(({ common, preparedSources }) => finalizeSchedulerSyncPlan(common, preparedSources));
-    const warnings = [];
-    const expectedSignature = sched.expectedSignature?.bind(sched);
-    const needsRuntime = preflights.some((preflight) => preflight.operations.some((operation) => operation.kind !== "remove" && operation.options?.binding === undefined));
-    const prepared = needsRuntime
-        ? prepareSchedulerSyncRuntime(undefined, deps, warnings, allEntries.map((entry) => entry.binding))
-        : undefined;
-    const plans = preparedSets.map(({ common, preparedSources, syncTarget }) => finalizeSchedulerSyncPlan({
-        ...common,
-        ...(prepared?.options
-            ? { installOptions: { ...prepared.options, ...(syncTarget ? { target: syncTarget } : {}) } }
-            : syncTarget
-                ? { installOptions: { target: syncTarget } }
-                : {}),
-        ...(expectedSignature
-            ? {
-                expectedSignature: (binding, install) => expectedSignature(binding, install),
-            }
-            : {}),
-    }, preparedSources));
-    assertNoCrossBundleSchedulerCollisions(plans);
-    const representedRefs = new Set(plans.flatMap((candidate) => [
-        ...candidate.desired.map((binding) => binding.logicalSource.ref),
-        ...candidate.failures.flatMap((failure) => (failure.ref ? [failure.ref] : [])),
-    ]));
-    const selectedBundleNames = new Set(preparedSets.map(({ common }) => common.bundleName));
-    const missingActivationFailures = enabled
-        .filter((activation) => {
-        const bundle = parseBundleRef(activation.ref).bundle;
-        return bundle !== undefined && selectedBundleNames.has(bundle) && !representedRefs.has(activation.ref);
-    })
-        .map((activation) => ({
-        path: activation.ref,
-        ref: activation.ref,
-        reason: `Enabled ${activation.kind} ${JSON.stringify(activation.ref)} was not found or has no schedule.`,
-    }));
-    const first = plans[0];
-    if (!first)
-        throw new ConfigError("No configured bundle is available for scheduler sync.", "INVALID_CONFIG_FILE");
-    const plan = Object.freeze({
-        desired: Object.freeze(plans.flatMap((candidate) => candidate.desired)),
-        installed: Object.freeze(plans.flatMap((candidate) => candidate.installed)),
-        updated: Object.freeze(plans.flatMap((candidate) => candidate.updated)),
-        removed: Object.freeze([
-            ...plans.flatMap((candidate) => candidate.removed),
-            ...inactiveOperations.map((operation) => operation.id),
-        ]),
-        unchanged: Object.freeze(plans.flatMap((candidate) => candidate.unchanged)),
-        operations: Object.freeze([...plans.flatMap((candidate) => candidate.operations), ...inactiveOperations]),
-        sourceSnapshot: first.sourceSnapshot,
-        failures: Object.freeze([...plans.flatMap((candidate) => candidate.failures), ...missingActivationFailures]),
-    });
-    return { sched, plan, sourceSnapshots: plans.map((candidate) => candidate.sourceSnapshot), prepared, warnings };
-}
-function inactiveBundleRemovalOperations(config, configuredSources, installed, artifacts) {
+    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 enabledRefSet = new Set(enabledRefs);
+    const desired = [];
+    const failures = [];
+    const keepRefs = new Set();
+    const scopes = [];
+    // Each bundle is its own item: one that cannot be read is reported and
+    // left untouched while the others reconcile. A scoped sync has only that
+    // bundle, so its failure is the whole operation's.
+    for (const name of selected) {
+        try {
+            const resolved = resolveTaskReadBundle(undefined, name);
+            const stashDir = resolved.source.path;
+            const adapterId = resolved.source.adapterId ?? detectAdapterId(stashDir);
+            const compiled = await compileSchedulerSources({
+                sourceRoot: stashDir,
+                adapterId,
+                bundleName: resolved.source.name,
+                backend: sched.name,
+                config,
+                resolveAsset: taskProjectionAssetResolver(config, resolved.source.name, stashDir),
+                enabledRefs: enabledRefSet,
+            });
+            desired.push(...compiled.desired);
+            failures.push(...compiled.failures);
+            for (const failure of compiled.failures)
+                if (failure.ref)
+                    keepRefs.add(failure.ref);
+            scopes.push({ ...bundleScope(resolved.source.name, stashDir), adapterId });
+        }
+        catch (cause) {
+            if (bundleTarget)
+                throw cause;
+            failures.push({ path: name ?? "(default bundle)", reason: errorMessage(cause) });
+        }
+    }
+    // An enabled ref of a synced bundle that produced nothing names a source
+    // that is gone or has no schedule; its row, if any, is removed below.
+    const represented = new Set([...desired.map((binding) => binding.logicalSource.ref), ...keepRefs]);
+    const synced = new Set(scopes.map((scope) => scope.bundleName));
+    for (const ref of enabledRefs) {
+        const bundle = parseBundleRef(ref).bundle;
+        if (bundle !== undefined && synced.has(bundle) && !represented.has(ref)) {
+            failures.push({ path: ref, ref, reason: `Enabled ref ${JSON.stringify(ref)} was not found or has no schedule.` });
+        }
+    }
+    // A disabled bundle's rows go on an unscoped sync, without reading its content.
     const inactive = new Set(configuredSources.filter((source) => source.enabled === false).map((source) => source.name));
-    if (inactive.size === 0)
-        return [];
-    return installed
-        .map((entry) => ({ entry, bundleName: installedSchedulerBundle(config, entry) }))
-        .filter((candidate) => candidate.bundleName !== undefined && inactive.has(candidate.bundleName))
-        .sort((left, right) => left.entry.id.localeCompare(right.entry.id))
-        .map(({ entry, bundleName }) => {
-        const adapterId = bundleComponentConfig(config.bundles?.[bundleName])?.adapter ?? "akm";
-        return buildSchedulerRemoveOperation(entry.id, entry, artifacts, { adapterId, bundleName });
+    const extraRemovals = bundleTarget
+        ? []
+        : installed.filter((row) => {
+            const bundle = installedSchedulerBundle(config, row);
+            return bundle !== undefined && inactive.has(bundle);
+        });
+    const runtime = prepareSchedulerRuntime(deps);
+    const plan = planSchedulerSync({
+        desired,
+        installed,
+        scopes,
+        ...(sched.expectedSignature ? { expectedSignature: sched.expectedSignature.bind(sched) } : {}),
+        installOptions: runtime.options,
+        rebind: options.rebind === true,
+        extraRemovals,
+        keepRefs,
     });
+    const warnings = [];
+    const writesLauncher = options.rebind === true
+        ? plan.operations.some((operation) => operation.kind !== "remove")
+        : plan.installed.length > 0;
+    if (runtime.via === "checkout" && writesLauncher) {
+        warnings.push(`Scheduled tasks now run akm from a source checkout (${runtime.options.binding?.join(" ")}); they run whatever the checkout holds when they fire. Install akm with \`npm install --global akm-cli\` or a standalone release, then run \`akm task sync --rebind\`.`);
+    }
+    return { sched, plan: { ...plan, failures: [...failures, ...plan.failures] }, warnings };
 }
-function installedSchedulerBundle(config, entry) {
-    const direct = entry.target ?? (entry.invocation ? scheduledInvocationBundle(entry.invocation) : undefined);
-    if (direct !== undefined)
-        return direct;
-    if (entry.ownerBundlePath === undefined)
-        return undefined;
-    return bundleKeyForContentRoot(config, entry.ownerBundlePath);
+/**
+ * The launcher and environment rows are written with. The environment
+ * follows the current policy on every sync; a row that is already installed
+ * keeps its launcher unless `--rebind` (see `installOptionsFor`). An injected
+ * backend (tests) renders with its own launcher.
+ */
+function prepareSchedulerRuntime(deps) {
+    const environment = scheduledRowEnvironment();
+    if (deps.schedulerRuntime) {
+        const runtime = deps.schedulerRuntime();
+        return { options: { binding: runtime.binding, environment }, ...(runtime.via ? { via: runtime.via } : {}) };
+    }
+    if (deps.backend)
+        return { options: { environment } };
+    const invocation = resolveAkmInvocation();
+    return { options: { binding: invocation.argv, environment }, via: invocation.via };
 }
-function emptySchedulerSyncPlan(operations) {
-    const sourceSnapshot = Object.freeze({
-        adapterId: "akm",
-        sourceRoot: "",
-        sourceRealPath: "",
-        sourcePhysicalIdentity: "inactive",
-        sourceDirectoryVersion: "inactive",
-        files: Object.freeze([]),
-        directoryManifests: Object.freeze([]),
-    });
-    return Object.freeze({
-        desired: Object.freeze([]),
-        installed: Object.freeze([]),
-        updated: Object.freeze([]),
-        removed: Object.freeze(operations.map((operation) => operation.id)),
-        unchanged: Object.freeze([]),
-        operations: Object.freeze([...operations]),
-        sourceSnapshot,
-        failures: Object.freeze([]),
+/** One read of the akm-owned rows, each attributed to the bundle path it names (#846). */
+async function listInstalledRows(sched) {
+    return (await sched.list()).map((row) => {
+        const ownerBundlePath = installedRowBundleDir(row);
+        return ownerBundlePath !== undefined ? { ...row, ownerBundlePath } : row;
     });
 }
-function scheduledInvocationBundle(invocation) {
-    const bundleIndex = invocation.indexOf("--bundle");
-    if (bundleIndex >= 0)
-        return invocation[bundleIndex + 1];
-    if (invocation[0] === "workflow" && invocation[1] === "run" && invocation[2]) {
-        try {
-            return parseBundleRef(invocation[2]).bundle;
-        }
-        catch {
-            return undefined;
-        }
+/**
+ * The `AKM_BUNDLE_DIR` an installed row names: its inline one, or the one in
+ * the descriptor a row written before 0.9.17-alpha.7 references. Undefined
+ * when it names none, or its descriptor cannot be read — which never means
+ * "mine".
+ */
+function installedRowBundleDir(row) {
+    if (row.contextPath === undefined)
+        return row.environment?.AKM_BUNDLE_DIR;
+    try {
+        return readLegacySchedulerContext(row.contextPath).AKM_BUNDLE_DIR;
     }
-    return undefined;
-}
-function assertNoCrossBundleSchedulerCollisions(plans) {
-    const owners = new Map();
-    for (const binding of plans.flatMap((plan) => plan.desired)) {
-        const key = schedulerNativeArtifactKey(schedulerBindingNativeId(binding));
-        const existing = owners.get(key);
-        if (existing && existing.logicalSource.ref !== binding.logicalSource.ref) {
-            throw new UsageError(`Scheduler native id ${JSON.stringify(schedulerBindingNativeId(binding))} is claimed by both ` +
-                `${JSON.stringify(existing.logicalSource.ref)} and ${JSON.stringify(binding.logicalSource.ref)}. ` +
-                "Rename one task before enabling both.", "RESOURCE_ALREADY_EXISTS");
-        }
-        owners.set(key, binding);
+    catch {
+        return undefined;
     }
 }
-export async function akmTasksSync(deps = {}, bundleTarget, options = {}) {
-    const { sched, plan, sourceSnapshots, prepared, warnings } = await buildSchedulerSyncPlan(deps, bundleTarget, options);
-    await applySchedulerSyncPlan(sched, plan, prepared?.publish && plan.operations.some((operation) => operation.kind !== "remove")
-        ? prepared.publish
-        : undefined, sourceSnapshots);
-    return {
-        installed: [...plan.installed],
-        updated: [...plan.updated],
-        removed: [...plan.removed],
-        unchanged: [...plan.unchanged],
-        skipped: [],
-        backend: sched.name,
-        failures: plan.failures.map((failure) => ({ ...failure })),
-        ...(warnings.length > 0 ? { warnings } : {}),
-    };
+/** The primary bundle proves its rows by path (#846); any other bundle by its config name. */
+function bundleScope(bundleName, stashDir) {
+    return isPrimaryStashPath(stashDir) ? { bundleName, bundlePath: path.resolve(stashDir) } : { bundleName };
 }
-/**
- * `akm task sync --dry-run` (#849): compute the exact same plan
- * `akmTasksSync` would apply, then return a non-mutating preview instead of
- * calling `applySchedulerSyncPlan`. `buildSchedulerSyncPlan` is shared with
- * the real sync path specifically so this can never see a different plan
- * than the one a real sync would apply — and specifically so this function
- * never even holds a reference to a callable `publish` closure past this
- * point: `prepared.publish`, if any, is dropped on the floor here, never
- * invoked. Zero durable writes, mirroring `akm workflow plan`.
- */
-export async function akmTasksSyncPlan(deps = {}, bundleTarget, options = {}) {
-    const { sched, plan } = await buildSchedulerSyncPlan(deps, bundleTarget, options);
-    return renderSchedulerSyncPlanPreview(sched.name, plan);
+function installedSchedulerBundle(config, row) {
+    const direct = row.target ?? scheduledInvocationBundle(row.invocation);
+    if (direct !== undefined)
+        return direct;
+    if (row.ownerBundlePath === undefined)
+        return undefined;
+    return bundleKeyForContentRoot(config, row.ownerBundlePath);
 }
 /**
- * Classify one installed scheduler binding as a prune candidate (#851), using
- * the same two signals `doctor`'s `inspectInstalledBinding` already computes
- * — deliberately narrower than that function's full `status` set. Only an
- * entry whose ownership can NEVER be resolved (`invalid-context`) or whose
- * resolved owner no longer exists on disk (`dead-bundle-path`) is a
- * candidate; `missing-path` (e.g. the akm binary itself moved) is a
- * different failure mode and is intentionally NOT folded in here, per the
- * scoping in #851 — an entry that still resolves to a live bundle is never a
- * candidate, full stop.
+ * Why `akm task prune` (#851) would remove an installed row: a row written
+ * before 0.9.17-alpha.7 whose descriptor cannot be read (`invalid-context`),
+ * or one naming a bundle directory that is gone (`dead-bundle-path`). A row
+ * that still resolves to a live bundle is never a candidate.
  */
 function classifyPruneCandidate(entry) {
-    let ownerBundlePath;
-    try {
-        ownerBundlePath = validateSchedulerContextDescriptor(entry.contextPath).environment.AKM_BUNDLE_DIR;
+    let bundleDir;
+    if (entry.contextPath !== undefined) {
+        try {
+            bundleDir = readLegacySchedulerContext(entry.contextPath).AKM_BUNDLE_DIR;
+        }
+        catch {
+            return "invalid-context";
+        }
+        // Every descriptor akm wrote names the bundle; one that does not cannot be attributed.
+        if (bundleDir === undefined)
+            return "invalid-context";
     }
-    catch {
-        return "invalid-context";
+    else {
+        bundleDir = entry.environment?.AKM_BUNDLE_DIR;
     }
-    if (ownerBundlePath !== undefined && !fs.existsSync(ownerBundlePath))
+    if (bundleDir !== undefined && !fs.existsSync(bundleDir))
         return "dead-bundle-path";
     return undefined;
 }
-async function buildTaskPrunePlan(deps = {}, options = {}) {
-    const sched = deps.backend ?? selectBackend();
-    if (!sched.inspectBindings) {
-        throw new ConfigError(`Scheduler backend "${sched.name}" cannot provide one coherent inspection for prune.`, "INVALID_CONFIG_FILE");
-    }
-    const inspection = await sched.inspectBindings({});
-    const candidates = new Map();
-    for (const entry of inspection.installed) {
-        const reason = classifyPruneCandidate(entry);
-        if (reason)
-            candidates.set(entry.id, reason);
-    }
-    const requestedIds = options.id?.filter((id) => id.length > 0) ?? [];
-    for (const id of requestedIds) {
-        if (!candidates.has(id)) {
-            throw new UsageError(`Scheduler binding ${JSON.stringify(id)} is not an orphaned prune candidate ` +
-                "(either not installed, or it still resolves to a live bundle) — refusing to prune it.", "INVALID_FLAG_VALUE");
-        }
-    }
-    const idFilter = requestedIds.length > 0 ? new Set(requestedIds) : undefined;
-    const resolved = resolveTaskReadBundle(undefined, undefined);
-    const bundleContext = {
-        adapterId: resolved.source.adapterId ?? detectAdapterId(resolved.source.path),
-        bundleName: resolved.source.name,
-    };
-    const operations = [];
-    for (const entry of inspection.installed) {
-        const reason = candidates.get(entry.id);
-        if (!reason)
-            continue;
-        if (idFilter && !idFilter.has(entry.id))
-            continue;
-        const operation = buildSchedulerRemoveOperation(entry.id, entry, inspection.artifacts, bundleContext);
-        operations.push(Object.freeze({ ...operation, reason }));
-    }
-    return { sched, operations: Object.freeze(operations) };
-}
 /**
- * `akm task prune` (#851): remove installed scheduler bindings `sync` can
- * never reclaim because their own `--scheduler-context` descriptor doesn't
- * resolve to a live bundle. Defaults to dry-run — no `--yes` and no `--id`
- * means zero backend calls that could mutate anything, matching
- * `akmTasksSyncPlan`'s zero-write guarantee. `--id` (one or more) narrows
- * execution to exactly those bindings; `--yes` alone executes every
- * currently-computed candidate. Both still return the full preview so the
- * plan is never silent about what it did.
+ * `akm task prune` (#851): remove installed rows `sync` can never reclaim
+ * because they no longer resolve to a live bundle. It scans
+ * every installed row, not one bundle's. Without `--yes` it only previews and
+ * writes nothing; `--id` narrows it to named candidates.
  */
 export async function akmTasksPrune(deps = {}, options = {}) {
-    const { sched, operations } = await buildTaskPrunePlan(deps, options);
-    const preview = renderSchedulerPlanPreview(sched.name, operations);
-    if (!options.yes) {
-        return { backend: sched.name, dryRun: true, preview, removed: [] };
-    }
-    await applySchedulerTransaction(sched, operations, {
-        initialExpectations: operations.map((operation) => operation.expected),
-    });
-    return {
-        backend: sched.name,
-        dryRun: false,
-        preview,
-        removed: operations.map((operation) => operation.id),
+    const prune = async () => {
+        const sched = deps.backend ?? selectBackend();
+        const operations = pruneOperations(await sched.list(), options.id ?? []);
+        const preview = renderSchedulerPlanPreview(sched.name, operations);
+        if (!options.yes)
+            return { backend: sched.name, dryRun: true, preview, removed: [] };
+        for (const operation of operations)
+            await sched.uninstall(operation.nativeId);
+        return { backend: sched.name, dryRun: false, preview, removed: operations.map((operation) => operation.id) };
     };
+    return options.yes ? withSchedulerLock(prune) : prune();
+}
+function pruneOperations(installed, requestedIds) {
+    const candidates = installed.flatMap((row) => {
+        const reason = classifyPruneCandidate(row);
+        return reason ? [{ row, reason }] : [];
+    });
+    const ids = requestedIds.filter((id) => id.length > 0);
+    for (const id of ids) {
+        if (!candidates.some(({ row }) => row.id === id)) {
+            throw new UsageError(`Scheduler binding ${JSON.stringify(id)} is not an orphaned prune candidate ` +
+                "(either not installed, or it still resolves to a live bundle) — refusing to prune it.", "INVALID_FLAG_VALUE");
+        }
+    }
+    return candidates
+        .filter(({ row }) => ids.length === 0 || ids.includes(row.id))
+        .map(({ row, reason }) => ({ kind: "remove", id: row.id, nativeId: installedRowNativeId(row), reason }));
 }
 export async function akmTasksDoctor(deps = {}) {
     const warnings = [];
-    let invocation = {
-        argv: [],
-        via: "unresolved",
-    };
+    let invocation = { argv: [], via: "unresolved" };
     try {
         const r = (deps.resolveInvocation ?? resolveAkmInvocation)();
-        invocation = { argv: r.argv, via: r.via, kind: r.kind, eligible: r.eligible };
+        invocation = { argv: r.argv, via: r.via };
     }
     catch (err) {
         warnings.push(err instanceof Error ? err.message : String(err));
@@ -718,7 +590,7 @@ export async function akmTasksDoctor(deps = {}) {
             warnings.push(`Unable to inspect installed ${backend} definitions: ${error instanceof Error ? error.message : String(error)}`);
         }
     }
-    const bindings = groupInstalledBindings(installed, invocation);
+    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());
@@ -748,7 +620,6 @@ export async function akmTasksDoctor(deps = {}) {
             defaultStrategy: improveStrategyName,
             enabled: triage.enabled === true,
             applyMode: triage.applyMode ?? "queue",
-            policy: triage.policy ?? "personal-stash",
         }
         : undefined;
     return {
@@ -769,298 +640,11 @@ export async function akmTasksDoctor(deps = {}) {
     };
 }
 // ── helpers ─────────────────────────────────────────────────────────────────
-async function applySchedulerSyncPlan(backend, plan, publish, sourceSnapshots = [plan.sourceSnapshot]) {
-    await applySchedulerTransaction(backend, plan.operations, {
-        initialExpectations: plan.operations.map((operation) => operation.expected),
-        assertReadSet: () => {
-            for (const snapshot of sourceSnapshots)
-                assertSchedulerSourceSnapshot(snapshot);
-        },
-        beforeOperation: (_operation, index) => {
-            if (index === 0)
-                publish?.();
-        },
-    });
-}
-async function applySchedulerTransaction(backend, operations, hooks) {
-    if (operations.length === 0) {
-        hooks.assertReadSet?.();
-        await hooks.afterOperations?.();
-        hooks.assertReadSet?.();
-        return;
-    }
-    hooks.assertReadSet?.();
-    if (!backend.snapshotBindings || !backend.restoreBindings) {
-        throw new ConfigError(`Scheduler backend "${backend.name}" cannot snapshot and restore a whole-set transaction.`, "INVALID_CONFIG_FILE");
-    }
-    const nativeIds = [
-        ...new Set(operations.map((operation) => operation.kind === "remove" ? operation.nativeId : schedulerBindingNativeId(operation.binding))),
-    ];
-    const snapshot = await backend.snapshotBindings(nativeIds);
-    assertSchedulerTransactionSnapshot(snapshot, nativeIds, hooks.initialExpectations);
-    const rollbackExpected = schedulerRollbackExpectations(snapshot, operations);
-    hooks.assertReadSet?.();
-    try {
-        for (const [index, operation] of operations.entries()) {
-            hooks.assertReadSet?.();
-            await hooks.beforeOperation?.(operation, index);
-            hooks.assertReadSet?.();
-            if (operation.kind === "remove")
-                await backend.uninstall(operation.nativeId, operation.expected);
-            else
-                await backend.install(operation.binding, operation.options, operation.expected);
-            hooks.assertReadSet?.();
-        }
-        hooks.assertReadSet?.();
-        await hooks.afterOperations?.();
-        hooks.assertReadSet?.();
-    }
-    catch (primaryError) {
-        let externalRollbackError;
-        try {
-            await hooks.rollbackExternal?.();
-        }
-        catch (error) {
-            externalRollbackError = error;
-        }
-        let nativeRollbackError;
-        const externalStateAllowsNativeRollback = externalRollbackError !== undefined &&
-            hooks.allowNativeRollbackAfterExternalFailure?.(externalRollbackError) === true;
-        if (!(externalRollbackError && hooks.suppressNativeRollbackWhenExternalFails && !externalStateAllowsNativeRollback)) {
-            try {
-                await backend.restoreBindings(snapshot, rollbackExpected);
-            }
-            catch (error) {
-                nativeRollbackError = error;
-            }
-        }
-        const rollbackErrors = [externalRollbackError, nativeRollbackError].filter((error) => error !== undefined);
-        if (rollbackErrors.length > 0) {
-            throw new AggregateError([primaryError, ...rollbackErrors], `Scheduler transaction failed and rollback was incomplete: ${errorMessage(primaryError)}`);
-        }
-        throw primaryError;
-    }
-}
-function schedulerRollbackExpectations(snapshot, operations) {
-    return Object.freeze(snapshot.nativeIds.map((nativeId) => {
-        const prior = snapshot.artifacts.find((artifact) => schedulerNativeArtifactKey(artifact.nativeId) === schedulerNativeArtifactKey(nativeId));
-        const allowed = [];
-        if (prior) {
-            if (prior.fingerprint === undefined) {
-                throw new ConfigError(`Scheduler backend snapshot for ${JSON.stringify(nativeId)} has no exact fingerprint.`, "INVALID_CONFIG_FILE");
-            }
-            allowed.push(Object.freeze({
-                state: "present",
-                ...(prior.bindingId !== undefined ? { bindingId: prior.bindingId } : {}),
-                ...(prior.invocation !== undefined ? { invocation: Object.freeze([...prior.invocation]) } : {}),
-                fingerprint: prior.fingerprint,
-            }));
-        }
-        else {
-            allowed.push(Object.freeze({ state: "absent" }));
-        }
-        const matchingOperations = operations.filter((candidate) => {
-            const operationNativeId = candidate.kind === "remove" ? candidate.nativeId : schedulerBindingNativeId(candidate.binding);
-            return schedulerNativeArtifactKey(operationNativeId) === schedulerNativeArtifactKey(nativeId);
-        });
-        for (const operation of matchingOperations) {
-            if (operation.kind === "remove") {
-                if (!allowed.some((state) => state.state === "absent")) {
-                    allowed.push(Object.freeze({ state: "absent" }));
-                }
-                continue;
-            }
-            if (operation.resultFingerprint === undefined) {
-                throw new ConfigError(`Scheduler backend cannot freeze the post-mutation fingerprint for ${JSON.stringify(nativeId)}.`, "INVALID_CONFIG_FILE");
-            }
-            allowed.push(Object.freeze({
-                state: "present",
-                bindingId: operation.binding.id,
-                invocation: Object.freeze([...operation.binding.invocation]),
-                fingerprint: operation.resultFingerprint,
-            }));
-        }
-        return Object.freeze({ nativeId, allowed: Object.freeze(allowed) });
-    }));
-}
-function assertSchedulerTransactionSnapshot(snapshot, nativeIds, initialExpectations) {
-    if (!snapshot ||
-        !Array.isArray(snapshot.nativeIds) ||
-        !Array.isArray(snapshot.artifacts) ||
-        nativeIds.some((nativeId) => !snapshot.nativeIds.includes(nativeId))) {
-        throw new ConfigError("Scheduler backend returned an incomplete transaction snapshot.", "INVALID_CONFIG_FILE");
-    }
-    const snapshotKeys = snapshot.nativeIds.map(schedulerNativeArtifactKey);
-    const requestedKeys = nativeIds.map(schedulerNativeArtifactKey);
-    if (snapshotKeys.length !== requestedKeys.length ||
-        new Set(snapshotKeys).size !== snapshotKeys.length ||
-        snapshotKeys.some((key) => !requestedKeys.includes(key))) {
-        throw new ConfigError("Scheduler backend returned an inexact normalized transaction snapshot set.", "INVALID_CONFIG_FILE");
-    }
-    for (const expected of initialExpectations) {
-        const artifact = assertSchedulerNativeArtifactCardinality(snapshot.artifacts, expected.nativeId, expected.state === "absent" ? 0 : 1);
-        assertSchedulerMutationArtifact(artifact, expected);
-    }
-}
-async function prepareTaskAddSchedulerTransaction(input) {
-    if (!input.sched.inspectBindings) {
-        throw new ConfigError(`Scheduler backend "${input.sched.name}" cannot provide one coherent inspection for transactional add.`, "INVALID_CONFIG_FILE");
-    }
-    if (!input.sched.snapshotBindings || !input.sched.restoreBindings || !input.sched.expectedSignature) {
-        throw new ConfigError(`Scheduler backend "${input.sched.name}" cannot provide exact snapshot, restore, and signature contracts for transactional add.`, "INVALID_CONFIG_FILE");
-    }
-    const inspection = await input.sched.inspectBindings({ rebind: input.rebind });
-    const installedEntries = [...inspection.installed];
-    const nativeArtifacts = [...inspection.artifacts];
-    const seenNativeKeys = new Set();
-    for (const artifact of nativeArtifacts) {
-        const key = schedulerNativeArtifactKey(artifact.nativeId);
-        if (seenNativeKeys.has(key)) {
-            throw new UsageError(`Scheduler inspection has duplicate normalized native artifact ${JSON.stringify(artifact.nativeId)}.`, "RESOURCE_ALREADY_EXISTS");
-        }
-        seenNativeKeys.add(key);
-    }
-    for (const binding of input.taskBindings) {
-        assertNoForeignSchedule(installedEntries, binding.id, input.ownerTarget);
-    }
-    const taskEntries = installedEntries.filter((entry) => installedEntryRunsTask(entry, input.id));
-    const foreignTaskEntry = taskEntries.find((entry) => !sameBundle(entry.target, input.ownerTarget));
-    if (foreignTaskEntry) {
-        throw new UsageError(foreignScheduleMessage(input.id, foreignTaskEntry.target), "RESOURCE_ALREADY_EXISTS");
-    }
-    assertSchedulerNativeArtifactOwnership(input.taskBindings, nativeArtifacts);
-    const primary = input.taskBindings[0];
-    if (!primary)
-        throw new Error("invariant: scheduler transaction has no desired binding");
-    const installedEntry = installedEntries.find((entry) => entry.id === primary.id) ?? taskEntries[0];
-    const preparedRuntime = installedEntry && !input.rebind
-        ? {
-            options: {
-                ...input.installOpts,
-                binding: Object.freeze([...installedEntry.binding]),
-                contextPath: installedEntry.contextPath,
-            },
-        }
-        : prepareSchedulerSyncRuntime(input.installOpts, input.deps, []);
-    const runtimeOpts = preparedRuntime.options;
-    const removals = taskEntries.map((entry) => {
-        const invocation = entry.invocation;
-        const nativeId = entry.nativeId ?? schedulerNativeBindingId(entry.id);
-        const artifact = assertSchedulerNativeArtifactCardinality(nativeArtifacts, nativeId, 1);
-        if (!artifact?.fingerprint || artifact.bindingId !== entry.id) {
-            throw new UsageError(`Installed scheduler binding ${JSON.stringify(entry.id)} has no exact coherent fingerprint.`, "RESOURCE_ALREADY_EXISTS");
-        }
-        const logicalSource = primary.logicalSource;
-        const ordinal = invocation ? schedulerBindingOrdinal(entry.id, logicalSource, invocation) : undefined;
-        if (!invocation || ordinal === undefined) {
-            warn(`Installed scheduler binding ${JSON.stringify(entry.id)} (native id ${JSON.stringify(nativeId)}) could not be exactly parsed — likely a hand-edited entry; replacing it without a compare-and-swap guard.`);
-            return Object.freeze({
-                kind: "remove",
-                id: entry.id,
-                nativeId,
-            });
-        }
-        return Object.freeze({
-            kind: "remove",
-            id: entry.id,
-            nativeId,
-            expected: Object.freeze({
-                bindingId: entry.id,
-                nativeId,
-                logicalSource,
-                ordinal,
-                invocation: Object.freeze([...invocation]),
-                fingerprint: artifact.fingerprint,
-            }),
-        });
-    });
-    const installs = input.taskBindings.map((binding) => {
-        const nativeId = schedulerBindingNativeId(binding);
-        const resultFingerprint = input.sched.expectedSignature(binding, runtimeOpts);
-        if (!resultFingerprint) {
-            throw new ConfigError(`Scheduler backend "${input.sched.name}" cannot freeze the post-install fingerprint for ${JSON.stringify(binding.id)}.`, "INVALID_CONFIG_FILE");
-        }
-        return Object.freeze({
-            kind: "install",
-            binding,
-            expected: Object.freeze({
-                state: "absent",
-                bindingId: binding.id,
-                nativeId,
-                logicalSource: binding.logicalSource,
-                ordinal: binding.ordinal,
-                invocation: binding.invocation,
-            }),
-            resultFingerprint,
-            ...(runtimeOpts ? { options: runtimeOpts } : {}),
-        });
-    });
-    const initialByKey = new Map();
-    for (const removal of removals) {
-        if (removal.kind !== "remove")
-            continue;
-        if (!removal.expected)
-            continue;
-        initialByKey.set(schedulerNativeArtifactKey(removal.nativeId), Object.freeze({ ...removal.expected, state: "present" }));
-    }
-    for (const install of installs) {
-        if (install.kind === "remove")
-            continue;
-        const key = schedulerNativeArtifactKey(schedulerBindingNativeId(install.binding));
-        if (!initialByKey.has(key))
-            initialByKey.set(key, install.expected);
-    }
-    return Object.freeze({
-        runtimeOpts,
-        ...(preparedRuntime.publish ? { publishRuntime: preparedRuntime.publish } : {}),
-        operations: Object.freeze([...removals, ...installs]),
-        initialExpectations: Object.freeze([...initialByKey.values()]),
-        publishOperationIndex: removals.length,
-    });
-}
-function prepareSchedulerSyncRuntime(base, deps, warnings, installedBindings = []) {
-    if (deps.backend && !deps.schedulerRuntime)
-        return base ? { options: base } : {};
-    if (deps.schedulerRuntime) {
-        const runtime = deps.schedulerRuntime();
-        warnIneligibleRebind(runtime, warnings, installedBindings);
-        return { options: { ...base, binding: runtime.binding, contextPath: runtime.contextPath } };
-    }
-    const invocation = resolveAndValidateSchedulerInvocation();
-    warnIneligibleRebind(invocation, warnings, installedBindings);
-    const descriptor = schedulerContextDescriptor();
-    const contextPath = schedulerContextPath(descriptor);
-    return {
-        options: { ...base, binding: invocation.binding, contextPath },
-        publish: () => {
-            const written = writeSchedulerContextDescriptor(descriptor);
-            if (written !== contextPath) {
-                throw new ConfigError("Scheduler context descriptor path changed after preflight.", "INVALID_CONFIG_FILE");
-            }
-        },
-    };
-}
-function resolveAndValidateSchedulerInvocation() {
-    const invocation = resolveAkmInvocation();
-    return { binding: invocation.argv, contextPath: "", eligible: invocation.eligible, kind: invocation.kind };
-}
-function warnIneligibleRebind(runtime, warnings, installedBindings) {
-    if (runtime.eligible !== false || warnings.length > 0)
-        return;
-    // #868 residue: binding every currently-installed entry to the SAME
-    // invocation it already carries changes nothing — this is the steady
-    // state of an image-baked install re-running `task sync` on a timer.
-    // Only warn when the bind actually moves an entry to a different
-    // invocation.
-    if (installedBindings.length > 0 && installedBindings.every((bound) => sameArgv(bound, runtime.binding)))
-        return;
-    warnings.push(`Scheduled tasks are bound to an ineligible ${runtime.kind ?? "unknown"} invocation (${runtime.binding.join(" ")}); scheduled runs will invoke a mutable, unproven binary. Install akm via \`npm install --global akm-cli\` or a standalone release, then re-run \`akm task sync --rebind\`.`);
-}
-function groupInstalledBindings(entries, invocation) {
+function groupInstalledBindings(entries) {
     const groups = new Map();
     for (const entry of entries) {
         const argv = [...entry.binding];
-        const status = inspectInstalledBinding(entry, invocation);
+        const status = inspectInstalledBinding(entry);
         const key = JSON.stringify([argv, entry.contextPath, status]);
         const existing = groups.get(key);
         if (existing) {
@@ -1069,192 +653,43 @@ function groupInstalledBindings(entries, invocation) {
         }
         groups.set(key, {
             argv,
-            contextPath: entry.contextPath,
+            ...(entry.contextPath !== undefined ? { contextPath: entry.contextPath } : {}),
             taskIds: [entry.id],
             status,
         });
     }
     return [...groups.values()].map((group) => ({ ...group, taskIds: group.taskIds.sort() }));
 }
-/** Best-effort recovery of an installed binding's owning bundle path (#846). */
-function resolveInstalledOwnerPath(contextPath) {
-    try {
-        return validateSchedulerContextDescriptor(contextPath).environment.AKM_BUNDLE_DIR;
-    }
-    catch {
-        return undefined;
-    }
-}
-function inspectInstalledBinding(entry, invocation) {
+function inspectInstalledBinding(entry) {
     const status = [];
     const binding = entry.binding;
-    if (!(invocation.eligible === true && sameArgv(binding, invocation.argv)) &&
-        binding.some((part) => /(?:^|[\\/])src[\\/]cli\.ts$|(?:^|[\\/])dist[\\/](?:cli\.js|cli-node\.mjs)$/i.test(part) ||
-            (path.isAbsolute(part) && hasGitAncestor(part)))) {
+    if (isCheckoutInvocation(binding))
         status.push("checkout");
-    }
     if (binding.some((part) => part === "akm" || part === "bun" || part === "node"))
         status.push("path-selected");
-    try {
-        validateSchedulerContextDescriptor(entry.contextPath);
-    }
-    catch {
-        status.push("invalid-context");
+    if (entry.contextPath !== undefined) {
+        try {
+            readLegacySchedulerContext(entry.contextPath);
+        }
+        catch {
+            status.push("invalid-context");
+        }
     }
-    const absolutePaths = [...binding.filter((part) => path.isAbsolute(part)), entry.contextPath];
+    const absolutePaths = binding.filter((part) => path.isAbsolute(part));
     if (absolutePaths.some((part) => !fs.existsSync(part)))
         status.push("missing-path");
     if (status.length === 0)
         status.push("ok");
     return status;
 }
-function sameArgv(left, right) {
-    return left.length === right.length && left.every((value, index) => value === right[index]);
-}
-function hasGitAncestor(file) {
-    let current;
-    try {
-        current = path.dirname(fs.realpathSync(file));
-    }
-    catch {
-        return false;
-    }
-    for (;;) {
-        if (fs.existsSync(path.join(current, ".git")))
-            return true;
-        const parent = path.dirname(current);
-        if (parent === current)
-            return false;
-        current = parent;
-    }
-}
 function taskAssetRef(id) {
     return { type: "task", name: id };
 }
-function captureTaskSourceExpectation(filePathInput, rootInput) {
-    const filePath = path.resolve(filePathInput);
-    const root = path.resolve(rootInput);
-    const lexicalRelative = path.relative(root, filePath);
-    if (lexicalRelative === "" || lexicalRelative.startsWith("..") || path.isAbsolute(lexicalRelative)) {
-        throw new UsageError(`${filePathInput} resolves outside the task source root.`, "PATH_ESCAPE_VIOLATION");
-    }
-    const rootRealPath = fs.realpathSync(root);
-    const rootStat = fs.statSync(rootRealPath, { bigint: true });
-    if (!rootStat.isDirectory()) {
-        throw new UsageError(`${root} is not a task source directory.`, "INVALID_FLAG_VALUE");
-    }
-    const common = { filePath, rootRealPath };
-    let descriptor;
-    try {
-        descriptor = fs.openSync(filePath, fs.constants.O_RDONLY);
-        let before = fs.fstatSync(descriptor, { bigint: true });
-        if (!before.isFile()) {
-            throw new UsageError(`${filePath} is not a regular task source.`, "INVALID_FLAG_VALUE");
-        }
-        let bytes = fs.readFileSync(descriptor);
-        const torn = !sameTaskSourceStat(before, fs.fstatSync(descriptor, { bigint: true })) ||
-            BigInt(bytes.byteLength) !== before.size;
-        if (torn) {
-            fs.closeSync(descriptor);
-            descriptor = fs.openSync(filePath, fs.constants.O_RDONLY);
-            before = fs.fstatSync(descriptor, { bigint: true });
-            bytes = fs.readFileSync(descriptor);
-            warn(`${filePath} changed while its guarded bytes were read; retried once and proceeding with the latest read (its SHA-256 is re-verified before anything is published).`);
-        }
-        const realPath = fs.realpathSync(filePath);
-        const physicalRelative = path.relative(rootRealPath, realPath);
-        if (physicalRelative === "" || physicalRelative.startsWith("..") || path.isAbsolute(physicalRelative)) {
-            throw new UsageError(`${filePath} resolves outside the task source root.`, "PATH_ESCAPE_VIOLATION");
-        }
-        let content;
-        try {
-            content = new TextDecoder("utf-8", { fatal: true, ignoreBOM: true }).decode(bytes);
-        }
-        catch {
-            throw new UsageError(`${filePath} contains invalid UTF-8 bytes.`, "INVALID_FLAG_VALUE");
-        }
-        return Object.freeze({
-            state: "present",
-            ...common,
-            realPath,
-            size: bytes.byteLength,
-            sha256: createHash("sha256").update(bytes).digest("hex"),
-            bytesBase64: bytes.toString("base64"),
-            content,
-        });
-    }
-    catch (cause) {
-        if (cause.code === "ENOENT") {
-            return Object.freeze({ state: "absent", ...common });
-        }
-        if (cause instanceof UsageError)
-            throw cause;
-        throw new UsageError(`${filePath} could not be guarded as a contained regular task source: ${errorMessage(cause)}`, "PATH_ESCAPE_VIOLATION");
-    }
-    finally {
-        if (descriptor !== undefined)
-            fs.closeSync(descriptor);
-    }
-}
-// TOCTOU note: this compares CONTENT (state + sha256), not filesystem
-// identity (inode/mtime/ctime/directory timestamps) — the same split already
-// applied to the task migrator in 0.9.5. An unrelated touch to the file or
-// its containing directory must not trip a "changed after planning" refusal;
-// only a real content change should.
-function assertTaskSourceExpectation(expected) {
-    const actual = captureTaskSourceExpectation(expected.filePath, expected.rootRealPath);
-    if (!sameTaskSourceExpectation(actual, expected)) {
-        throw new UsageError(`Task source ${JSON.stringify(expected.filePath)} changed after transaction planning.`, "RESOURCE_ALREADY_EXISTS");
-    }
-}
-function sameTaskSourceExpectation(left, right) {
-    if (left.state !== right.state || left.filePath !== right.filePath || left.rootRealPath !== right.rootRealPath) {
-        return false;
-    }
-    if (left.state === "absent")
-        return true;
-    return left.sha256 === right.sha256;
-}
-function assertTaskSourceRestored(expected) {
-    const actual = captureTaskSourceExpectation(expected.filePath, expected.rootRealPath);
-    const restored = actual.state === expected.state &&
-        (actual.state === "absent" ||
-            (expected.state === "present" && actual.sha256 === expected.sha256 && actual.content === expected.content));
-    if (!restored) {
-        throw new UsageError(`Task source ${JSON.stringify(expected.filePath)} could not be restored without replacing a concurrent owner.`, "RESOURCE_ALREADY_EXISTS");
-    }
-}
-class TaskSourceRestoredBoundaryError extends Error {
-    cause;
-    constructor(cause) {
-        super(errorMessage(cause));
-        this.name = "TaskSourceRestoredBoundaryError";
-        this.cause = cause;
-    }
-}
-function sameTaskSourceStat(left, right) {
-    return (left.dev === right.dev &&
-        left.ino === right.ino &&
-        left.mode === right.mode &&
-        left.size === right.size &&
-        left.mtimeNs === right.mtimeNs &&
-        left.ctimeNs === right.ctimeNs);
-}
-function hashTaskSource(source) {
-    return createHash("sha256").update(Buffer.from(source, "utf8")).digest("hex");
-}
-/**
- * Resolve the bundle a mutating/run task command targets. Returns the resolved
- * write/read target, its stash path, and the `--bundle <bundle>` token to embed
- * in scheduled invocations. The primary bundle uses the target-less form.
- */
-function resolveTaskBundle(target, opts) {
+/** The bundle `task add` writes into: its write target, config, stash path, and name. */
+function resolveTaskBundle(target) {
     const config = loadConfig();
-    const selected = resolveWriteTarget(config, target, { requireWritable: opts.requireWritable });
-    const resolved = opts.requireWritable ? prepareWriteTargetForMutation(selected) : selected;
-    const stashDir = resolved.source.path;
-    const installTarget = isPrimaryStashPath(stashDir) ? undefined : (resolved.selector ?? resolved.source.name);
-    return { resolved, config, stashDir, bundleName: resolved.source.name, installTarget };
+    const resolved = prepareWriteTargetForMutation(resolveWriteTarget(config, target, { requireWritable: true }));
+    return { resolved, config, stashDir: resolved.source.path, bundleName: resolved.source.name };
 }
 function taskProjectionAssetResolver(config, bundleName, bundleRoot) {
     return async ({ bundle, type, name }) => {
@@ -1299,8 +734,9 @@ export function resolveTaskReadBundle(refBundle, flagBundle) {
  * 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 must accept precisely its derived
- * owner name after the scheduler context restores the environment.
+ * 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
@@ -1328,31 +764,9 @@ function isPrimaryStashPath(candidate) {
     }
     return path.resolve(candidate) === primary;
 }
-/** Two bundle attributions match when both are the primary (undefined) or equal names. */
-function sameBundle(a, b) {
-    return (a ?? undefined) === (b ?? undefined);
-}
-function installedEntryRunsTask(entry, id) {
-    const invocation = entry.invocation;
-    return invocation?.[0] === "task" && invocation[1] === "run" && invocation[2] === id;
-}
-function foreignScheduleMessage(id, existingTarget) {
-    const where = existingTarget === undefined ? "the default bundle" : `bundle "${existingTarget}"`;
-    return `Task id "${id}" is already scheduled from ${where}; rename the task or disable the existing one first.`;
-}
 function errorMessage(cause) {
     return cause instanceof Error ? cause.message : String(cause);
 }
-/**
- * Refuse to schedule an id already installed from a DIFFERENT bundle. Scheduler
- * ids are the bare task id (never namespaced), so a single id can be active from
- * only one bundle at a time — a collision is a hard error, not an auto-rename.
- */
-function assertNoForeignSchedule(entries, id, installTarget) {
-    const foreign = entries.find((entry) => entry.id === id && !sameBundle(entry.target, installTarget));
-    if (foreign)
-        throw new UsageError(foreignScheduleMessage(id, foreign.target), "RESOURCE_ALREADY_EXISTS");
-}
 /**
  * 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