poe-code 10.0.2 → 10.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "poe-code",
-  "version": "10.0.2",
+  "version": "10.0.4",
   "description": "CLI tool to configure Poe API for developer workflows.",
   "license": "MIT",
   "type": "module",

package/packages/agent-harness/dist/loader/run.js

@@ -138,7 +138,10 @@ export async function runHarnessPair(mdPath, options) {
             throw error;
         }
         await hostCallReplay.flush();
-        if (result.ok && options.preserveSnapshotOnSuccess !== true) {
+        if (result.ok && result.snapshot.migration !== undefined) {
+            await snapshotBackend.write(result.snapshot);
+        }
+        else if (result.ok && options.preserveSnapshotOnSuccess !== true) {
             await cleanupCompletedSnapshot(snapshotBackend, snapshotPath);
         }
         const usage = usageAccumulator.snapshot();

package/packages/safejs/dist/chunks/{chunk-RSK47E4C.js → chunk-JLYBD3E6.js}

@@ -21213,6 +21213,89 @@ function shouldIncludeTemplateRaw(record2, key, includeTemplateRaw) {
   return false;
 }
 
+// packages/safejs/src/snapshot/migration.ts
+function validateMigrationSemantics(value) {
+  if (!["jobs-v1", "jobs-v2", "jobs-v3", "jobs-v4", "jobs-v5"].includes(value))
+    throw new TypeError(
+      "Migration requires a supported execution-semantics marker (jobs-v1 through jobs-v5)."
+    );
+}
+function validateMigrationJournal(sourceHash, replay, hostCalls = []) {
+  if (replay === void 0)
+    throw new TypeError("Migration requires a complete host replay journal.");
+  if (!Array.isArray(hostCalls)) throw new TypeError("Invalid migration hostCalls.");
+  const journal = new HostCallJournal(sourceHash, hostCalls, void 0, replay);
+  try {
+    const restored = journal.snapshotReplay();
+    for (const call of restored.calls) {
+      if (["created", "running"].includes(call.lifecycle) && call.outcome !== void 0)
+        throw new TypeError("Unresolved migration calls cannot contain a recorded outcome.");
+      for (const callback of call.callbacks ?? []) {
+        if (!call.functions?.includes(callback.id))
+          throw new TypeError("Migration callback has no registered source function.");
+      }
+    }
+    return restored;
+  } finally {
+    journal.dispose();
+  }
+}
+function validateMigrationReconciliation(value, checkpointDigest, calls) {
+  validateSnapshotData(value);
+  const receipt = value;
+  if (receipt === null || typeof receipt !== "object" || receipt.checkpointDigest !== checkpointDigest || !isCheckpointDigest(receipt.checkpointDigest))
+    throw new TypeError("Migration reconciliation must identify this exact checkpoint digest.");
+  if (receipt.quiescent !== true)
+    throw new TypeError(
+      "Migration requires explicit host confirmation that execution, operations, and callbacks are quiescent."
+    );
+  if (!Array.isArray(receipt.calls))
+    throw new TypeError("Migration reconciliation calls must be an array.");
+  const pending = new Map(
+    calls.filter((call) => !["settled", "consumed"].includes(call.lifecycle)).map((call) => [call.id, call])
+  );
+  for (const resolution of receipt.calls) {
+    if (resolution === null || typeof resolution !== "object" || !pending.has(resolution.callId))
+      throw new TypeError("Migration contains an unknown or duplicate call resolution.");
+    if (!["not-performed", "fulfilled", "rejected"].includes(resolution.disposition) || resolution.disposition === "fulfilled" && !Object.hasOwn(resolution, "value") || resolution.disposition === "rejected" && !Object.hasOwn(resolution, "reason"))
+      throw new TypeError(
+        "Migration call resolution requires a reconciled outcome or confirmed non-performance."
+      );
+    pending.delete(resolution.callId);
+  }
+  if (pending.size > 0)
+    throw new TypeError(
+      `Migration requires external reconciliation for: ${[...pending.keys()].join(", ")}`
+    );
+}
+function validateSnapshotMigration(value, sourceHash) {
+  if (value === void 0) return void 0;
+  validateSnapshotData(value);
+  const migration = value;
+  if (migration === null || typeof migration !== "object" || migration.version !== 1 || !Array.isArray(migration.history) || migration.history.length === 0)
+    throw new TypeError("Invalid snapshot migration history.");
+  decodeReplayData(migration.state);
+  let previousTarget;
+  for (const entry of migration.history) {
+    if (entry === null || typeof entry !== "object" || typeof entry.sourceHash !== "string" || entry.sourceHash.length === 0 || typeof entry.targetSourceHash !== "string" || entry.targetSourceHash.length === 0 || previousTarget !== void 0 && previousTarget !== entry.sourceHash)
+      throw new TypeError("Invalid snapshot migration ancestry.");
+    validateMigrationSemantics(entry.executionSemantics);
+    const replay = validateMigrationJournal(entry.sourceHash, entry.replay);
+    validateMigrationReconciliation(
+      entry.reconciliation,
+      entry.reconciliation?.checkpointDigest,
+      replay.calls
+    );
+    previousTarget = entry.targetSourceHash;
+  }
+  if (previousTarget !== sourceHash)
+    throw new TypeError("Migration ancestry does not match the target source.");
+  return migration;
+}
+function isCheckpointDigest(value) {
+  return typeof value === "string" && value.length === 64 && [...value].every((character) => "0123456789abcdef".includes(character));
+}
+
 // packages/safejs/src/restore.ts
 var SnapshotMismatchError = class extends Error {
   actualHash;
@@ -21230,6 +21313,7 @@ var SnapshotMismatchError = class extends Error {
 function restore(snapshot, options) {
   assertSnapshotInactive(snapshot);
   validateDumpEnvelope(snapshot);
+  validateSnapshotMigration(snapshot.migration, snapshot.sourceHash);
   if (snapshot.executionSemantics !== EXECUTION_SEMANTICS && (snapshot.executionSemantics !== void 0 || snapshot.promiseReplay !== void 0 || snapshot.replay !== void 0 || snapshot.initialInputs !== void 0)) {
     throw new SnapshotValidationError(
       "unsupportedVersion",
@@ -28308,6 +28392,7 @@ function run(source, options = {}) {
   const lifecycle = { hostCallbackDepth: 0 };
   const dumpController = createDumpController(lifecycle);
   const promiseTracker = createSandboxPromiseRejectionTracker();
+  let completedSnapshot;
   const execute = async () => {
     const promiseReplay = new PromiseReplay(options.snapshot?.promiseReplay);
     return promiseReplayContext.run(promiseReplay, async () => {
@@ -28385,6 +28470,17 @@ function run(source, options = {}) {
           }),
           ...createRegexGlobals()
         };
+        const importMeta = deepCopyToSandbox(options.importMeta ?? {});
+        if (restoredSnapshot?.migration !== void 0) {
+          if (Object.hasOwn(importMeta, "migration"))
+            throw new TypeError("import.meta.migration is reserved for migrated checkpoint state.");
+          Object.defineProperty(importMeta, "migration", {
+            value: decodeReplayData(restoredSnapshot.migration.state),
+            enumerable: true,
+            configurable: true,
+            writable: true
+          });
+        }
         const initialInputs = prepareReplayInputs(
           {
             bindings: callerBindings,
@@ -28395,7 +28491,7 @@ function run(source, options = {}) {
               allowMissing: restoredSnapshot?.initialInputs !== void 0
             }),
             entryPointArgs: options.entryPointArgs === void 0 ? void 0 : deepCopyToSandbox([...options.entryPointArgs]),
-            importMeta: deepCopyToSandbox(options.importMeta ?? {})
+            importMeta
           },
           restoredSnapshot?.initialInputs,
           (promise, id) => {
@@ -28460,6 +28556,7 @@ function run(source, options = {}) {
         });
         snapshotScheduler = activeSnapshotScheduler;
         createFailureSnapshot = () => createRunSnapshot({
+          migration: restoredSnapshot?.migration,
           bindings: executionScope.snapshot().bindings,
           clock: options.clock,
           hostCalls: hostCalls.snapshot(),
@@ -28485,6 +28582,7 @@ function run(source, options = {}) {
               }
               const interpreterSnapshot2 = yieldPoint.snapshot();
               snapshot2 = createRunSnapshot({
+                migration: restoredSnapshot?.migration,
                 bindings: interpreterSnapshot2.bindings,
                 clock: options.clock,
                 hostCalls: hostCalls.snapshot(),
@@ -28526,6 +28624,7 @@ function run(source, options = {}) {
               }
               const interpreterSnapshot2 = yieldPoint.snapshot();
               snapshot2 = createRunSnapshot({
+                migration: restoredSnapshot?.migration,
                 bindings: interpreterSnapshot2.bindings,
                 clock: options.clock,
                 hostCalls: hostCalls.snapshot(),
@@ -28559,6 +28658,7 @@ function run(source, options = {}) {
           replayError = error.message;
         }
         const snapshot = createRunSnapshot({
+          migration: restoredSnapshot?.migration,
           bindings: executionScope.snapshot().bindings,
           clock: options.clock,
           hostCalls: hostCalls.snapshot(),
@@ -28570,6 +28670,7 @@ function run(source, options = {}) {
         });
         if (replayError !== void 0) snapshot.replayError = replayError;
         dumpController.finalize(snapshot);
+        completedSnapshot = snapshot;
         return {
           ...result2,
           snapshot
@@ -28606,7 +28707,17 @@ function run(source, options = {}) {
   const result = withRunResources(
     options.signal,
     () => withSandboxPromiseRejectionTracker(promiseTracker, execute)
-  );
+  ).catch(async (error) => {
+    if (completedSnapshot !== void 0) {
+      try {
+        await createSnapshotScheduler(options).write(completedSnapshot);
+      } catch (snapshotError) {
+        console.warn("Failed to write failure snapshot.", snapshotError);
+      }
+    }
+    dumpController.fail(error);
+    throw error;
+  });
   return attachDumpController(result, dumpController);
 }
 async function throwIfReturnedPromiseRejected(result) {
@@ -28717,6 +28828,7 @@ function createRunSnapshot(input) {
     version: DUMP_FORMAT_VERSION,
     executionSemantics: EXECUTION_SEMANTICS,
     sourceHash: input.sourceHash,
+    ...input.migration === void 0 ? {} : { migration: structuredClone(input.migration) },
     bindings: input.bindings,
     clock: input.clock?.snapshot(),
     ...input.hostCalls === void 0 || input.hostCalls.length === 0 ? {} : { hostCalls: input.hostCalls },
@@ -28786,6 +28898,7 @@ export {
   parse,
   parseModule,
   lint,
+  hashSource,
   runResources,
   noopOtelSink,
   bindOtelSpan,
@@ -28797,15 +28910,26 @@ export {
   safeEndSpan,
   SandboxError,
   Budget,
+  DUMP_FORMAT_VERSION,
+  EXECUTION_SEMANTICS,
+  serializeSafeJSSnapshot,
   SnapshotValidationError,
+  validateSnapshotData,
+  validateDumpEnvelope,
+  encodeReplayData,
   HostOperationResumePolicyError,
   registerPendingHostCallPolicy,
   HostCallResumabilityError,
+  assertSnapshotInactive,
   isSandboxClosure,
   deepCopyToSandbox,
   deepCopyFromSandbox,
   createSeededRandom,
   createReplayableRandom,
+  validateMigrationSemantics,
+  validateMigrationJournal,
+  validateMigrationReconciliation,
+  validateSnapshotMigration,
   restore,
   declareHostOperation,
   dump,
@@ -28815,4 +28939,4 @@ export {
   FileSnapshotBackend,
   run
 };
-//# sourceMappingURL=chunk-RSK47E4C.js.map
+//# sourceMappingURL=chunk-JLYBD3E6.js.map