opencode-swarm 7.154.1 → 7.154.3

package/dist/cli/{index-9wzgztj9.js → index-ed13peqr.js}

@@ -1,7 +1,7 @@
 // @bun
 import {
   atomicWriteFile
-} from "./index-107cv0dr.js";
+} from "./index-bhjkxasn.js";
 import {
   init_logger,
   warn

package/dist/cli/{index-tmgbwgsm.js → index-env8fk17.js}

@@ -9,7 +9,7 @@ import {
 } from "./index-y8552snf.js";
 import {
   atomicWriteFile
-} from "./index-107cv0dr.js";
+} from "./index-bhjkxasn.js";
 import {
   assertProjectRoot,
   withEvidenceLock

package/dist/cli/{index-9znypky4.js → index-g1bh7980.js}

@@ -2,14 +2,14 @@
 import {
   autoCommitDirty,
   cleanUntrackedFiles
-} from "./index-zak84bqr.js";
+} from "./index-7qky94rr.js";
 import {
   isPathWithinDeclaredScope,
   unsafePathTextReason
 } from "./index-556ja8an.js";
 import {
   validateSwarmPath
-} from "./index-4cgee5vh.js";
+} from "./index-dtn0pne5.js";
 import {
   bunSpawn,
   classifySpawnFailure
@@ -26,7 +26,7 @@ import {
   atomicWriteFile,
   taskEvidencePath,
   withTaskEvidenceLock
-} from "./index-107cv0dr.js";
+} from "./index-bhjkxasn.js";
 import {
   assertProjectRoot
 } from "./index-xagq35tf.js";

package/dist/cli/{index-p17hs70t.js → index-gbkdj7ay.js}

@@ -2,10 +2,10 @@
 import {
   init_loader,
   loadPluginConfigWithMeta
-} from "./index-xsbf2mmf.js";
+} from "./index-q0prhdds.js";
 import {
   init_schema
-} from "./index-fz9xcq6z.js";
+} from "./index-y3kw1zpm.js";
 import {
   DEFAULT_WORKTREE_ISOLATION_CONFIG,
   init_constants

package/dist/cli/{index-9xev69y4.js → index-kck2gtxk.js}

@@ -1,7 +1,10 @@
 // @bun
+import {
+  canonicalRootKeyFresh
+} from "./index-ddszzne4.js";
 import {
   validateSwarmPath
-} from "./index-4cgee5vh.js";
+} from "./index-dtn0pne5.js";
 import {
   bunWrite
 } from "./index-r3mvsbtq.js";
@@ -17,6 +20,9 @@ import {
   init_logger,
   warn
 } from "./index-zgwm4ryv.js";
+import {
+  __require
+} from "./index-a76rekgs.js";
 
 // src/background/pending-delegations.ts
 init_zod();
@@ -387,6 +393,7 @@ var MAX_LIVE_BACKGROUND_FALLBACKS = 256;
 var MAX_LIVE_BACKGROUND_CODER_RESERVATIONS = 256;
 var MAX_BACKGROUND_OBSERVED_FILES = 5000;
 var MAX_BACKGROUND_ADVISORY_CHARS = 4000;
+var LEGACY_CODER_SETTLEMENT_PENDING_ADVISORY_MARKER = "legacy coder settlement transfer is pending";
 var MAX_BACKGROUND_DELEGATION_GENERATION = 1e6;
 var MAX_RECOVERY_FALLBACK_BYTES = 1024 * 1024;
 var DELEGATION_COMPACTION_LOW_WATER_BYTES = 256 * 1024;
@@ -674,6 +681,11 @@ var RecordSchema = exports_external.object({
   terminalResult: TerminalResultSchema.optional(),
   coderSettlement: CoderSettlementSchema.optional(),
   advisoryInbox: AdvisoryInboxSchema.optional(),
+  legacyCoderSettlementTransfer: exports_external.object({
+    taskId: exports_external.string().min(1).max(256),
+    transitionId: exports_external.string().min(1).max(256),
+    updatedAt: exports_external.number().nonnegative()
+  }).strict().optional(),
   ingestion: DelegationIngestionSchema.optional(),
   result: ResultSchema.optional(),
   completedAt: exports_external.number().optional()
@@ -1132,6 +1144,8 @@ function isCheckpointLiveRecord(record) {
     return true;
   if (record.advisoryInbox?.state === "pending")
     return true;
+  if (record.legacyCoderSettlementTransfer)
+    return true;
   const settlement = record.coderSettlement;
   if (settlement && settlement.state !== "settled")
     return true;
@@ -1986,6 +2000,99 @@ async function updateCoderSettlement(directory, correlationId, input) {
     return null;
   }
 }
+var MAX_LEGACY_CODER_SETTLEMENT_RECONCILERS = 32;
+var RETRYABLE_LEGACY_SETTLEMENT_ERROR_CODES = new Set([
+  "CODER_SETTLEMENT_LOCKED",
+  "EACCES",
+  "EBUSY",
+  "EIO",
+  "EPERM",
+  "ETIMEDOUT"
+]);
+var legacyCoderSettlementReconcilers = new Map;
+var legacyCoderSettlementReconcilerOrder = [];
+function registerLegacyCoderSettlementReconciler(directory, reconciler) {
+  const key = canonicalRootKeyFresh(directory);
+  if (legacyCoderSettlementReconcilers.has(key)) {
+    const existingIndex = legacyCoderSettlementReconcilerOrder.indexOf(key);
+    if (existingIndex >= 0) {
+      legacyCoderSettlementReconcilerOrder.splice(existingIndex, 1);
+    }
+    legacyCoderSettlementReconcilerOrder.push(key);
+    legacyCoderSettlementReconcilers.set(key, reconciler);
+    return;
+  }
+  if (legacyCoderSettlementReconcilerOrder.length >= MAX_LEGACY_CODER_SETTLEMENT_RECONCILERS) {
+    const evicted = legacyCoderSettlementReconcilerOrder.shift();
+    if (evicted)
+      legacyCoderSettlementReconcilers.delete(evicted);
+  }
+  legacyCoderSettlementReconcilerOrder.push(key);
+  legacyCoderSettlementReconcilers.set(key, reconciler);
+}
+function getLegacyCoderSettlementReconciler(directory) {
+  return legacyCoderSettlementReconcilers.get(canonicalRootKeyFresh(directory));
+}
+var _internals = {
+  getLegacyCoderSettlementReconciler,
+  getLegacyCoderSettlementReconcilerOrder: () => [
+    ...legacyCoderSettlementReconcilerOrder
+  ],
+  resetLegacyCoderSettlementReconcilers: () => {
+    legacyCoderSettlementReconcilers.clear();
+    legacyCoderSettlementReconcilerOrder.length = 0;
+  }
+};
+async function markLegacyCoderSettlementTransferPending(directory, correlationId, transfer) {
+  return updateLegacyCoderSettlementTransfer(directory, correlationId, transfer);
+}
+async function clearLegacyCoderSettlementTransferPending(directory, correlationId) {
+  return updateLegacyCoderSettlementTransfer(directory, correlationId, null);
+}
+async function updateLegacyCoderSettlementTransfer(directory, correlationId, transfer) {
+  if (!correlationId)
+    return null;
+  let result = null;
+  try {
+    await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      const records = loadRecordsForWrite(directory);
+      if (records === null)
+        return;
+      const current = findRecordForWrite(records, correlationId);
+      if (!current)
+        return;
+      if (transfer && (current.status === "consumed" || current.legacyCoderSettlementTransfer && (current.legacyCoderSettlementTransfer.taskId !== transfer.taskId || current.legacyCoderSettlementTransfer.transitionId !== transfer.transitionId))) {
+        result = current;
+        return;
+      }
+      const updatedAt = Date.now();
+      const next = transfer ? {
+        ...current,
+        schemaVersion: 3,
+        legacyCoderSettlementTransfer: {
+          ...transfer,
+          updatedAt
+        },
+        updatedAt
+      } : (() => {
+        const { legacyCoderSettlementTransfer: _pending, ...rest } = current;
+        return {
+          ...rest,
+          schemaVersion: 3,
+          updatedAt
+        };
+      })();
+      if (!RecordSchema.safeParse(next).success)
+        return;
+      appendRecord(directory, next);
+      maybeCompactDelegationsLocked(directory);
+      result = next;
+    });
+  } catch (error) {
+    warn(`[background] legacy coder settlement transfer marker update failed: ${error instanceof Error ? error.message : String(error)}`);
+  }
+  return result;
+}
 async function claimDelegationIngestion(directory, correlationId, options) {
   if (!correlationId || !options.claimantId)
     return null;
@@ -2129,6 +2236,50 @@ async function putPendingBackgroundAdvisory(directory, correlationId, input) {
     return null;
   }
 }
+async function replacePendingBackgroundAdvisory(directory, correlationId, input) {
+  const createdAt = input.createdAt ?? Date.now();
+  const parsed = AdvisoryInboxSchema.safeParse({
+    eventId: input.eventId,
+    parentSessionId: input.parentSessionId,
+    state: "pending",
+    message: input.message,
+    createdAt
+  });
+  if (!correlationId || !parsed.success)
+    return null;
+  let result = null;
+  try {
+    await withEvidenceLock(directory, BACKGROUND_DELEGATIONS_FILE, STORE_LOCK_AGENT, STORE_LOCK_TASK, async () => {
+      const records = loadRecordsForWrite(directory);
+      if (records === null)
+        return;
+      const current = findRecordForWrite(records, correlationId);
+      const existing = current?.advisoryInbox;
+      if (!current?.terminalResult || current.terminalResult.eventId !== parsed.data.eventId || current.parentSessionId !== parsed.data.parentSessionId || !existing || !existing.message.includes(LEGACY_CODER_SETTLEMENT_PENDING_ADVISORY_MARKER) || parsed.data.message.includes(LEGACY_CODER_SETTLEMENT_PENDING_ADVISORY_MARKER)) {
+        if (existing && existing.eventId === parsed.data.eventId && existing.parentSessionId === parsed.data.parentSessionId && existing.message === parsed.data.message) {
+          result = { advisory: existing };
+        }
+        return;
+      }
+      const next = {
+        ...current,
+        schemaVersion: 3,
+        advisoryInbox: parsed.data,
+        updatedAt: createdAt
+      };
+      appendRecord(directory, next);
+      maybeCompactDelegationsLocked(directory);
+      result = {
+        advisory: parsed.data,
+        replacedMessage: existing.message
+      };
+    });
+    return result;
+  } catch (err) {
+    warn(`[background] replacePendingBackgroundAdvisory failed: ${err instanceof Error ? err.message : String(err)}`);
+    return null;
+  }
+}
 async function preparePendingBackgroundAdvisories(directory, parentSessionId, options) {
   if (!parentSessionId || !options.preparationId)
     return [];
@@ -2940,6 +3091,74 @@ async function releaseBackgroundCoderReservation(directory, input) {
 }
 var DEFAULT_MAINTENANCE_LOCK_TIMEOUT_MS = 5000;
 var DEFAULT_MAINTENANCE_BATCH = 256;
+async function reconcileLegacyCoderSettlements(directory, maxRecords, onReconciled, onAdvisoryReplaced) {
+  const reconciler = onReconciled ?? getLegacyCoderSettlementReconciler(directory);
+  const candidates = readDelegations(directory).filter((record) => record.normalizedAgent === "coder" && Boolean(record.legacyCoderSettlementTransfer) && Boolean(record.terminalResult)).slice(0, maxRecords);
+  if (candidates.length === 0)
+    return 0;
+  const { transferCoderSettlementToBackground } = await import("./coder-settlement-7c9h07f5.js");
+  let transferred = 0;
+  for (const record of candidates) {
+    try {
+      const outcome = await transferCoderSettlementToBackground({
+        directory,
+        taskId: record.legacyCoderSettlementTransfer.taskId,
+        transitionId: record.legacyCoderSettlementTransfer.transitionId
+      });
+      if ((outcome === "transferred" || outcome === "already-terminal" || outcome === "missing") && reconciler) {
+        if (await reconciler(record)) {
+          await clearLegacyCoderSettlementTransferPending(directory, record.correlationId);
+        }
+      }
+      if (outcome === "transferred")
+        transferred += 1;
+    } catch (error) {
+      const code = legacySettlementErrorCode(error);
+      if (!RETRYABLE_LEGACY_SETTLEMENT_ERROR_CODES.has(code ?? "")) {
+        const advisory = record.advisoryInbox;
+        const manualMessage = `[BACKGROUND COMPLETION ${record.terminalResult?.eventId ?? record.correlationId}] coder task ${record.evidenceTaskId ?? record.planTaskId ?? "unknown"} legacy coder settlement requires manual recovery; run /swarm recover for this task (or /swarm reset-session).`;
+        let advisoryRecorded = false;
+        if (advisory?.state === "pending") {
+          const replaced = await replacePendingBackgroundAdvisory(directory, record.correlationId, {
+            eventId: advisory.eventId,
+            parentSessionId: advisory.parentSessionId,
+            message: manualMessage
+          });
+          advisoryRecorded = replaced !== null;
+          if (replaced) {
+            try {
+              await onAdvisoryReplaced?.(record, replaced);
+            } catch (callbackError) {
+              warn(`[background] legacy coder settlement advisory replacement notification failed for ${record.correlationId}: ${callbackError instanceof Error ? callbackError.message : String(callbackError)}`);
+            }
+          }
+        } else if (record.terminalResult) {
+          const stored = await putPendingBackgroundAdvisory(directory, record.correlationId, {
+            eventId: record.terminalResult.eventId,
+            parentSessionId: record.parentSessionId,
+            message: manualMessage
+          });
+          advisoryRecorded = stored !== null;
+        }
+        if (advisoryRecorded) {
+          await clearLegacyCoderSettlementTransferPending(directory, record.correlationId);
+        }
+        warn(`[background] legacy coder settlement reconciliation requires manual recovery for ${record.correlationId}: ${code ?? "unknown transfer failure"}`);
+        continue;
+      }
+      warn(`[background] legacy coder settlement reconciliation deferred for ${record.correlationId}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  return transferred;
+}
+function legacySettlementErrorCode(error) {
+  if (error && typeof error === "object" && "code" in error && typeof error.code === "string") {
+    return error.code ?? null;
+  }
+  const detail = error instanceof Error ? error.message : String(error);
+  const match = /^([A-Z][A-Z0-9_]*)(?::|$)/.exec(detail.trim());
+  return match?.[1] ?? null;
+}
 async function maintainBackgroundDelegations(directory, options = {}) {
   const now = options.now ?? Date.now();
   const staleTimeoutMs = options.staleTimeoutMs ?? DEFAULT_STALE_DELEGATION_TIMEOUT_MS;
@@ -3221,10 +3440,17 @@ async function maintainBackgroundDelegations(directory, options = {}) {
     });
     return emitObservation("failure", error instanceof Error ? error.message : String(error));
   }
+  if (!options.skipLegacyCoderSettlementReconciliation) {
+    try {
+      await reconcileLegacyCoderSettlements(directory, maxRecords, options.onLegacyCoderSettlementReconciled ?? getLegacyCoderSettlementReconciler(directory), options.onLegacyCoderSettlementAdvisoryReplaced);
+    } catch (error) {
+      warn(`[background] legacy coder settlement reconciliation pass failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
   if (result.status === "failure") {
     return emitObservation("failure", result.reason);
   }
   return emitObservation("ok");
 }
 
-export { MAX_RECOVERY_LEDGER_BYTES, readDelegationHealthArtifact, collectDelegationLedgerHealth, MAX_PR_REVIEW_COLLECTION_RECEIPT_ITEM_IDS, BACKGROUND_DELEGATIONS_FILE, BACKGROUND_DELEGATION_FALLBACK_DIR, BACKGROUND_CODER_RESERVATIONS_FILE, BACKGROUND_DELEGATIONS_CHECKPOINT_FILE, BACKGROUND_DELEGATIONS_MANIFEST_FILE, MAX_LIVE_BACKGROUND_FALLBACKS, MAX_LIVE_BACKGROUND_CODER_RESERVATIONS, MAX_BACKGROUND_OBSERVED_FILES, MAX_BACKGROUND_ADVISORY_CHARS, DELEGATION_COMPACTION_LOW_WATER_BYTES, DELEGATION_COMPACTION_HIGH_WATER_BYTES, MAX_CHECKPOINT_BYTES, MAX_CHECKPOINT_RECORDS, TOMBSTONE_MIN_AGE_MS, BACKGROUND_INGESTION_LEASE_MS, BACKGROUND_CODER_RESERVATION_LEASE_MS, BACKGROUND_CODER_RESERVATION_LEASE_MAX_MS, BACKGROUND_CODER_RESERVATION_LEASE_MIN_MS, DEFAULT_STALE_DELEGATION_TIMEOUT_MS, DEFAULT_SWEEPABLE_DELEGATION_STATUSES, _checkpointInternals, isUnsettledWorktreeOwner, compactBackgroundDelegations, readDelegations, scanDelegationsForRecovery, findByCorrelationId, recordPendingDelegationDetailed, recordPendingDelegation, buildPromptSnapshot, appendDelegationTransition, buildBackgroundCompletionEventId, claimTerminalResult, claimCoderSettlement, normalizeBackgroundObservedFiles, updateCoderSettlement, claimDelegationIngestion, recordDelegationIngestionResult, putPendingBackgroundAdvisory, preparePendingBackgroundAdvisories, acknowledgeObservedBackgroundAdvisories, releasePreparedBackgroundAdvisories, findByBatchId, findOpenAsyncLaneBatches, sweepStaleDelegations, readDelegationFallback, listDelegationFallbacks, scanDelegationFallbacksForRecovery, writeDelegationFallback, removeDelegationFallback, findDelegationForCompletion, promoteDelegationFallback, buildBackgroundCoderReservationId, scanBackgroundCoderReservationsForAdmission, reserveBackgroundCoderSlot, bindBackgroundCoderReservation, releaseBackgroundCoderReservation, maintainBackgroundDelegations };
+export { MAX_RECOVERY_LEDGER_BYTES, readDelegationHealthArtifact, collectDelegationLedgerHealth, MAX_PR_REVIEW_COLLECTION_RECEIPT_ITEM_IDS, BACKGROUND_DELEGATIONS_FILE, BACKGROUND_DELEGATION_FALLBACK_DIR, BACKGROUND_CODER_RESERVATIONS_FILE, BACKGROUND_DELEGATIONS_CHECKPOINT_FILE, BACKGROUND_DELEGATIONS_MANIFEST_FILE, MAX_LIVE_BACKGROUND_FALLBACKS, MAX_LIVE_BACKGROUND_CODER_RESERVATIONS, MAX_BACKGROUND_OBSERVED_FILES, MAX_BACKGROUND_ADVISORY_CHARS, LEGACY_CODER_SETTLEMENT_PENDING_ADVISORY_MARKER, DELEGATION_COMPACTION_LOW_WATER_BYTES, DELEGATION_COMPACTION_HIGH_WATER_BYTES, MAX_CHECKPOINT_BYTES, MAX_CHECKPOINT_RECORDS, TOMBSTONE_MIN_AGE_MS, BACKGROUND_INGESTION_LEASE_MS, BACKGROUND_CODER_RESERVATION_LEASE_MS, BACKGROUND_CODER_RESERVATION_LEASE_MAX_MS, BACKGROUND_CODER_RESERVATION_LEASE_MIN_MS, DEFAULT_STALE_DELEGATION_TIMEOUT_MS, DEFAULT_SWEEPABLE_DELEGATION_STATUSES, _checkpointInternals, isUnsettledWorktreeOwner, compactBackgroundDelegations, readDelegations, scanDelegationsForRecovery, findByCorrelationId, recordPendingDelegationDetailed, recordPendingDelegation, buildPromptSnapshot, appendDelegationTransition, buildBackgroundCompletionEventId, claimTerminalResult, claimCoderSettlement, normalizeBackgroundObservedFiles, updateCoderSettlement, registerLegacyCoderSettlementReconciler, _internals, markLegacyCoderSettlementTransferPending, clearLegacyCoderSettlementTransferPending, claimDelegationIngestion, recordDelegationIngestionResult, putPendingBackgroundAdvisory, replacePendingBackgroundAdvisory, preparePendingBackgroundAdvisories, acknowledgeObservedBackgroundAdvisories, releasePreparedBackgroundAdvisories, findByBatchId, findOpenAsyncLaneBatches, sweepStaleDelegations, readDelegationFallback, listDelegationFallbacks, scanDelegationFallbacksForRecovery, writeDelegationFallback, removeDelegationFallback, findDelegationForCompletion, promoteDelegationFallback, buildBackgroundCoderReservationId, scanBackgroundCoderReservationsForAdmission, reserveBackgroundCoderSlot, bindBackgroundCoderReservation, releaseBackgroundCoderReservation, maintainBackgroundDelegations };