akm-cli 0.9.4 → 0.9.5

package/dist/scripts/akm-migrate.js

@@ -10066,11 +10066,13 @@ function makeStampHandler(command) {
     if (typeof result !== "object" || Array.isArray(result))
       return result;
     const obj = result;
-    if (obj.shape === undefined)
-      obj.shape = command;
-    if (obj.schemaVersion === undefined)
-      obj.schemaVersion = 1;
-    return obj;
+    if (obj.shape !== undefined && obj.schemaVersion !== undefined)
+      return obj;
+    return {
+      ...obj,
+      shape: obj.shape ?? command,
+      schemaVersion: obj.schemaVersion ?? 1
+    };
   };
 }
 var PASSTHROUGH_COMMANDS = [
@@ -10110,6 +10112,7 @@ var PASSTHROUGH_COMMANDS = [
   "task-doctor",
   "task-explain",
   "task-history",
+  "task-prune",
   "task-run",
   "task-sync",
   "task-sync-dry-run",
@@ -12946,8 +12949,17 @@ import path8 from "path";
 // src/core/warn.ts
 import fs4 from "fs";
 var quiet = false;
+var verbose = false;
 var logFilePath;
 var sinkOverride;
+function isVerbose() {
+  const env = process.env.AKM_VERBOSE?.trim().toLowerCase();
+  if (env === "1" || env === "true" || env === "yes" || env === "on")
+    return true;
+  if (env === "0" || env === "false" || env === "no" || env === "off")
+    return false;
+  return verbose;
+}
 function appendToLogFile(level, args) {
   if (!logFilePath)
     return;
@@ -12973,6 +12985,15 @@ function warn(...args) {
     console.warn(...args);
   }
 }
+function warnVerbose(...args) {
+  if (sinkOverride) {
+    sinkOverride("warnVerbose", args);
+    return;
+  }
+  if (isVerbose()) {
+    warn(...args);
+  }
+}
 
 // src/indexer/passes/metadata.ts
 var SCOPE_KEYS = ["user", "agent", "run", "channel"];
@@ -13688,7 +13709,7 @@ function stripMarkdownLinkDestinations(text, nesting = 0) {
   }
   return visible;
 }
-function projectMarkdownContent(body) {
+function projectMarkdownContent(body, truncationInfo) {
   const lines = body.split(/\r?\n/);
   const innerBlock = findInnerFrontmatterBlock(lines);
   const start = innerBlock && isFrontmatterShaped(lines, innerBlock) ? innerBlock.close + 1 : 0;
@@ -13734,6 +13755,8 @@ function projectMarkdownContent(body) {
   const text = projected.join(" ").replace(/\s+/g, " ").trim();
   if (!text)
     return;
+  if (truncationInfo)
+    truncationInfo.truncated = text.length > MARKDOWN_CONTENT_MAX_CHARS;
   return truncateUnicodeSafe(text, MARKDOWN_CONTENT_MAX_CHARS);
 }
 function applyPreContributorFields(entry, file, ctx, pkgMeta) {
@@ -13757,9 +13780,15 @@ function applyPreContributorFields(entry, file, ctx, pkgMeta) {
     applyWikiFrontmatter(entry, parsed.data);
     applyProvenanceFrontmatter(entry, parsed.data);
     if (entry.type !== "env" && entry.type !== "session" && !hasSessionMemoryMarker(parsed.data, parsed.content)) {
-      const contentProjection = projectMarkdownContent(parsed.content);
-      if (contentProjection)
+      const truncationInfo = { truncated: false };
+      const contentProjection = projectMarkdownContent(parsed.content, truncationInfo);
+      if (contentProjection) {
         entry.content = contentProjection;
+        if (truncationInfo.truncated) {
+          entry.contentTruncated = true;
+          warnVerbose(`${file}: indexed content truncated to ${MARKDOWN_CONTENT_MAX_CHARS} chars`);
+        }
+      }
     }
     if (entry.type === "command") {
       const cmdParams = extractCommandParameters(parsed.content);
@@ -16722,6 +16751,16 @@ var SHELL_ASSIGNMENT_WORD = /^[A-Za-z_][A-Za-z0-9_]*=/;
 function shellStableV2Executable(executable) {
   return executable === "akm" || executable.includes("/");
 }
+function skipEnvAssignmentPrefix(tokens) {
+  if (tokens[0] !== "env")
+    return { tokens, envWrapped: false };
+  let index = 1;
+  while (index < tokens.length && SHELL_ASSIGNMENT_WORD.test(tokens[index]))
+    index += 1;
+  if (index >= tokens.length)
+    return { tokens, envWrapped: false };
+  return { tokens: tokens.slice(index), envWrapped: true };
+}
 var KNOWN_PROMPT_REF_FAMILIES = new Set([
   "agents",
   "commands",
@@ -16742,11 +16781,6 @@ function hash(bytes) {
   return crypto.createHash("sha256").update(bytes).digest("hex");
 }
 function base(input) {
-  const inspectionIdentity = input.inspectionIdentity ? Object.freeze({
-    file: Object.freeze({ ...input.inspectionIdentity.file }),
-    root: Object.freeze({ ...input.inspectionIdentity.root }),
-    ...input.inspectionIdentity.bundleRoot ? { bundleRoot: Object.freeze({ ...input.inspectionIdentity.bundleRoot }) } : {}
-  }) : undefined;
   return {
     filePath: input.filePath,
     before: Buffer.from(input.bytes),
@@ -16754,8 +16788,7 @@ function base(input) {
     mode: input.mode,
     writable: input.writable,
     ...input.onDiskWritable !== undefined ? { onDiskWritable: input.onDiskWritable } : {},
-    ...input.containmentRoot ? { containmentRoot: input.containmentRoot } : {},
-    ...inspectionIdentity ? { inspectionIdentity } : {}
+    ...input.containmentRoot ? { containmentRoot: input.containmentRoot } : {}
   };
 }
 function blocked(input, reason, detail) {
@@ -16991,8 +17024,9 @@ function migratedObject(data) {
     if (tokens.length === 0 || tokens.some((token) => !SAFE_V2_COMMAND_TOKEN.test(token))) {
       return "shell-operators-change-v2-literal-argv-semantics";
     }
-    const executable = tokens[0];
-    if (SHELL_ASSIGNMENT_WORD.test(executable) || !shellStableV2Executable(executable)) {
+    const { tokens: targetTokens, envWrapped } = skipEnvAssignmentPrefix(tokens);
+    const executable = targetTokens[0];
+    if (SHELL_ASSIGNMENT_WORD.test(executable) || !envWrapped && !shellStableV2Executable(executable)) {
       return "shell-command-resolution-changes-v2-literal-argv-semantics";
     }
     output.run = tokens.join(" ");
@@ -17186,11 +17220,6 @@ function causeMessage(cause) {
   return cause instanceof Error ? cause.message : String(cause);
 }
 function base2(input) {
-  const inspectionIdentity = input.inspectionIdentity ? Object.freeze({
-    file: Object.freeze({ ...input.inspectionIdentity.file }),
-    root: Object.freeze({ ...input.inspectionIdentity.root }),
-    ...input.inspectionIdentity.bundleRoot ? { bundleRoot: Object.freeze({ ...input.inspectionIdentity.bundleRoot }) } : {}
-  }) : undefined;
   return {
     filePath: input.filePath,
     before: Buffer.from(input.bytes),
@@ -17198,8 +17227,7 @@ function base2(input) {
     mode: input.mode,
     writable: input.writable,
     ...input.onDiskWritable !== undefined ? { onDiskWritable: input.onDiskWritable } : {},
-    ...input.containmentRoot ? { containmentRoot: input.containmentRoot } : {},
-    ...inspectionIdentity ? { inspectionIdentity } : {}
+    ...input.containmentRoot ? { containmentRoot: input.containmentRoot } : {}
   };
 }
 function blocked2(input, reason, detail) {
@@ -21764,6 +21792,8 @@ function indexDocumentFromEntry(entry, base3, rendererName) {
     doc.tags = entry.tags;
   if (entry.content !== undefined)
     doc.content = entry.content;
+  if (entry.contentTruncated !== undefined)
+    doc.contentTruncated = entry.contentTruncated;
   if (entry.aliases !== undefined)
     doc.aliases = entry.aliases;
   if (entry.searchHints !== undefined)
@@ -28814,6 +28844,43 @@ var AkmConfigSchema = AkmConfigBaseSchema.superRefine((config, ctx) => {
   }
 });
 
+// src/core/config/config-version-shim.ts
+var KNOWN_OLD_CONFIG_VERSIONS = ["0.0.1"];
+function isKnownOldConfigVersion(value) {
+  return typeof value === "string" && KNOWN_OLD_CONFIG_VERSIONS.includes(value);
+}
+function upgradeFrom080(raw) {
+  const { defaultEngine, defaults, ...rest } = raw;
+  if (typeof defaultEngine !== "string" || defaultEngine.length === 0) {
+    return { ...rest, ...defaults !== undefined ? { defaults } : {}, configVersion: CURRENT_CONFIG_VERSION };
+  }
+  const existingDefaults = defaults !== null && typeof defaults === "object" ? defaults : {};
+  return {
+    ...rest,
+    configVersion: CURRENT_CONFIG_VERSION,
+    defaults: { llmEngine: defaultEngine, ...existingDefaults }
+  };
+}
+var CONFIG_VERSION_UPGRADES = {
+  "0.0.1": upgradeFrom080
+};
+function unsupportedConfigVersionError(rawVersion, sourcePath) {
+  const where = sourcePath ? ` at ${sourcePath}` : "";
+  const supported = [CURRENT_CONFIG_VERSION, ...KNOWN_OLD_CONFIG_VERSIONS].map((v) => `"${v}"`).join(", ");
+  return new ConfigError(`Unsupported configVersion${where}: got ${JSON.stringify(rawVersion)}, expected one of ${supported}.`, "UNSUPPORTED_CONFIG_VERSION", "Recreate engines and improve.strategies manually for AKM 0.9.0; profile-based configuration is not translated automatically.");
+}
+function upgradeConfigVersion(raw, sourcePath) {
+  const version = raw.configVersion;
+  if (version === CURRENT_CONFIG_VERSION)
+    return raw;
+  if (isKnownOldConfigVersion(version)) {
+    const upgraded = CONFIG_VERSION_UPGRADES[version](raw);
+    warn(`Config${sourcePath ? ` at ${sourcePath}` : ""} uses configVersion "${version}" \u2014 auto-upgraded to ${CURRENT_CONFIG_VERSION} in memory; the next config write (e.g. \`akm config set\`) persists this and silences the warning.`);
+    return upgraded;
+  }
+  throw unsupportedConfigVersionError(version, sourcePath);
+}
+
 // src/core/config/deep-merge.ts
 var UNSAFE_KEYS3 = new Set(["__proto__", "constructor", "prototype"]);
 function isPlainObject4(value) {
@@ -28904,10 +28971,7 @@ function loadUserConfig() {
   return finalConfig;
 }
 function parseAndValidateConfigText(text, sourcePath) {
-  const parsedRaw = parseConfigText(text, sourcePath);
-  if (parsedRaw.configVersion !== CURRENT_CONFIG_VERSION) {
-    throw new ConfigError(`Unsupported configVersion${sourcePath ? ` at ${sourcePath}` : ""}: expected "${CURRENT_CONFIG_VERSION}".`, "UNSUPPORTED_CONFIG_VERSION", "Recreate engines and improve.strategies manually for AKM 0.9.0; profile-based configuration is not translated automatically.");
-  }
+  const parsedRaw = upgradeConfigVersion(parseConfigText(text, sourcePath), sourcePath);
   const { config: raw, lifted, conflicts } = liftLegacyEngineExtraParams(parsedRaw);
   const where = sourcePath ? ` at ${sourcePath}` : "";
   if (conflicts.length > 0) {
@@ -29460,32 +29524,18 @@ function contained2(root, candidate) {
   const relative = path31.relative(root, candidate);
   return relative === "" || !relative.startsWith("..") && !path31.isAbsolute(relative);
 }
-function identity3(filePath, kind) {
-  const stat = fs26.lstatSync(filePath, { bigint: true });
-  const valid = kind === "file" ? stat.isFile() : stat.isDirectory();
-  if (stat.isSymbolicLink() || !valid)
-    throw migrationError(`${filePath} must be a real ${kind}.`);
-  if (kind === "file" && stat.nlink !== 1n)
-    throw migrationError(`${filePath} must not be hard-linked.`);
-  return Object.freeze({
-    realPath: fs26.realpathSync(filePath),
-    device: stat.dev.toString(),
-    inode: stat.ino.toString(),
-    linkCount: stat.nlink.toString(),
-    changeTimeNs: stat.ctimeNs.toString()
-  });
-}
-function sameIdentity2(left, right) {
-  return left.realPath === right.realPath && left.device === right.device && left.inode === right.inode && left.linkCount === right.linkCount && left.changeTimeNs === right.changeTimeNs;
+function realDirectory(filePath) {
+  const stat = fs26.lstatSync(filePath);
+  if (stat.isSymbolicLink() || !stat.isDirectory())
+    throw migrationError(`${filePath} must be a real directory.`);
+  return fs26.realpathSync(filePath);
 }
 function snapshot(filePath) {
-  const before = identity3(filePath, "file");
   const stat = fs26.lstatSync(filePath);
+  if (stat.isSymbolicLink() || !stat.isFile())
+    throw migrationError(`${filePath} must be a real file.`);
   const bytes = fs26.readFileSync(filePath);
-  const after = identity3(filePath, "file");
-  if (!sameIdentity2(before, after))
-    throw migrationError(`${filePath} changed while it was read.`);
-  return Object.freeze({ bytes, mode: stat.mode & 511, identity: after });
+  return Object.freeze({ bytes, mode: stat.mode & 511 });
 }
 function writable(filePath) {
   try {
@@ -29496,10 +29546,9 @@ function writable(filePath) {
   }
 }
 function walkTasks(root, tasksDir, out) {
-  const rootIdentity = identity3(root.root, "directory");
-  const bundleIdentity = identity3(root.bundleRoot ?? root.root, "directory");
-  const physicalRoot = rootIdentity.realPath;
-  if (!contained2(bundleIdentity.realPath, physicalRoot)) {
+  const physicalRoot = realDirectory(root.root);
+  const physicalBundleRoot = realDirectory(root.bundleRoot ?? root.root);
+  if (!contained2(physicalBundleRoot, physicalRoot)) {
     throw migrationError(`${root.root} resolves outside bundle ${root.bundleId}.`);
   }
   const visit2 = (directory) => {
@@ -29525,12 +29574,7 @@ function walkTasks(root, tasksDir, out) {
         mode: current.mode,
         writable: root.writable,
         onDiskWritable: writable(candidate) && writable(parent) && (current.mode & 146) !== 0,
-        containmentRoot: physicalRoot,
-        inspectionIdentity: Object.freeze({
-          file: current.identity,
-          root: rootIdentity,
-          bundleRoot: bundleIdentity
-        })
+        containmentRoot: physicalRoot
       });
     }
   };
@@ -29594,17 +29638,9 @@ function assertUnchanged(change) {
   if (!current.bytes.equals(change.before) || current.mode !== change.mode) {
     throw migrationError(`${change.filePath} changed after preview; no task files were replaced.`);
   }
-  const planned = change.inspectionIdentity?.file;
-  if (planned && !sameIdentity2(planned, current.identity)) {
-    throw migrationError(`${change.filePath} identity changed after preview; no task files were replaced.`);
-  }
   return current;
 }
 function applyTaskToV3MigrationPlan(plan, options) {
-  const blocked3 = plan.files.filter((file) => file.status === "blocked");
-  if (blocked3.length > 0) {
-    throw migrationError(`plan is blocked: ${blocked3.map((file) => `${file.filePath} (${file.reason})`).join(", ")}. No files were written.`);
-  }
   const changes = plan.files.filter((file) => file.status === "changed");
   for (const change of changes) {
     assertUnchanged(change);
@@ -29647,32 +29683,18 @@ function contained3(root, candidate) {
   const relative = path32.relative(root, candidate);
   return relative === "" || !relative.startsWith("..") && !path32.isAbsolute(relative);
 }
-function identity4(filePath, kind) {
-  const stat = fs27.lstatSync(filePath, { bigint: true });
-  const valid = kind === "file" ? stat.isFile() : stat.isDirectory();
-  if (stat.isSymbolicLink() || !valid)
-    throw migrationError2(`${filePath} must be a real ${kind}.`);
-  if (kind === "file" && stat.nlink !== 1n)
-    throw migrationError2(`${filePath} must not be hard-linked.`);
-  return Object.freeze({
-    realPath: fs27.realpathSync(filePath),
-    device: stat.dev.toString(),
-    inode: stat.ino.toString(),
-    linkCount: stat.nlink.toString(),
-    changeTimeNs: stat.ctimeNs.toString()
-  });
-}
-function sameIdentity3(left, right) {
-  return left.realPath === right.realPath && left.device === right.device && left.inode === right.inode && left.linkCount === right.linkCount && left.changeTimeNs === right.changeTimeNs;
+function realDirectory2(filePath) {
+  const stat = fs27.lstatSync(filePath);
+  if (stat.isSymbolicLink() || !stat.isDirectory())
+    throw migrationError2(`${filePath} must be a real directory.`);
+  return fs27.realpathSync(filePath);
 }
 function snapshot2(filePath) {
-  const before = identity4(filePath, "file");
   const stat = fs27.lstatSync(filePath);
+  if (stat.isSymbolicLink() || !stat.isFile())
+    throw migrationError2(`${filePath} must be a real file.`);
   const bytes = fs27.readFileSync(filePath);
-  const after = identity4(filePath, "file");
-  if (!sameIdentity3(before, after))
-    throw migrationError2(`${filePath} changed while it was read.`);
-  return Object.freeze({ bytes, mode: stat.mode & 511, identity: after });
+  return Object.freeze({ bytes, mode: stat.mode & 511 });
 }
 function writable2(filePath) {
   try {
@@ -29683,10 +29705,9 @@ function writable2(filePath) {
   }
 }
 function walkTasks2(root, tasksDir, out) {
-  const rootIdentity = identity4(root.root, "directory");
-  const bundleIdentity = identity4(root.bundleRoot ?? root.root, "directory");
-  const physicalRoot = rootIdentity.realPath;
-  if (!contained3(bundleIdentity.realPath, physicalRoot)) {
+  const physicalRoot = realDirectory2(root.root);
+  const physicalBundleRoot = realDirectory2(root.bundleRoot ?? root.root);
+  if (!contained3(physicalBundleRoot, physicalRoot)) {
     throw migrationError2(`${root.root} resolves outside bundle ${root.bundleId}.`);
   }
   const visit2 = (directory) => {
@@ -29712,12 +29733,7 @@ function walkTasks2(root, tasksDir, out) {
         mode: current.mode,
         writable: root.writable,
         onDiskWritable: writable2(candidate) && writable2(parent) && (current.mode & 146) !== 0,
-        containmentRoot: physicalRoot,
-        inspectionIdentity: Object.freeze({
-          file: current.identity,
-          root: rootIdentity,
-          bundleRoot: bundleIdentity
-        })
+        containmentRoot: physicalRoot
       });
     }
   };
@@ -29781,17 +29797,9 @@ function assertUnchanged2(change) {
   if (!current.bytes.equals(change.before) || current.mode !== change.mode) {
     throw migrationError2(`${change.filePath} changed after preview; no task files were replaced.`);
   }
-  const planned = change.inspectionIdentity?.file;
-  if (planned && !sameIdentity3(planned, current.identity)) {
-    throw migrationError2(`${change.filePath} identity changed after preview; no task files were replaced.`);
-  }
   return current;
 }
 function applyTaskToV4MigrationPlan(plan, options) {
-  const blocked3 = plan.files.filter((file) => file.status === "blocked");
-  if (blocked3.length > 0) {
-    throw migrationError2(`plan is blocked: ${blocked3.map((file) => `${file.filePath} (${file.reason})`).join(", ")}. No files were written.`);
-  }
   const changes = plan.files.filter((file) => file.status === "changed");
   for (const change of changes) {
     assertUnchanged2(change);
@@ -29935,12 +29943,12 @@ async function runMigrationApply(options = {}) {
   }
   const result = withConfigLock(() => withMaintenanceStartBarrier(() => {
     const before = inspectCurrentTaskPlan();
-    if (before.result.status !== "ready")
+    if (before.result.taskV3Migration.changed === 0)
       return before.result;
     const backupPath = path33.join(getDataDir(), "backups", "task-v3", `${Date.now()}-${randomUUID2()}`);
     const applied = applyTaskToV3MigrationPlan(before.plan, { backupRoot: backupPath });
     const after = inspectCurrentTaskPlan().result;
-    if (after.status !== "current") {
+    if (after.taskV3Migration.changed > 0) {
       throw new ConfigError("Task migration did not converge to task v3.", "INVALID_CONFIG_FILE");
     }
     return { ...after, backupPath, applied: applied.changed.length };
@@ -29998,12 +30006,12 @@ async function runTaskV4MigrationApply(options = {}) {
   }
   const result = withConfigLock(() => withMaintenanceStartBarrier(() => {
     const before = inspectCurrentTaskV4Plan();
-    if (before.result.status !== "ready")
+    if (before.result.taskV4Migration.changed === 0)
       return before.result;
     const backupPath = path33.join(getDataDir(), "backups", "task-v4", `${Date.now()}-${randomUUID2()}`);
     const applied = applyTaskToV4MigrationPlan(before.plan, { backupRoot: backupPath });
     const after = inspectCurrentTaskV4Plan().result;
-    if (after.status !== "current") {
+    if (after.taskV4Migration.changed > 0) {
       throw new ConfigError("Task migration did not converge to task source v4.", "INVALID_CONFIG_FILE");
     }
     return { ...after, backupPath, applied: applied.changed.length };

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/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);
 }