akm-cli 0.9.4 → 0.9.6

package/dist/setup/engine-config.js

@@ -7,11 +7,10 @@ export function readCurrentLlmEngine(config) {
     const engine = name ? config.engines?.[name] : undefined;
     if (!engine || engine.kind !== "llm")
         return undefined;
-    const { kind: _kind, supportsJsonSchema, timeoutMs, ...connection } = engine;
+    const { kind: _kind, timeoutMs, ...connection } = engine;
     return {
         ...connection,
         ...(timeoutMs !== undefined ? { timeoutMs } : {}),
-        ...(supportsJsonSchema !== undefined ? { capabilities: { structuredOutput: supportsJsonSchema } } : {}),
     };
 }
 export function readAgentEngineSelection(config) {
@@ -45,15 +44,13 @@ export function writeLlmEngine(config, llm) {
     const endpoint = llm.endpoint.endsWith("/chat/completions")
         ? llm.endpoint
         : `${llm.endpoint.replace(/\/$/, "")}/chat/completions`;
-    const { capabilities, ...connection } = llm;
     return {
         engines: {
             ...(config.engines ?? {}),
             [name]: {
-                ...connection,
+                ...llm,
                 kind: "llm",
                 endpoint,
-                ...(capabilities?.structuredOutput !== undefined ? { supportsJsonSchema: capabilities.structuredOutput } : {}),
             },
         },
         defaults: { ...(config.defaults ?? {}), engine: config.defaults?.engine ?? name, llmEngine: name },

package/dist/setup/registry-stash-loader.js

@@ -17,14 +17,6 @@ import { hasRegistryUrlCredentials } from "../core/registry-url.js";
 import { allowPrivateRegistryFixtureForTests, cancelRegistryResponse, fetchRegistryResponse, } from "../registry/network.js";
 import { parseRegistryRef } from "../registry/resolve.js";
 // ── Default selections ──────────────────────────────────────────────────────
-/**
- * Registry stash IDs that are pre-selected by default during setup.
- * IDs must match the `id` field in the official registry index and have a
- * matching target in AUTHENTICATED_DEFAULT_TARGETS.
- *
- * The target binding is intentionally separate from display metadata.
- */
-export const DEFAULT_SELECTED_STASH_IDS = ["itlackey/akm-stash"];
 const AUTHENTICATED_DEFAULT_TARGETS = {
     "itlackey/akm-stash": {
         installType: "git",

package/dist/setup/setup.js

@@ -29,11 +29,10 @@ import { ConfigError, UsageError } from "../core/errors.js";
 import { getConfigPath, getDefaultStashDir, isTransientStashPath } from "../core/paths.js";
 import { warn } from "../core/warn.js";
 import { akmIndex } from "../indexer/indexer.js";
-import { clearSemanticStatus, deriveSemanticProviderFingerprint, writeSemanticStatus, } from "../indexer/search/semantic-status.js";
 import { detectAgentCliProfiles, pickDefaultAgentProfile } from "../integrations/agent/index.js";
 import { defaultProfileName } from "../integrations/harnesses/index.js";
 import { readLockfile } from "../integrations/lockfile.js";
-import { probeLlmCapabilities } from "../llm/client.js";
+import { probeLlmReachable } from "../llm/client.js";
 import { detectEnvironment, detectLMStudio, renderDetectionSummary, } from "./detect.js";
 import { upsertDetectedAgentEngine, upsertDetectedLlmEngine, verifyOpenAiCompatibleEndpoint } from "./detected-engines.js";
 import { readCurrentLlmEngine, writeAgentEngines, writeLlmEngine } from "./engine-config.js";
@@ -592,38 +591,14 @@ export async function runSetupWizard(opts) {
     // Non-interactive setup paths never reach this interactive-only step.
     p.log.step("Scheduled Tasks");
     await stepScheduledTasks();
-    if (semanticSearchMode.mode === "off") {
-        clearSemanticStatus();
-    }
     if (semanticSearchMode.mode === "auto") {
         if (semanticSearchMode.prepareAssets) {
             const ready = await prepareSemanticSearchAssets(savedConfig);
             if (!ready.ok) {
-                writeSemanticStatus({
-                    status: "blocked",
-                    reason: ready.reason,
-                    message: ready.message,
-                    providerFingerprint: deriveSemanticProviderFingerprint(savedConfig.embedding),
-                    lastCheckedAt: new Date().toISOString(),
-                });
                 p.log.warn("Semantic search remains set to auto, but is currently blocked. Re-run `akm index --full --verbose` once the issue is resolved.");
             }
-            else {
-                writeSemanticStatus({
-                    status: "pending",
-                    message: "Semantic prerequisites verified. Building the index to finish activation.",
-                    providerFingerprint: deriveSemanticProviderFingerprint(savedConfig.embedding),
-                    lastCheckedAt: new Date().toISOString(),
-                });
-            }
         }
         else {
-            writeSemanticStatus({
-                status: "pending",
-                message: "Semantic search is enabled, but asset preparation was skipped.",
-                providerFingerprint: deriveSemanticProviderFingerprint(savedConfig.embedding),
-                lastCheckedAt: new Date().toISOString(),
-            });
             p.log.info("Semantic search is set to auto, but asset preparation was skipped. Run `akm index --full --verbose` later to verify it.");
         }
     }
@@ -649,15 +624,6 @@ export async function runSetupWizard(opts) {
     catch (err) {
         spin.stop("Indexing failed — you can run `akm index` manually later.");
         p.log.warn(String(err));
-        if (savedConfig.semanticSearchMode === "auto") {
-            writeSemanticStatus({
-                status: "blocked",
-                reason: "index-failed",
-                message: String(err),
-                providerFingerprint: deriveSemanticProviderFingerprint(savedConfig.embedding),
-                lastCheckedAt: new Date().toISOString(),
-            });
-        }
     }
     // API key reminder
     if (embedding?.apiKey === undefined && embedding?.provider !== "ollama") {
@@ -989,22 +955,19 @@ export async function runSetupFromConfig(opts) {
         merged = ctx.config;
     }
     // Convert the private setup draft to the persisted bundle shape.
-    let finalizedMerged = finalizeSetupDraft(merged);
+    const finalizedMerged = finalizeSetupDraft(merged);
     // Reject an invalid merged engine graph before probing or touching the stash.
     validateCompleteConfig(finalizedMerged);
-    // Optional probe
+    // Optional connectivity probe — informational only, never blocks or
+    // mutates config. `chatCompletion` attempts structured output fresh on
+    // every call that needs it (see `llm/client.ts`), so there is nothing to
+    // probe or persist here beyond "did the endpoint answer".
     const mergedLlm = readCurrentLlmEngine(finalizedMerged);
     if (opts.probe && mergedLlm) {
         try {
-            const caps = await probeLlmCapabilities(mergedLlm);
-            if (caps.reachable) {
-                finalizedMerged = {
-                    ...finalizedMerged,
-                    ...writeLlmEngine(finalizedMerged, {
-                        ...mergedLlm,
-                        capabilities: { structuredOutput: caps.structuredOutput ?? false },
-                    }),
-                };
+            const reach = await probeLlmReachable(mergedLlm);
+            if (!reach.reachable) {
+                warn(`[akm setup] LLM endpoint not reachable${reach.error ? `: ${reach.error}` : ""}.`);
             }
         }
         catch {

package/dist/setup/steps/connection-shared.js

@@ -9,7 +9,7 @@
  * each step keeps its own option assembly and branching.
  */
 import * as p from "../../cli/clack.js";
-import { probeLlmCapabilities } from "../../llm/client.js";
+import { probeLlmReachable } from "../../llm/client.js";
 import { prompt, promptOrBack } from "../prompt.js";
 // ── Derive-config ───────────────────────────────────────────────────────────
 /** Standard chat-connection config shared by every provider branch. */
@@ -97,21 +97,18 @@ export async function promptApiKeyEnvVarName() {
 }
 // ── Probe ───────────────────────────────────────────────────────────────────
 /**
- * Best-effort structured-output probe — never blocks setup. Annotates
- * `llm.capabilities.structuredOutput` in place when the endpoint answers,
- * and warns (configuration is still saved) when it does not.
+ * Best-effort reachability probe — never blocks setup. Does NOT probe or
+ * cache structured-output support: `chatCompletion` now attempts
+ * `response_format: json_schema` fresh on every call that supplies a schema
+ * and falls back once per call on a 4xx (see `llm/client.ts`), so there is
+ * no verdict for setup to determine or persist here.
  */
 export async function probeLlmConnection(llm) {
     const probeSpin = p.spinner();
-    probeSpin.start("Probing LLM (structured-output round-trip)...");
-    const probe = await probeLlmCapabilities(llm);
-    if (probe.reachable && probe.structuredOutput) {
-        probeSpin.stop("LLM reachable; structured output verified.");
-        llm.capabilities = { ...(llm.capabilities ?? {}), structuredOutput: true };
-    }
-    else if (probe.reachable) {
-        probeSpin.stop("LLM reachable but structured-output probe failed.");
-        llm.capabilities = { ...(llm.capabilities ?? {}), structuredOutput: false };
+    probeSpin.start("Probing LLM connectivity...");
+    const probe = await probeLlmReachable(llm);
+    if (probe.reachable) {
+        probeSpin.stop("LLM reachable.");
     }
     else {
         probeSpin.stop("LLM not reachable.");

package/dist/sources/providers/git-install.js

@@ -198,7 +198,7 @@ async function doSyncGit(parsed, options) {
                 };
             }
         }
-        catch (error) {
+        catch {
             // Cache invalid, re-clone
         }
     }

package/dist/storage/engines/sqlite-migrations.js

@@ -1,6 +1,25 @@
 // 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/.
+/**
+ * Shared SQLite migration engine.
+ *
+ * SQLite schemas evolve through this transaction-per-migration runner backed
+ * by a `schema_migrations` ledger.
+ *
+ * This module factors that runner out once. Each caller supplies only its own
+ * `MIGRATIONS` array.
+ *
+ * Ledger/transaction contract:
+ *   - `id` is permanent and must never be reused.
+ *   - Applied IDs must be an exact ordered prefix of the registry.
+ *   - Each `up` body and its ledger insert commit in the same transaction.
+ *   - Migration bodies run only after `BEGIN IMMEDIATE` is observably active,
+ *     and the transaction must remain active through the body's completion.
+ *   - The caller owns semantic safety classification and any policy gate;
+ *     this generic engine intentionally does not infer risk from SQL text.
+ */
+import { sleepSync } from "../../runtime.js";
 export function assertMigrationRegistry(migrations) {
     const seen = new Set();
     for (const migration of migrations) {
@@ -152,7 +171,7 @@ function isRetryableImmediateBeginError(error) {
 function sleepImmediateRetry(ms) {
     if (ms <= 0)
         return;
-    Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+    sleepSync(ms);
 }
 /**
  * Run `fn` inside a `BEGIN IMMEDIATE` transaction.

package/dist/storage/repositories/index-entries-repository.js

@@ -354,9 +354,6 @@ function deleteEntryRows(db, rows, options = {}) {
     }
     return rows.map((row) => row.id);
 }
-export function deleteEntriesByDir(db, dirPath) {
-    db.transaction(() => deleteEntryRows(db, rowsInDirectory(db, dirPath)))();
-}
 export function deleteEntriesByDirAndBundle(db, dirPath, bundleId, options = {}) {
     return db.transaction(() => deleteEntryRows(db, rowsInDirectory(db, dirPath, bundleId), options))();
 }
@@ -704,18 +701,6 @@ export function getEntryRefRowsForStashRoot(db, stashRoot) {
     });
 }
 // ── Indexer-phase helpers (moved from indexer.ts) ────────────────────────────
-/**
- * Compute a cheap FNV-1a hash of a buffer for source-identity tracking.
- * Not security-sensitive; used as an incremental fast-path skip key.
- */
-export function computeSourceHash(content) {
-    let hash = 0x811c9dc5;
-    for (let i = 0; i < content.length; i++) {
-        hash ^= content[i];
-        hash = Math.imul(hash, 0x01000193);
-    }
-    return (hash >>> 0).toString(16);
-}
 /**
  * Return distinct zero-result search queries from the `usage_events` table
  * within the given lookback window.

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

@@ -85,7 +85,7 @@ function currentProposalRef(ref, requireQualified = false) {
 }
 function currentProposalTarget(value) {
     if (typeof value !== "object" || value === null)
-        throw new Error("Proposal metadata is missing proposedTarget.");
+        throw new Error("Proposal metadata has an invalid proposedTarget.");
     const target = value;
     if (typeof target.source !== "string" ||
         !isBundleSlug(target.source) ||
@@ -200,7 +200,13 @@ export function proposalRowToProposal(row) {
     }
     validatePresentMetadata(meta);
     const changes = storedToChanges(meta.changes, row.content);
-    const proposedTarget = currentProposalTarget(meta.proposedTarget);
+    // #859: absent proposedTarget (~93% of the real archive's accepted/rejected
+    // rows) is envelope metadata that predates this field, not corruption — an
+    // already-decided proposal is counted/displayed, never re-applied, so
+    // decode tolerates its absence the same way it already tolerates absent
+    // `changes`. A *present but malformed* value is still corruption and
+    // throws via currentProposalTarget, same as before.
+    const proposedTarget = meta.proposedTarget !== undefined ? currentProposalTarget(meta.proposedTarget) : undefined;
     return {
         id: row.id,
         ref: currentProposalRef(row.ref),
@@ -214,7 +220,7 @@ export function proposalRowToProposal(row) {
             ...(frontmatter !== undefined ? { frontmatter } : {}),
         },
         changes,
-        proposedTarget,
+        ...(proposedTarget !== undefined ? { proposedTarget } : {}),
         ...(typeof meta.beforeHash === "string" ? { beforeHash: meta.beforeHash } : {}),
         ...(meta.review !== undefined ? { review: meta.review } : {}),
         ...(typeof meta.confidence === "number" ? { confidence: meta.confidence } : {}),
@@ -233,8 +239,27 @@ export function proposalRowToProposal(row) {
 export function proposalToRowValues(proposal, stashDir) {
     // Fields that have no dedicated column live in metadata_json.
     const metaObj = {};
-    if (!Array.isArray(proposal.changes) || proposal.changes.length === 0) {
-        throw new Error(`Proposal ${proposal.id} has no file changes.`);
+    // #859: `changes` and `proposedTarget` are only enforced as REQUIRED when
+    // minting/updating a `pending` proposal — the one status createProposal
+    // ever writes, and the one status every real accept/reject transition
+    // writes FROM (a pending row always carries the full envelope; see
+    // storedToChanges / currentProposalTarget doc comments). Writing a
+    // non-pending status (accepted/rejected/reverted) is always a status
+    // TRANSITION of an already-persisted proposal, spread-copied from the row
+    // this same repository just decoded — for a legacy archived row that
+    // never had `changes`/`proposedTarget` to begin with (the pre-envelope
+    // shape), re-persisting it unchanged (e.g. `proposal revert` on an old
+    // accepted row) must not be blocked by a requirement the row never met.
+    // This does NOT weaken validation of a genuinely new proposal: every
+    // pending-status write still requires the full envelope, exactly as
+    // before.
+    if (proposal.status === "pending") {
+        if (!Array.isArray(proposal.changes) || proposal.changes.length === 0) {
+            throw new Error(`Proposal ${proposal.id} has no file changes.`);
+        }
+        if (proposal.proposedTarget === undefined) {
+            throw new Error(`Proposal ${proposal.id} is missing proposedTarget.`);
+        }
     }
     if (proposal.changes.some((change) => typeof change.path !== "string" ||
         change.path.length === 0 ||
@@ -243,7 +268,8 @@ export function proposalToRowValues(proposal, stashDir) {
         throw new Error(`Proposal ${proposal.id} has invalid file changes.`);
     }
     metaObj.changes = changesToStored(proposal.changes);
-    metaObj.proposedTarget = currentProposalTarget(proposal.proposedTarget);
+    if (proposal.proposedTarget !== undefined)
+        metaObj.proposedTarget = currentProposalTarget(proposal.proposedTarget);
     if (proposal.beforeHash !== undefined)
         metaObj.beforeHash = proposal.beforeHash;
     if (proposal.sourceRun !== undefined)

package/dist/tasks/backends/launchd.js

@@ -494,15 +494,20 @@ function assertUnrestorableLaunchdSnapshotUnchanged(entry, currentArtifacts) {
         throw new ConfigError(`Loaded launchd artifact ${JSON.stringify(entry.id)} has no restorable plist and changed after its snapshot; refusing mutation.`, "INVALID_CONFIG_FILE");
     }
 }
+/**
+ * Enumerate the current launchd AKM service namespace (loaded domain members,
+ * print-disabled labels, and on-disk plists) in one pass.
+ *
+ * This used to run the enumeration twice and fail closed if the two passes
+ * disagreed, guarding against launchd state mutating between the two
+ * `launchctl` shell-outs (milliseconds apart, in-process). The only actor
+ * that could cause that is another concurrent akm process or the user
+ * running launchctl by hand at that exact instant; a subsequent `task sync`
+ * (idempotent by design) reconciles any such drift on its own, so the
+ * two-pass fencing added a TOCTOU-shaped guard around a race with a working
+ * self-heal already in place, not a way to avoid one.
+ */
 function inspectStableLaunchdNamespace(seedIds, context) {
-    const first = captureLaunchdNamespacePass(seedIds, context);
-    const second = captureLaunchdNamespacePass(seedIds, context);
-    if (first.stabilityKey !== second.stabilityKey) {
-        throw new ConfigError("The launchd AKM service namespace changed while scheduler state was being stabilized.", "INVALID_CONFIG_FILE");
-    }
-    return second.namespace;
-}
-function captureLaunchdNamespacePass(seedIds, context) {
     const domain = context.exec.run(["launchctl", "print", `gui/${context.exec.uid()}`]);
     if (domain.status !== 0) {
         throw new ConfigError(`launchctl failed to enumerate the loaded user domain during scheduler state inspection: ${domain.stderr || domain.stdout || "no output"}.`, "INVALID_CONFIG_FILE");
@@ -532,9 +537,6 @@ function captureLaunchdNamespacePass(seedIds, context) {
         ids.add(serviceLabel.slice(LAUNCHD_LABEL_PREFIX.length));
     for (const serviceLabel of akmDisabledLabels)
         ids.add(serviceLabel.slice(LAUNCHD_LABEL_PREFIX.length));
-    if (ids.size > MAX_LAUNCHD_AKM_NAMESPACE_ENTRIES) {
-        throw new ConfigError(`launchd AKM scheduler inventory exceeds ${MAX_LAUNCHD_AKM_NAMESPACE_ENTRIES} namespace entries.`, "INVALID_CONFIG_FILE");
-    }
     const plistByNativeId = new Map(plistEntries);
     const entries = [];
     for (const nativeId of [...ids].sort()) {
@@ -566,15 +568,8 @@ function captureLaunchdNamespacePass(seedIds, context) {
         }, parsed.invocation, entry.nativeId));
     }
     return Object.freeze({
-        namespace: Object.freeze({
-            inspection: Object.freeze({ installed: Object.freeze(installed), artifacts: Object.freeze(artifacts) }),
-            entries: Object.freeze(entries),
-        }),
-        stabilityKey: JSON.stringify({
-            loadedLabels: [...loadedLabels].sort(),
-            disabledLabels: akmDisabledLabels,
-            plistEntries,
-        }),
+        inspection: Object.freeze({ installed: Object.freeze(installed), artifacts: Object.freeze(artifacts) }),
+        entries: Object.freeze(entries),
     });
 }
 function restoreLaunchdBindingEntry(entry, context, errors) {

package/dist/tasks/backends/schtasks.js

@@ -106,7 +106,7 @@ export function SCHTASKS_BACKEND(options = {}) {
                     assertSchedulerMutationArtifact(current?.status === 0 && finalNativeId ? schtasksArtifact(finalNativeId, current.stdout) : undefined, expected);
                 }
                 else {
-                    assertSchtasksArtifactUnchanged(exec, taskName(nativeId), query, nativeId, task);
+                    assertSchtasksArtifactUnchanged(exec, taskName(nativeId), nativeId, task);
                 }
                 try {
                     // /F forces overwrite if a task with the same name exists.
@@ -461,8 +461,23 @@ function parsePowerShellSingleQuotedArgs(script, start) {
     }
     return argv;
 }
-/** Close the read/prepare-to-/Create ownership race at the native boundary. */
-function assertSchtasksArtifactUnchanged(exec, nativeTaskName, previous, nativeId, task) {
+/**
+ * Re-verify ownership of the native artifact immediately before `/Create /F`
+ * overwrites it (the read/prepare-to-/Create ownership race at the native
+ * boundary).
+ *
+ * This used to also compare the fresh query against the first read taken
+ * earlier in `install` and refuse the whole operation if anything about the
+ * XML had changed in between -- a freshness re-check on top of the identity
+ * re-check right below it. That extra comparison never caught anything the
+ * owner check didn't already cover (a foreign/changed owner still fails
+ * `assertSchedulerNativeArtifactOwner`), and `task sync` is idempotent, so a
+ * spurious refusal here only cost the user a rerun of a command they'd
+ * already asked for. Dropped; the owner re-check (the actual corruption/
+ * clobber guard -- no fallback exists if a foreign task got silently
+ * overwritten) stays.
+ */
+function assertSchtasksArtifactUnchanged(exec, nativeTaskName, nativeId, task) {
     // This runs outside install's rollback region: no scheduler mutation has
     // occurred, so a raced owner must remain untouched rather than be restored
     // from the stale first read.
@@ -470,11 +485,6 @@ function assertSchtasksArtifactUnchanged(exec, nativeTaskName, previous, nativeI
         isOk: (result) => result.status === 0 || isMissingTaskResult(result),
         message: (result) => `schtasks /Query failed during final ownership check (exit ${result.status}): ${result.stderr || result.stdout || "no output"}.`,
     });
-    const changed = current.status !== previous.status ||
-        (current.status === 0 && normalizeXmlForUtf16File(current.stdout) !== normalizeXmlForUtf16File(previous.stdout));
-    if (changed) {
-        throw new ConfigError(`schtasks task "${nativeTaskName}" changed while it was being prepared; refusing to replace an unverified owner.`, "INVALID_CONFIG_FILE");
-    }
     if (current.status === 0) {
         assertSchedulerNativeArtifactOwner(nativeId, task, extractSchtasksInvocation(current.stdout)?.invocation);
     }

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

@@ -20,7 +20,7 @@
 import path from "node:path";
 import { assertNever } from "../../core/assert.js";
 import { runManagedSubprocess, streamCaptureFailure } from "../../core/subprocess.js";
-import { assertFrozenDirectoryIdentity } from "../../execution/directory-identity.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";
@@ -146,11 +146,13 @@ export async function runNativeTask(input) {
     const dbLines = [{ line: header }];
     let exitCode = null;
     try {
-        // The projector froze both canonical paths and filesystem identities before
-        // history mutation. 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.
-        assertFrozenDirectoryIdentity(task.cwdIdentity);
+        // 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);

package/dist/tasks/scheduler-binding.js

@@ -159,12 +159,15 @@ export function schedulerLogicalBindingOwner(nativeId, invocation) {
     return schedulerNativeArtifactOwner(nativeId, invocation)?.logicalId;
 }
 export function schedulerNativeArtifactOwner(nativeId, invocation) {
-    if (invocation[0] === "workflow" && invocation[1] === "run") {
-        return { logicalId: nativeId, logicalKind: "workflow" };
+    if (invocation[0] === "workflow" && invocation[1] === "run" && invocation.length === 3) {
+        const ref = invocation[2];
+        if (ref && workflowRefDigestsToNativeId(ref, nativeId)) {
+            return { logicalId: nativeId, logicalKind: "workflow" };
+        }
+        return undefined;
     }
     const taskId = invocation[0] === "task" && invocation[1] === "run" ? invocation[2] : undefined;
-    const bundleIndex = invocation.indexOf("--bundle", 3);
-    if (!taskId || bundleIndex === -1 || !invocation[bundleIndex + 1])
+    if (!taskId)
         return undefined;
     return {
         logicalId: schedulerNativeBindingId(taskId) === nativeId ? taskId : nativeId,
@@ -225,7 +228,6 @@ export function assertSchedulerMutationArtifact(artifact, expected) {
         artifact.nativeId === expected.nativeId &&
         artifact.bindingId === expected.bindingId &&
         artifact.invocation !== undefined &&
-        sameInvocation(artifact.invocation, expected.invocation) &&
         expected.fingerprint !== undefined &&
         artifact.fingerprint === expected.fingerprint) {
         return;
@@ -306,6 +308,14 @@ export function schedulerBindingOrdinal(bindingId, logicalSource, invocation) {
     }
     return undefined;
 }
+/** Whether some schedule ordinal on `ref` would digest to `nativeId` (mirrors schedulerBindingOrdinal). */
+function workflowRefDigestsToNativeId(ref, nativeId) {
+    for (let ordinal = 0; ordinal < 4096; ordinal += 1) {
+        if (digestBindingId("workflow", ref, ordinal) === nativeId)
+            return true;
+    }
+    return false;
+}
 function digestBindingId(kind, ref, ordinal) {
     const prefix = kind === "workflow" ? "wf" : "task";
     const digest = createHash("sha256")

package/dist/tasks/scheduler-sync-preview.js

@@ -7,7 +7,7 @@
  * `SchedulerSyncPlan`) so a future `task prune` can build a preview from
  * its own remove-only operation set without needing a full sync plan.
  */
-export function renderSchedulerPlanPreview(backend, operations, unchanged = []) {
+export function renderSchedulerPlanPreview(backend, operations, unchanged = [], failures = []) {
     const adds = [];
     const updates = [];
     const removes = [];
@@ -18,6 +18,7 @@ export function renderSchedulerPlanPreview(backend, operations, unchanged = [])
                 kind: "remove",
                 nativeId: operation.nativeId,
                 ...(operation.ownerBundlePath !== undefined ? { ownerBundlePath: operation.ownerBundlePath } : {}),
+                ...(operation.reason !== undefined ? { reason: operation.reason } : {}),
             });
         }
         else if (operation.kind === "install") {
@@ -35,9 +36,10 @@ export function renderSchedulerPlanPreview(backend, operations, unchanged = [])
         removes: Object.freeze(removes),
         unchanged: Object.freeze([...unchanged]),
         hasRemovals: removes.length > 0,
+        failures: Object.freeze([...failures]),
     });
 }
 /** Convenience wrapper for the common case: previewing a whole {@link SchedulerSyncPlan}. */
 export function renderSchedulerSyncPlanPreview(backend, plan) {
-    return renderSchedulerPlanPreview(backend, plan.operations, plan.unchanged);
+    return renderSchedulerPlanPreview(backend, plan.operations, plan.unchanged, plan.failures);
 }