@pqpo/pragma 0.1.0-next.14 → 0.1.0-next.15

package/dist/cli.js

@@ -35515,6 +35515,25 @@ var init_output = __esm({
   }
 });
 
+// packages/core/dist/execution/human-interaction-checkpoint.js
+function isHumanInteractionCheckpointError(error53) {
+  return error53 instanceof HumanInteractionCheckpointError;
+}
+var HumanInteractionCheckpointError;
+var init_human_interaction_checkpoint = __esm({
+  "packages/core/dist/execution/human-interaction-checkpoint.js"() {
+    "use strict";
+    HumanInteractionCheckpointError = class extends Error {
+      executionId;
+      constructor(executionId) {
+        super(`Execution checkpointed while waiting for human input: ${executionId}`);
+        this.executionId = executionId;
+        this.name = "HumanInteractionCheckpointError";
+      }
+    };
+  }
+});
+
 // packages/core/dist/execution/expert-orchestrator.js
 import { createHash as createHash6, randomUUID as randomUUID11 } from "node:crypto";
 function collectDescendantInvocationIds(invocations, ownerInvocationId) {
@@ -35679,6 +35698,7 @@ var init_expert_orchestrator = __esm({
     init_invocation_service();
     init_context_resolution_service();
     init_context_id_resolver();
+    init_human_interaction_checkpoint();
     MAX_EXPERT_MESSAGE_CHARACTERS = 1e5;
     MAX_PENDING_EXPERT_MESSAGES = 128;
     MAX_PENDING_EXPERT_MESSAGE_BYTES = 1024 * 1024;
@@ -36401,6 +36421,7 @@ var init_expert_orchestrator = __esm({
         }
       }
       async executeActiveJob(options2) {
+        let checkpointed = false;
         try {
           await this.options.store.commit({
             commitId: `agent-activated:${options2.invocation.invocationId}:${randomUUID11()}`,
@@ -36427,15 +36448,19 @@ var init_expert_orchestrator = __esm({
             prompt: options2.prompt,
             permit: options2.permit
           });
-        } catch {
-          const current = await this.options.store.getInvocation(this.options.executionId, options2.invocation.invocationId);
-          if (current !== void 0 && !isTerminalExecutionStatus(current.status)) {
-            await this.failUnrecoverableJob(current, "Expert task failed before reaching a terminal state.");
+        } catch (error53) {
+          if (isHumanInteractionCheckpointError(error53)) {
+            checkpointed = true;
+          } else {
+            const current = await this.options.store.getInvocation(this.options.executionId, options2.invocation.invocationId);
+            if (current !== void 0 && !isTerminalExecutionStatus(current.status)) {
+              await this.failUnrecoverableJob(current, "Expert task failed before reaching a terminal state.");
+            }
           }
         } finally {
           try {
             const currentAgent = await this.options.store.getAgent(this.options.executionId, options2.agentId);
-            if (currentAgent?.activeInvocationId === options2.invocation.invocationId) {
+            if (!checkpointed && currentAgent?.activeInvocationId === options2.invocation.invocationId) {
               await this.options.store.commit({
                 commitId: `agent-idle:${options2.invocation.invocationId}`,
                 executionId: this.options.executionId,
@@ -37218,9 +37243,6 @@ var init_expert_prompt = __esm({
 
 // packages/core/dist/execution/expert-runner.js
 import { createHash as createHash7, randomUUID as randomUUID12 } from "node:crypto";
-function isHumanInteractionCheckpointError(error53) {
-  return error53 instanceof HumanInteractionCheckpointError;
-}
 async function listPendingHumanInteractionIds(store, executionId) {
   return (await readPendingHumanInteractions(store, executionId)).map((interaction) => interaction.interactionId);
 }
@@ -38325,7 +38347,7 @@ async function validateDelegatedRuntimeRouting(options2, delegation, parentRunti
 function sameRuntimeBinding2(left, right) {
   return left.runtimeId === right.runtimeId && left.revision === right.revision && left.fingerprint === right.fingerprint;
 }
-var AUTOMATIC_EXPERT_WAIT_TIMEOUT_MS, HumanInteractionCheckpointError, ExecutionController;
+var AUTOMATIC_EXPERT_WAIT_TIMEOUT_MS, ExecutionController;
 var init_expert_runner = __esm({
   "packages/core/dist/execution/expert-runner.js"() {
     "use strict";
@@ -38355,15 +38377,9 @@ var init_expert_runner = __esm({
     init_runtime_session_pool();
     init_context_output_service();
     init_expert_prompt();
+    init_human_interaction_checkpoint();
+    init_human_interaction_checkpoint();
     AUTOMATIC_EXPERT_WAIT_TIMEOUT_MS = 10 * 60 * 1e3;
-    HumanInteractionCheckpointError = class extends Error {
-      executionId;
-      constructor(executionId) {
-        super(`Execution checkpointed while waiting for human input: ${executionId}`);
-        this.executionId = executionId;
-        this.name = "HumanInteractionCheckpointError";
-      }
-    };
     ExecutionController = class {
       executionId;
       store;
@@ -38459,7 +38475,7 @@ var init_expert_runner = __esm({
             signal.abort(checkpoint);
           const submission = this.activeRuntimeSubmissions.get(invocationId);
           if (submission !== void 0) {
-            runtimeStops.push(Promise.resolve().then(async () => await submission.handle.cancel()));
+            runtimeStops.push((async () => await submission.handle.cancel())());
           }
         }
         for (const interaction of pending)
@@ -39245,6 +39261,57 @@ var init_expert_session = __esm({
           throw error53;
         }
       }
+      async recoverClosedSession(expert, request2) {
+        const existing = this.active.get(request2.sessionId);
+        if (existing !== void 0)
+          return existing;
+        if (request2.reason.trim() === "") {
+          throw new Error("Closed ExpertSession recovery requires a reason.");
+        }
+        const record2 = await this.dependencies.sessions.get(request2.sessionId);
+        if (record2 === void 0)
+          throw new Error(`ExpertSession not found: ${request2.sessionId}`);
+        if (record2.status !== "closed") {
+          throw new Error(`ExpertSession is not closed: ${request2.sessionId}`);
+        }
+        const currentFingerprint = fingerprintExpertExecutionDefinition(expert);
+        const definitionMatches = record2.expertId === expert.id && record2.definitionFingerprint === currentFingerprint;
+        const rootExpert = isExpertTeam(expert) ? expert.coordinator : expert;
+        const migration = definitionMatches ? void 0 : validateDefinitionMigration(record2, expert, currentFingerprint, request2);
+        if (!definitionMatches && migration === void 0) {
+          throw new ExpertDefinitionMismatchError(request2.sessionId);
+        }
+        const claimId = randomUUID13();
+        const recovered = await this.dependencies.sessions.recoverClosed({
+          sessionId: request2.sessionId,
+          expectedUpdatedAt: record2.updatedAt,
+          claimId,
+          leaseMs: EXPERT_SESSION_LEASE_MS,
+          reason: request2.reason
+        });
+        if (recovered === void 0) {
+          throw new Error(`ExpertSession recovery conflict: ${request2.sessionId}`);
+        }
+        try {
+          if (migration !== void 0) {
+            await this.migrateSessionDefinition({
+              sessionId: request2.sessionId,
+              expertId: expert.id,
+              rootExpertId: rootExpert.id,
+              definitionFingerprint: currentFingerprint,
+              previousExpertId: migration.previousExpertId,
+              previousRootExpertId: migration.previousRootExpertId,
+              reason: migration.reason
+            });
+          }
+          const session = this.createActiveSession(expert, request2.sessionId, true, claimId);
+          this.active.set(request2.sessionId, session);
+          return session;
+        } catch (error53) {
+          await this.dependencies.sessions.releaseLease(request2.sessionId, claimId);
+          throw error53;
+        }
+      }
       async migrateSessionDefinition(options2) {
         return await this.dependencies.sessions.transact(options2.sessionId, async ({ session, prompts }) => {
           const rootContext = session.contexts[session.rootContextId];
@@ -41277,6 +41344,76 @@ function createFileExpertSessionStore(options2) {
         return parsed.data;
       });
     },
+    async recoverClosed(input2) {
+      return await withFileLock(paths.expertSessionLock(input2.sessionId), async () => {
+        await prepareExpertSession(paths, options2.executions, input2.sessionId);
+        const session = ExpertSessionRecordSchema.parse(await requireJson(paths.expertSessionState(input2.sessionId), input2.sessionId));
+        if (session.status !== "closed" || session.updatedAt !== input2.expectedUpdatedAt) {
+          return void 0;
+        }
+        if (session.activeExecutionId !== void 0) {
+          throw new Error(`Closed ExpertSession has an active Execution: ${input2.sessionId}`);
+        }
+        const prompts = PromptRequestSchema.array().parse(await readJson(paths.expertSessionPrompts(input2.sessionId)) ?? []);
+        if (prompts.some((prompt) => prompt.status === "queued" || prompt.status === "running")) {
+          throw new Error(`Closed ExpertSession has pending prompts: ${input2.sessionId}`);
+        }
+        for (const executionId of session.executionIds) {
+          const execution = await options2.executions.get(executionId);
+          if (execution !== void 0 && !isTerminalExecutionStatus(execution.status)) {
+            throw new Error(`Closed ExpertSession has a non-terminal Execution: ${input2.sessionId}`);
+          }
+        }
+        const existingValue = await readJson(paths.expertSessionLease(input2.sessionId));
+        const existing = existingValue === void 0 ? void 0 : ExpertSessionLeaseSchema.parse(existingValue);
+        if (existing !== void 0 && existing.claimId !== input2.claimId && Date.parse(existing.expiresAt) > Date.now() && (existing.processId === void 0 || isProcessAlive2(existing.processId))) {
+          return void 0;
+        }
+        const rootContext = session.contexts[session.rootContextId];
+        if (rootContext === void 0)
+          throw new Error("ExpertSession root Context is missing.");
+        const reopenedRoot = {
+          ...rootContext,
+          lifecycle: "open",
+          updatedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        delete reopenedRoot.closedAt;
+        const recovered = ExpertSessionRecordSchema.parse({
+          ...session,
+          status: "open",
+          contexts: { ...session.contexts, [session.rootContextId]: reopenedRoot },
+          updatedAt: reopenedRoot.updatedAt
+        });
+        const events = ExpertSessionEventSchema.array().parse(await readJson(paths.expertSessionEvents(input2.sessionId)) ?? []);
+        const journal = ExpertSessionTransactionJournalV10Schema.parse({
+          schemaVersion: "pragma.expert-session-transaction/v10",
+          session: recovered,
+          prompts,
+          events: materializeSessionEvents(input2.sessionId, events, [
+            {
+              eventId: `context-recovered:${session.rootContextId}:${recovered.updatedAt}`,
+              type: "context.recovered",
+              data: { contextId: session.rootContextId, reason: input2.reason },
+              occurredAt: recovered.updatedAt
+            },
+            {
+              eventId: `session-recovered:${recovered.updatedAt}`,
+              type: "session.recovered",
+              data: { reason: input2.reason },
+              occurredAt: recovered.updatedAt
+            }
+          ])
+        });
+        await writeJson(paths.expertSessionTransaction(input2.sessionId), journal);
+        await applyTransaction2(paths, options2.executions, input2.sessionId, journal);
+        await writeJson(paths.expertSessionLease(input2.sessionId), {
+          claimId: input2.claimId,
+          processId: process.pid,
+          expiresAt: new Date(Date.now() + input2.leaseMs).toISOString()
+        });
+        return recovered;
+      });
+    },
     async transact(sessionId, action) {
       return await withFileLock(paths.expertSessionLock(sessionId), async () => {
         await prepareExpertSession(paths, options2.executions, sessionId);
@@ -41622,7 +41759,8 @@ function createPragma(options2) {
   return {
     experts: {
       createSession: async (expert, request2) => await experts.createSession(expert, request2),
-      resumeSession: async (expert, request2) => await experts.resumeSession(expert, request2)
+      resumeSession: async (expert, request2) => await experts.resumeSession(expert, request2),
+      recoverClosedSession: async (expert, request2) => await experts.recoverClosedSession(expert, request2)
     },
     flows: {
       start: async (flow, request2) => await flows.start(flow, request2),
@@ -424490,7 +424628,7 @@ init_dist13();
 init_integration();
 
 // apps/cli/src/version.ts
-var CLI_VERSION = false ? "0.0.0" : "0.1.0-next.14";
+var CLI_VERSION = false ? "0.0.0" : "0.1.0-next.15";
 
 // apps/cli/src/composition/default.ts
 function createCliLocalHost(input2 = {}) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pqpo/pragma",
-  "version": "0.1.0-next.14",
+  "version": "0.1.0-next.15",
   "description": "Pragma command-line interface",
   "license": "SEE LICENSE IN LICENSE",
   "type": "module",