@bastani/atomic 0.8.25 → 0.8.26-alpha.10

package/dist/builtin/workflows/src/shared/store.ts

@@ -16,6 +16,9 @@ import type {
   RunStatus,
   StageStatus,
   WorkflowFailureKind,
+  WorkflowFailureCode,
+  WorkflowFailureRecoverability,
+  WorkflowFailureDisposition,
   WorkflowNotice,
   WorkflowChildRunRef,
 } from "./store-types.js";
@@ -43,9 +46,55 @@ function cannotPause(status: StageStatus): boolean {
 
 export interface RunEndMetadata {
   readonly failureKind?: WorkflowFailureKind;
+  readonly failureCode?: WorkflowFailureCode;
+  readonly failureRecoverability?: WorkflowFailureRecoverability;
+  readonly failureDisposition?: WorkflowFailureDisposition;
   readonly failureMessage?: string;
   readonly failedStageId?: string;
   readonly resumable?: boolean;
+  readonly retryAfterMs?: number;
+}
+
+export interface RunBlockedMetadata extends RunEndMetadata {
+  readonly failureRecoverability: "recoverable";
+  readonly failedStageId: string;
+  readonly resumable: true;
+  readonly blockedAt?: number;
+}
+
+function clearRunFailureMetadata(run: RunSnapshot): void {
+  delete run.error;
+  delete run.failureKind;
+  delete run.failureCode;
+  delete run.failureRecoverability;
+  delete run.failureDisposition;
+  delete run.failureMessage;
+  delete run.failedStageId;
+  delete run.resumable;
+  delete run.retryAfterMs;
+  delete run.blockedAt;
+}
+
+function clearStaleBlockedRunMetadata(run: RunSnapshot, metadata: RunEndMetadata | undefined): void {
+  if (metadata?.failureKind === undefined) delete run.failureKind;
+  if (metadata?.failureCode === undefined) delete run.failureCode;
+  if (metadata?.failureRecoverability === undefined) delete run.failureRecoverability;
+  if (metadata?.failureDisposition === undefined) delete run.failureDisposition;
+  if (metadata?.failureMessage === undefined) delete run.failureMessage;
+  if (metadata?.failedStageId === undefined) delete run.failedStageId;
+  if (metadata?.resumable === undefined) delete run.resumable;
+  if (metadata?.retryAfterMs === undefined) delete run.retryAfterMs;
+}
+
+function applyRunEndMetadata(run: RunSnapshot, metadata: RunEndMetadata): void {
+  if (metadata.failureKind !== undefined) run.failureKind = metadata.failureKind;
+  if (metadata.failureCode !== undefined) run.failureCode = metadata.failureCode;
+  if (metadata.failureRecoverability !== undefined) run.failureRecoverability = metadata.failureRecoverability;
+  if (metadata.failureDisposition !== undefined) run.failureDisposition = metadata.failureDisposition;
+  if (metadata.retryAfterMs !== undefined) run.retryAfterMs = metadata.retryAfterMs;
+  if (metadata.failureMessage !== undefined) run.failureMessage = metadata.failureMessage;
+  if (metadata.failedStageId !== undefined) run.failedStageId = metadata.failedStageId;
+  if (metadata.resumable !== undefined) run.resumable = metadata.resumable;
 }
 
 export type StagePromptAnswerSource = "workflow_ui" | "workflow_tool";
@@ -95,6 +144,12 @@ export interface Store {
     error?: string,
     metadata?: RunEndMetadata,
   ): boolean;
+  /**
+   * Record an active, recoverable workflow failure without ending the run.
+   * The run remains resumable/running and carries failure metadata for status,
+   * persistence restore, and continuation decisions.
+   */
+  recordRunBlocked(runId: string, error: string, metadata: RunBlockedMetadata): boolean;
   /**
    * Remove a run from live workflow history/status. Any pending HIL prompt
    * waiter is rejected because the workflow will not resume through that path.
@@ -151,6 +206,16 @@ export interface Store {
   ): boolean;
   /** Wait for a stage/node-scoped HIL prompt to resolve. */
   awaitStagePendingPrompt(runId: string, stageId: string, promptId: string): Promise<unknown>;
+  /**
+   * Record a live-only draft for an active stage-local input/editor prompt.
+   * Draft text may contain secrets and must never be copied into snapshots,
+   * status output, logs, notifications, or persisted metadata.
+   */
+  recordStagePromptDraft(runId: string, stageId: string, promptId: string, text: string): boolean;
+  /** Return a live-only draft for an active stage-local input/editor prompt, if present. */
+  getStagePromptDraft(runId: string, stageId: string, promptId: string): string | undefined;
+  /** Clear a live-only draft for a stage-local prompt. */
+  clearStagePromptDraft(runId: string, stageId: string, promptId: string): boolean;
   /**
    * Return the live-only prompt answer record for a completed prompt stage, if
    * still available. The returned value may contain secrets and must never be
@@ -239,6 +304,7 @@ export function createStore(): Store {
   const _notices: WorkflowNotice[] = [];
   const _listeners: Set<(snap: StoreSnapshot) => void> = new Set();
   const _stagePromptAnswers = new Map<string, PromptAnswerRecord>();
+  const _stagePromptDrafts = new Map<string, string>();
   let _version = 0;
 
   /**
@@ -285,16 +351,36 @@ export function createStore(): Store {
     return JSON.stringify([runId, stageId]);
   }
 
-  function rejectStagePrompt(stage: StageSnapshot, reason: string): void {
+  function stagePromptDraftKey(runId: string, stageId: string, promptId: string): string {
+    return JSON.stringify([runId, stageId, promptId]);
+  }
+
+  function stageHasActiveTextPrompt(
+    runId: string,
+    stageId: string,
+    promptId: string,
+  ): { prompt: PendingPrompt } | undefined {
+    const run = findRun(runId);
+    if (!run || TERMINAL_STATUSES.has(run.status)) return undefined;
+    const stage = findStage(run, stageId);
+    if (!stage || isTerminalStageStatus(stage.status)) return undefined;
+    const prompt = stage.pendingPrompt;
+    if (!prompt || prompt.id !== promptId) return undefined;
+    if (prompt.kind !== "input" && prompt.kind !== "editor") return undefined;
+    return { prompt };
+  }
+
+  function rejectStagePrompt(runId: string, stage: StageSnapshot, reason: string): void {
     const prompt = stage.pendingPrompt;
     if (!prompt) return;
     stage.pendingPrompt = undefined;
+    _stagePromptDrafts.delete(stagePromptDraftKey(runId, stage.id, prompt.id));
     rejectPrompt(prompt.id, reason);
   }
 
-  function rejectAllStagePrompts(run: RunSnapshot, reason: string): void {
+  function rejectAllStagePrompts(runId: string, run: RunSnapshot, reason: string): void {
     for (const stage of run.stages) {
-      rejectStagePrompt(stage, reason);
+      rejectStagePrompt(runId, stage, reason);
     }
   }
 
@@ -417,6 +503,10 @@ export function createStore(): Store {
       existing.result = stage.result;
       existing.error = stage.error;
       existing.failureKind = stage.failureKind;
+      existing.failureCode = stage.failureCode;
+      existing.failureRecoverability = stage.failureRecoverability;
+      existing.failureDisposition = stage.failureDisposition;
+      existing.retryAfterMs = stage.retryAfterMs;
       existing.failureMessage = stage.failureMessage;
       existing.skippedReason = stage.skippedReason;
       if (stage.replayKey !== undefined) existing.replayKey = stage.replayKey;
@@ -427,7 +517,7 @@ export function createStore(): Store {
       if (stage.workflowChild !== undefined) existing.workflowChild = structuredClone(stage.workflowChild);
       delete existing.awaitingInputSince;
       delete existing.inputRequest;
-      rejectStagePrompt(existing, `atomic-workflows: stage ${stage.id} ended before prompt resolved`);
+      rejectStagePrompt(runId, existing, `atomic-workflows: stage ${stage.id} ended before prompt resolved`);
       _version++;
       notify();
     },
@@ -454,17 +544,26 @@ export function createStore(): Store {
         run.pausedAt = undefined;
       }
       run.durationMs = elapsedRunMs(run, run.endedAt);
-      if (status === "completed" && result !== undefined) {
-        run.result = result;
-      }
-      if ((status === "failed" || status === "killed") && error !== undefined) {
-        run.error = error;
-      }
-      if (metadata !== undefined) {
-        if (metadata.failureKind !== undefined) run.failureKind = metadata.failureKind;
-        if (metadata.failureMessage !== undefined) run.failureMessage = metadata.failureMessage;
-        if (metadata.failedStageId !== undefined) run.failedStageId = metadata.failedStageId;
-        if (metadata.resumable !== undefined) run.resumable = metadata.resumable;
+      const wasBlocked = run.blockedAt !== undefined || run.failureDisposition === "active_blocked";
+      delete run.blockedAt;
+      if (status === "completed") {
+        if (result !== undefined) {
+          run.result = result;
+        }
+        clearRunFailureMetadata(run);
+      } else {
+        if (wasBlocked && error === undefined) delete run.error;
+        if ((status === "failed" || status === "killed") && error !== undefined) {
+          run.error = error;
+        }
+        if (wasBlocked) clearStaleBlockedRunMetadata(run, metadata);
+        if (metadata !== undefined) applyRunEndMetadata(run, metadata);
+        if (run.failureDisposition === "active_blocked") delete run.failureDisposition;
+        if (status === "killed") {
+          run.failureRecoverability = "non_recoverable";
+          run.failureDisposition = "terminal_killed";
+          run.resumable = false;
+        }
       }
       // Abandon any waiting HIL prompt — workflow body never resumed past
       // it, but the awaiter promise must reject so the executor's catch
@@ -474,7 +573,27 @@ export function createStore(): Store {
         run.pendingPrompt = undefined;
         rejectPrompt(pending.id, `atomic-workflows: run ${runId} ended before prompt resolved`);
       }
-      rejectAllStagePrompts(run, `atomic-workflows: run ${runId} ended before prompt resolved`);
+      rejectAllStagePrompts(runId, run, `atomic-workflows: run ${runId} ended before prompt resolved`);
+      _version++;
+      notify();
+      return true;
+    },
+
+    recordRunBlocked(runId: string, error: string, metadata: RunBlockedMetadata): boolean {
+      const run = findRun(runId);
+      if (!run) return false;
+      if (TERMINAL_STATUSES.has(run.status)) return false;
+      run.status = "running";
+      run.error = error;
+      run.failureKind = metadata.failureKind;
+      run.failureCode = metadata.failureCode;
+      run.failureRecoverability = metadata.failureRecoverability;
+      run.failureDisposition = metadata.failureDisposition;
+      run.failureMessage = metadata.failureMessage;
+      run.failedStageId = metadata.failedStageId;
+      run.resumable = metadata.resumable;
+      run.blockedAt = metadata.blockedAt ?? Date.now();
+      if (metadata.retryAfterMs !== undefined) run.retryAfterMs = metadata.retryAfterMs;
       _version++;
       notify();
       return true;
@@ -488,7 +607,7 @@ export function createStore(): Store {
       if (pending) {
         rejectPrompt(pending.id, `atomic-workflows: run ${runId} was removed before prompt resolved`);
       }
-      rejectAllStagePrompts(run, `atomic-workflows: run ${runId} was removed before prompt resolved`);
+      rejectAllStagePrompts(runId, run, `atomic-workflows: run ${runId} was removed before prompt resolved`);
       for (const stage of run.stages) {
         _stagePromptAnswers.delete(stagePromptAnswerKey(runId, stage.id));
       }
@@ -599,6 +718,7 @@ export function createStore(): Store {
       if (!stage) return false;
       const pending = stage.pendingPrompt;
       if (!pending || pending.id !== promptId) return false;
+      _stagePromptDrafts.delete(stagePromptDraftKey(runId, stageId, promptId));
       if (options.recordAnswer !== false) {
         _stagePromptAnswers.set(stagePromptAnswerKey(runId, stageId), {
           runId,
@@ -654,6 +774,21 @@ export function createStore(): Store {
       });
     },
 
+    recordStagePromptDraft(runId: string, stageId: string, promptId: string, text: string): boolean {
+      if (stageHasActiveTextPrompt(runId, stageId, promptId) === undefined) return false;
+      _stagePromptDrafts.set(stagePromptDraftKey(runId, stageId, promptId), text);
+      return true;
+    },
+
+    getStagePromptDraft(runId: string, stageId: string, promptId: string): string | undefined {
+      if (stageHasActiveTextPrompt(runId, stageId, promptId) === undefined) return undefined;
+      return _stagePromptDrafts.get(stagePromptDraftKey(runId, stageId, promptId));
+    },
+
+    clearStagePromptDraft(runId: string, stageId: string, promptId: string): boolean {
+      return _stagePromptDrafts.delete(stagePromptDraftKey(runId, stageId, promptId));
+    },
+
     getStagePromptAnswer(runId: string, stageId: string): PromptAnswerRecord | undefined {
       return _stagePromptAnswers.get(stagePromptAnswerKey(runId, stageId));
     },
@@ -896,7 +1031,13 @@ export function createStore(): Store {
     },
 
     clear(): void {
-      if (_runs.length === 0 && _notices.length === 0 && _resolvers.size === 0 && _stagePromptAnswers.size === 0) return;
+      if (
+        _runs.length === 0 &&
+        _notices.length === 0 &&
+        _resolvers.size === 0 &&
+        _stagePromptAnswers.size === 0 &&
+        _stagePromptDrafts.size === 0
+      ) return;
       _runs.length = 0;
       _notices.length = 0;
       // Reject any outstanding HIL waiters so background promises terminate
@@ -907,6 +1048,7 @@ export function createStore(): Store {
       }
       _resolvers.clear();
       _stagePromptAnswers.clear();
+      _stagePromptDrafts.clear();
       _version++;
       notify();
     },

package/dist/builtin/workflows/src/shared/types.ts

@@ -6,7 +6,7 @@
 import type {
   AgentSession,
   AgentSessionEvent,
-  CompactionResult,
+  ContextCompactionResult,
   CreateAgentSessionOptions,
   ModelCycleResult,
   PromptOptions,
@@ -19,7 +19,7 @@ import type * as AuthoringContract from "./authoring-contract.js";
 
 export type { TSchema };
 
-export type { AgentSessionEvent, CompactionResult, ModelCycleResult, PromptOptions };
+export type { AgentSessionEvent, ContextCompactionResult, ModelCycleResult, PromptOptions };
 
 export type WorkflowModelValue = NonNullable<CreateAgentSessionOptions["model"]> | string;
 export type WorkflowModelUsage = AuthoringContract.WorkflowModelUsage;
@@ -308,7 +308,7 @@ export interface StageContext {
   ): Promise<{ editorText?: string; cancelled: boolean }>;
 
   /** Compaction. */
-  compact(customInstructions?: string): Promise<CompactionResult>;
+  compact(): Promise<ContextCompactionResult>;
   abortCompaction(): void;
 
   /** Abort current operation. */