@exaudeus/workrail 1.0.0 → 1.1.0

package/dist/v2/durable-core/domain/ack-advance-append-plan.d.ts

@@ -2,6 +2,10 @@ import type { DomainEventV1 } from '../schemas/session/index.js';
 import { type OutputToAppend } from './outputs.js';
 import { type Result } from 'neverthrow';
 import type { SnapshotRef, WorkflowHash } from '../ids/index.js';
+type AdvanceOutcomeV1 = Extract<DomainEventV1, {
+    kind: 'advance_recorded';
+}>['data']['outcome'];
+type EventToAppendV1 = Omit<DomainEventV1, 'eventIndex' | 'sessionId'>;
 export declare function buildAckAdvanceAppendPlanV1(args: {
     readonly sessionId: string;
     readonly runId: string;
@@ -9,16 +13,18 @@ export declare function buildAckAdvanceAppendPlanV1(args: {
     readonly workflowHash: WorkflowHash;
     readonly attemptId: string;
     readonly nextEventIndex: number;
-    readonly toNodeId: string;
-    readonly snapshotRef: SnapshotRef;
-    readonly causeKind: 'intentional_fork' | 'non_tip_advance';
+    readonly outcome?: AdvanceOutcomeV1;
+    readonly extraEventsToAppend?: readonly EventToAppendV1[];
+    readonly toNodeId?: string;
+    readonly snapshotRef?: SnapshotRef;
+    readonly causeKind?: 'intentional_fork' | 'non_tip_advance';
     readonly minted: {
         readonly advanceRecordedEventId: string;
-        readonly nodeCreatedEventId: string;
-        readonly edgeCreatedEventId: string;
-        readonly outputEventIds: readonly string[];
+        readonly nodeCreatedEventId?: string;
+        readonly edgeCreatedEventId?: string;
+        readonly outputEventIds?: readonly string[];
     };
-    readonly outputsToAppend: readonly OutputToAppend[];
+    readonly outputsToAppend?: readonly OutputToAppend[];
 }): Result<{
     readonly events: readonly DomainEventV1[];
     readonly snapshotPins: readonly {
@@ -30,3 +36,4 @@ export declare function buildAckAdvanceAppendPlanV1(args: {
     readonly code: 'INVARIANT_VIOLATION';
     readonly message: string;
 }>;
+export {};

package/dist/v2/durable-core/domain/ack-advance-append-plan.js

@@ -4,27 +4,81 @@ exports.buildAckAdvanceAppendPlanV1 = buildAckAdvanceAppendPlanV1;
 const outputs_js_1 = require("./outputs.js");
 const neverthrow_1 = require("neverthrow");
 function buildAckAdvanceAppendPlanV1(args) {
-    const { sessionId, runId, fromNodeId, workflowHash, attemptId, nextEventIndex, toNodeId, snapshotRef, causeKind, minted, outputsToAppend, } = args;
+    const { sessionId, runId, fromNodeId, workflowHash, attemptId, nextEventIndex, minted, outputsToAppend, extraEventsToAppend, } = args;
+    const outcome = args.outcome ??
+        (args.toNodeId
+            ? { kind: 'advanced', toNodeId: args.toNodeId }
+            :
+                (() => {
+                    throw new Error('INVARIANT: buildAckAdvanceAppendPlanV1 requires toNodeId when outcome is omitted');
+                })());
     const advanceDedupeKey = `advance_recorded:${sessionId}:${fromNodeId}:${attemptId}`;
-    const baseEvents = [
-        {
-            v: 1,
-            eventId: minted.advanceRecordedEventId,
-            eventIndex: nextEventIndex,
-            sessionId,
-            kind: 'advance_recorded',
-            dedupeKey: advanceDedupeKey,
-            scope: { runId, nodeId: fromNodeId },
-            data: {
-                attemptId,
-                intent: 'ack_pending',
-                outcome: { kind: 'advanced', toNodeId },
-            },
+    const advanceRecorded = {
+        v: 1,
+        eventId: minted.advanceRecordedEventId,
+        eventIndex: nextEventIndex,
+        sessionId,
+        kind: 'advance_recorded',
+        dedupeKey: advanceDedupeKey,
+        scope: { runId, nodeId: fromNodeId },
+        data: {
+            attemptId,
+            intent: 'ack_pending',
+            outcome,
         },
+    };
+    const extra = [];
+    if (extraEventsToAppend && extraEventsToAppend.length > 0) {
+        for (let i = 0; i < extraEventsToAppend.length; i++) {
+            const raw = extraEventsToAppend[i];
+            if ('eventIndex' in raw) {
+                return (0, neverthrow_1.err)({ code: 'INVARIANT_VIOLATION', message: 'extraEventsToAppend must not include eventIndex (assigned by append plan builder)' });
+            }
+            if ('sessionId' in raw) {
+                return (0, neverthrow_1.err)({ code: 'INVARIANT_VIOLATION', message: 'extraEventsToAppend must not include sessionId (assigned by append plan builder)' });
+            }
+            extra.push({
+                ...extraEventsToAppend[i],
+                sessionId,
+                eventIndex: nextEventIndex + 1 + i,
+            });
+        }
+    }
+    const nextIndexAfterExtra = nextEventIndex + 1 + extra.length;
+    if (outcome.kind === 'blocked') {
+        if (outputsToAppend && outputsToAppend.length > 0) {
+            return (0, neverthrow_1.err)({
+                code: 'INVARIANT_VIOLATION',
+                message: 'blocked outcome cannot include outputsToAppend (no node advancement occurs)',
+            });
+        }
+        return (0, neverthrow_1.ok)({
+            events: [advanceRecorded, ...extra],
+            snapshotPins: [],
+        });
+    }
+    if (!args.toNodeId || !args.snapshotRef || !args.causeKind) {
+        return (0, neverthrow_1.err)({
+            code: 'INVARIANT_VIOLATION',
+            message: 'advanced outcome requires toNodeId + snapshotRef + causeKind',
+        });
+    }
+    if (!minted.nodeCreatedEventId || !minted.edgeCreatedEventId || !minted.outputEventIds) {
+        return (0, neverthrow_1.err)({
+            code: 'INVARIANT_VIOLATION',
+            message: 'advanced outcome requires minted.nodeCreatedEventId + minted.edgeCreatedEventId + minted.outputEventIds',
+        });
+    }
+    const toNodeId = args.toNodeId;
+    const snapshotRef = args.snapshotRef;
+    const causeKind = args.causeKind;
+    const nodeCreatedEventIndex = nextIndexAfterExtra;
+    const edgeCreatedEventIndex = nextIndexAfterExtra + 1;
+    const advancedEvents = [
         {
             v: 1,
             eventId: minted.nodeCreatedEventId,
-            eventIndex: nextEventIndex + 1,
+            eventIndex: nodeCreatedEventIndex,
             sessionId,
             kind: 'node_created',
             dedupeKey: `node_created:${sessionId}:${runId}:${toNodeId}`,
@@ -39,7 +93,7 @@ function buildAckAdvanceAppendPlanV1(args) {
         {
             v: 1,
             eventId: minted.edgeCreatedEventId,
-            eventIndex: nextEventIndex + 2,
+            eventIndex: edgeCreatedEventIndex,
             sessionId,
             kind: 'edge_created',
             dedupeKey: `edge_created:${sessionId}:${runId}:${fromNodeId}->${toNodeId}:acked_step`,
@@ -52,8 +106,9 @@ function buildAckAdvanceAppendPlanV1(args) {
             },
         },
     ];
-    const normalizedOutputs = (0, outputs_js_1.normalizeOutputsForAppend)(outputsToAppend);
-    if (minted.outputEventIds.length !== normalizedOutputs.length) {
+    const normalizedOutputs = (0, outputs_js_1.normalizeOutputsForAppend)(outputsToAppend ?? []);
+    const outputEventIds = minted.outputEventIds ?? [];
+    if (outputEventIds.length !== normalizedOutputs.length) {
         return (0, neverthrow_1.err)({
             code: 'INVARIANT_VIOLATION',
             message: 'outputEventIds length mismatch (caller must supply exactly one eventId per output event)',
@@ -62,8 +117,8 @@ function buildAckAdvanceAppendPlanV1(args) {
     const outputEvents = normalizedOutputs.map((o, idx) => {
         const base = {
             v: 1,
-            eventId: minted.outputEventIds[idx],
-            eventIndex: nextEventIndex + 3 + idx,
+            eventId: outputEventIds[idx],
+            eventIndex: nextIndexAfterExtra + 2 + idx,
             sessionId,
             kind: 'node_output_appended',
             dedupeKey: `node_output_appended:${sessionId}:${o.outputId}`,
@@ -81,13 +136,13 @@ function buildAckAdvanceAppendPlanV1(args) {
             }
             : base;
     });
-    const events = [...baseEvents, ...outputEvents];
+    const events = [advanceRecorded, ...extra, ...advancedEvents, ...outputEvents];
     return (0, neverthrow_1.ok)({
         events,
         snapshotPins: [
             {
                 snapshotRef,
-                eventIndex: nextEventIndex + 1,
+                eventIndex: nodeCreatedEventIndex,
                 createdByEventId: minted.nodeCreatedEventId,
             },
         ],

package/dist/v2/durable-core/domain/blocking-decision.d.ts

@@ -0,0 +1,32 @@
+import { type Result } from 'neverthrow';
+import type { ValidationResult } from '../../../types/validation.js';
+import type { ReasonV1 } from './reason-model.js';
+export type BlockingDecisionError = {
+    readonly code: 'INVALID_DELIMITER_SAFE_ID';
+    readonly message: string;
+};
+export type OutputRequirementStatus = {
+    readonly kind: 'not_required';
+} | {
+    readonly kind: 'missing';
+    readonly contractRef: string;
+} | {
+    readonly kind: 'invalid';
+    readonly contractRef: string;
+    readonly validation: ValidationResult;
+};
+export type CapabilityRequirementStatus = {
+    readonly kind: 'not_required';
+} | {
+    readonly kind: 'unknown';
+    readonly capability: 'delegation' | 'web_browsing';
+} | {
+    readonly kind: 'unavailable';
+    readonly capability: 'delegation' | 'web_browsing';
+};
+export declare function detectBlockingReasonsV1(args: {
+    readonly missingContextKeys?: readonly string[];
+    readonly contextBudgetExceeded?: boolean;
+    readonly outputRequirement?: OutputRequirementStatus;
+    readonly capabilityRequirement?: CapabilityRequirementStatus;
+}): Result<readonly ReasonV1[], BlockingDecisionError>;

package/dist/v2/durable-core/domain/blocking-decision.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectBlockingReasonsV1 = detectBlockingReasonsV1;
+const neverthrow_1 = require("neverthrow");
+const constants_js_1 = require("../constants.js");
+function detectBlockingReasonsV1(args) {
+    const reasons = [];
+    if (args.contextBudgetExceeded) {
+        reasons.push({ kind: 'context_budget_exceeded' });
+    }
+    if (args.missingContextKeys) {
+        for (const key of args.missingContextKeys) {
+            if (!constants_js_1.DELIMITER_SAFE_ID_PATTERN.test(key)) {
+                return (0, neverthrow_1.err)({
+                    code: 'INVALID_DELIMITER_SAFE_ID',
+                    message: `context key must be delimiter-safe: [a-z0-9_-]+ (got: ${key})`,
+                });
+            }
+            reasons.push({ kind: 'missing_context_key', key });
+        }
+    }
+    const outReq = args.outputRequirement;
+    if (outReq && outReq.kind !== 'not_required') {
+        if (outReq.kind === 'missing') {
+            reasons.push({ kind: 'missing_required_output', contractRef: outReq.contractRef });
+        }
+        if (outReq.kind === 'invalid') {
+            reasons.push({ kind: 'invalid_required_output', contractRef: outReq.contractRef });
+        }
+    }
+    const capReq = args.capabilityRequirement;
+    if (capReq && capReq.kind !== 'not_required') {
+        if (capReq.kind === 'unknown') {
+            reasons.push({ kind: 'required_capability_unknown', capability: capReq.capability });
+        }
+        if (capReq.kind === 'unavailable') {
+            reasons.push({ kind: 'required_capability_unavailable', capability: capReq.capability });
+        }
+    }
+    return (0, neverthrow_1.ok)(reasons);
+}

package/dist/v2/durable-core/domain/context-merge.d.ts

@@ -0,0 +1,8 @@
+import type { JsonObject } from '../canonical/json-types.js';
+import type { Result } from 'neverthrow';
+export type ContextMergeError = {
+    readonly code: 'RESERVED_KEY_REJECTED';
+    readonly message: string;
+    readonly key: string;
+};
+export declare function mergeContext(stored: JsonObject | undefined, delta: JsonObject | undefined): Result<JsonObject, ContextMergeError>;

package/dist/v2/durable-core/domain/context-merge.js

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeContext = mergeContext;
+const neverthrow_1 = require("neverthrow");
+const RESERVED_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function mergeContext(stored, delta) {
+    if (!delta)
+        return (0, neverthrow_1.ok)(stored ?? {});
+    if (!stored)
+        return stripNullAndValidate(delta);
+    for (const reservedKey of RESERVED_KEYS) {
+        if (reservedKey in delta && Object.prototype.hasOwnProperty.call(delta, reservedKey)) {
+            return (0, neverthrow_1.err)({
+                code: 'RESERVED_KEY_REJECTED',
+                message: `Context key '${reservedKey}' is reserved and cannot be used.`,
+                key: reservedKey,
+            });
+        }
+    }
+    const tombstones = new Set(Object.entries(delta)
+        .filter(([_, v]) => v === null)
+        .map(([k]) => k));
+    const overrides = Object.fromEntries(Object.entries(delta).filter(([_, v]) => v !== null && v !== undefined));
+    const mergedEntries = Object.entries(stored)
+        .filter(([k]) => !tombstones.has(k))
+        .concat(Object.entries(overrides));
+    return (0, neverthrow_1.ok)(Object.fromEntries(mergedEntries));
+}
+function stripNullAndValidate(obj) {
+    const reservedKey = Object.keys(obj).find(k => RESERVED_KEYS.has(k));
+    if (reservedKey) {
+        return (0, neverthrow_1.err)({
+            code: 'RESERVED_KEY_REJECTED',
+            message: `Context key '${reservedKey}' is reserved and cannot be used.`,
+            key: reservedKey,
+        });
+    }
+    const entries = Object.entries(obj).filter(([_, v]) => v !== null && v !== undefined);
+    return (0, neverthrow_1.ok)(Object.fromEntries(entries));
+}

package/dist/v2/durable-core/domain/function-definition-expander.d.ts

@@ -0,0 +1,14 @@
+import type { Result } from 'neverthrow';
+import type { Workflow, FunctionDefinition } from '../../../types/workflow.js';
+import type { LoopPathFrameV1 } from '../schemas/execution-snapshot/index.js';
+export type FunctionExpansionError = {
+    readonly code: 'FUNCTION_EXPANSION_FAILED';
+    readonly message: string;
+};
+export declare function expandFunctionDefinitions(args: {
+    readonly workflow: Workflow;
+    readonly stepId: string;
+    readonly loopPath: readonly LoopPathFrameV1[];
+    readonly functionReferences: readonly string[];
+}): Result<readonly FunctionDefinition[], FunctionExpansionError>;
+export declare function formatFunctionDef(def: FunctionDefinition): string;

package/dist/v2/durable-core/domain/function-definition-expander.js

@@ -0,0 +1,66 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.expandFunctionDefinitions = expandFunctionDefinitions;
+exports.formatFunctionDef = formatFunctionDef;
+const neverthrow_1 = require("neverthrow");
+const workflow_js_1 = require("../../../types/workflow.js");
+function findLoopById(workflow, loopId) {
+    function searchSteps(steps) {
+        for (const step of steps) {
+            if (!(0, workflow_js_1.isLoopStepDefinition)(step))
+                continue;
+            if (step.id === loopId)
+                return step;
+            if (Array.isArray(step.body)) {
+                const found = searchSteps(step.body);
+                if (found)
+                    return found;
+            }
+        }
+        return null;
+    }
+    return searchSteps(workflow.definition.steps);
+}
+function getWorkflowScopeDefs(workflow) {
+    return workflow.definition.functionDefinitions?.filter(f => !f.scope || f.scope === 'workflow') ?? [];
+}
+function getLoopScopeDefs(args) {
+    return args.loopPath.flatMap(frame => {
+        const loopStep = findLoopById(args.workflow, String(frame.loopId));
+        return loopStep?.functionDefinitions?.filter(f => !f.scope || f.scope === 'loop') ?? [];
+    });
+}
+function getStepScopeDefs(args) {
+    const step = args.workflow.definition.steps.find(s => s.id === args.stepId);
+    return step?.functionDefinitions?.filter(f => !f.scope || f.scope === 'step') ?? [];
+}
+function expandFunctionDefinitions(args) {
+    const allDefs = [
+        ...getWorkflowScopeDefs(args.workflow),
+        ...getLoopScopeDefs({ workflow: args.workflow, loopPath: args.loopPath }),
+        ...getStepScopeDefs({ workflow: args.workflow, stepId: args.stepId }),
+    ];
+    const deduped = new Map();
+    for (const def of allDefs) {
+        if (!deduped.has(def.name)) {
+            deduped.set(def.name, def);
+        }
+    }
+    const filtered = args.functionReferences.length > 0
+        ? Array.from(deduped.values()).filter(f => args.functionReferences.includes(f.name))
+        : Array.from(deduped.values());
+    const scopePriority = { step: 0, loop: 1, workflow: 2 };
+    const sorted = filtered.sort((a, b) => {
+        const aScope = a.scope ?? 'workflow';
+        const bScope = b.scope ?? 'workflow';
+        const aPri = scopePriority[aScope] ?? 2;
+        const bPri = scopePriority[bScope] ?? 2;
+        if (aPri !== bPri)
+            return aPri - bPri;
+        return a.name.localeCompare(b.name);
+    });
+    return (0, neverthrow_1.ok)(sorted);
+}
+function formatFunctionDef(def) {
+    return `function ${def.name}(...)\n  ${def.definition}`;
+}

package/dist/v2/durable-core/domain/gap-builder.d.ts

@@ -0,0 +1,19 @@
+import type { DomainEventV1 } from '../schemas/session/index.js';
+import type { ReasonV1 } from './reason-model.js';
+export type GapEvidenceRefV1 = {
+    readonly kind: 'event';
+    readonly eventId: string;
+} | {
+    readonly kind: 'output';
+    readonly outputId: string;
+};
+export declare function buildGapRecordedEventV1(args: {
+    readonly eventId: string;
+    readonly eventIndex: number;
+    readonly sessionId: string;
+    readonly runId: string;
+    readonly nodeId: string;
+    readonly gapId: string;
+    readonly reason: ReasonV1;
+    readonly evidenceRefs?: readonly GapEvidenceRefV1[];
+}): DomainEventV1;

package/dist/v2/durable-core/domain/gap-builder.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildGapRecordedEventV1 = buildGapRecordedEventV1;
+const reason_model_js_1 = require("./reason-model.js");
+function buildGapRecordedEventV1(args) {
+    const { severity, reason, summary } = (0, reason_model_js_1.reasonToGap)(args.reason);
+    return {
+        v: 1,
+        eventId: args.eventId,
+        eventIndex: args.eventIndex,
+        sessionId: args.sessionId,
+        kind: 'gap_recorded',
+        dedupeKey: `gap_recorded:${args.sessionId}:${args.gapId}`,
+        scope: { runId: args.runId, nodeId: args.nodeId },
+        data: {
+            gapId: args.gapId,
+            severity,
+            reason,
+            summary,
+            resolution: { kind: 'unresolved' },
+            evidenceRefs: args.evidenceRefs,
+        },
+    };
+}

package/dist/v2/durable-core/domain/prompt-renderer.d.ts

@@ -0,0 +1,24 @@
+import type { Result } from 'neverthrow';
+import type { Workflow } from '../../../types/workflow.js';
+import type { LoadedSessionTruthV2 } from '../../ports/session-event-log-store.port.js';
+import type { LoopPathFrameV1 } from '../schemas/execution-snapshot/index.js';
+import type { NodeId, RunId } from '../ids/index.js';
+export type PromptRenderError = {
+    readonly code: 'RENDER_FAILED';
+    readonly message: string;
+};
+export interface StepMetadata {
+    readonly stepId: string;
+    readonly title: string;
+    readonly prompt: string;
+    readonly requireConfirmation: boolean;
+}
+export declare function renderPendingPrompt(args: {
+    readonly workflow: Workflow;
+    readonly stepId: string;
+    readonly loopPath: readonly LoopPathFrameV1[];
+    readonly truth: LoadedSessionTruthV2;
+    readonly runId: RunId;
+    readonly nodeId: NodeId;
+    readonly rehydrateOnly: boolean;
+}): Result<StepMetadata, PromptRenderError>;

package/dist/v2/durable-core/domain/prompt-renderer.js

@@ -0,0 +1,167 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renderPendingPrompt = renderPendingPrompt;
+const neverthrow_1 = require("neverthrow");
+const workflow_js_1 = require("../../../types/workflow.js");
+const index_js_1 = require("../ids/index.js");
+const run_dag_js_1 = require("../../projections/run-dag.js");
+const node_outputs_js_1 = require("../../projections/node-outputs.js");
+const recap_recovery_js_1 = require("./recap-recovery.js");
+const function_definition_expander_js_1 = require("./function-definition-expander.js");
+const constants_js_1 = require("../constants.js");
+function buildNonTipSections(args) {
+    const sections = [];
+    const childSummary = (0, recap_recovery_js_1.buildChildSummary)({ nodeId: args.nodeId, dag: args.run });
+    if (childSummary) {
+        sections.push(`### Branch Summary\n${childSummary}`);
+    }
+    if (args.run.preferredTipNodeId && args.run.preferredTipNodeId !== String(args.nodeId)) {
+        const downstreamRes = (0, recap_recovery_js_1.collectDownstreamRecap)({
+            fromNodeId: args.nodeId,
+            toNodeId: (0, index_js_1.asNodeId)(args.run.preferredTipNodeId),
+            dag: args.run,
+            outputs: args.outputs,
+        });
+        if (downstreamRes.isOk() && downstreamRes.value.length > 0) {
+            sections.push(`### Downstream Recap (Preferred Branch)\n${downstreamRes.value.join('\n\n')}`);
+        }
+    }
+    return sections;
+}
+function buildAncestrySections(args) {
+    const ancestryRes = (0, recap_recovery_js_1.collectAncestryRecap)({
+        nodeId: args.nodeId,
+        dag: args.run,
+        outputs: args.outputs,
+        includeCurrentNode: false,
+    });
+    if (ancestryRes.isOk() && ancestryRes.value.length > 0) {
+        return [`### Ancestry Recap\n${ancestryRes.value.join('\n\n')}`];
+    }
+    return [];
+}
+function buildFunctionDefsSections(args) {
+    const funcsRes = (0, function_definition_expander_js_1.expandFunctionDefinitions)({
+        workflow: args.workflow,
+        stepId: args.stepId,
+        loopPath: args.loopPath,
+        functionReferences: args.functionReferences,
+    });
+    if (funcsRes.isOk() && funcsRes.value.length > 0) {
+        const formatted = funcsRes.value.map(function_definition_expander_js_1.formatFunctionDef).join('\n\n');
+        return [`### Function Definitions\n\`\`\`\n${formatted}\n\`\`\``];
+    }
+    return [];
+}
+function buildRecoverySections(args) {
+    const isTip = args.run.tipNodeIds.includes(String(args.nodeId));
+    return [
+        ...(isTip ? [] : buildNonTipSections({ nodeId: args.nodeId, run: args.run, outputs: args.outputs })),
+        ...buildAncestrySections({ nodeId: args.nodeId, run: args.run, outputs: args.outputs }),
+        ...buildFunctionDefsSections({
+            workflow: args.workflow,
+            stepId: args.stepId,
+            loopPath: args.loopPath,
+            functionReferences: args.functionReferences,
+        }),
+    ];
+}
+function trimToUtf8Boundary(bytes) {
+    const n = bytes.length;
+    if (n === 0)
+        return bytes;
+    let cont = 0;
+    for (let i = n - 1; i >= 0 && i >= n - 4; i--) {
+        const b = bytes[i];
+        if ((b & 192) === 128) {
+            cont++;
+        }
+        else {
+            break;
+        }
+    }
+    if (cont === 0)
+        return bytes;
+    const leadByteIndex = n - cont - 1;
+    if (leadByteIndex < 0) {
+        return new Uint8Array(0);
+    }
+    const leadByte = bytes[leadByteIndex];
+    const expectedLen = (leadByte & 128) === 0 ? 1 :
+        (leadByte & 224) === 192 ? 2 :
+            (leadByte & 240) === 224 ? 3 :
+                (leadByte & 248) === 240 ? 4 :
+                    0;
+    const actualLen = cont + 1;
+    if (expectedLen === 0 || expectedLen !== actualLen) {
+        return bytes.subarray(0, leadByteIndex);
+    }
+    return bytes;
+}
+function applyPromptBudget(combinedPrompt) {
+    const encoder = new TextEncoder();
+    const promptBytes = encoder.encode(combinedPrompt);
+    if (promptBytes.length <= constants_js_1.RECOVERY_BUDGET_BYTES) {
+        return combinedPrompt;
+    }
+    const markerText = constants_js_1.TRUNCATION_MARKER;
+    const omissionNote = `\nOmitted recovery content due to budget constraints.`;
+    const suffixBytes = encoder.encode(markerText + omissionNote);
+    const maxContentBytes = constants_js_1.RECOVERY_BUDGET_BYTES - suffixBytes.length;
+    const truncatedBytes = trimToUtf8Boundary(promptBytes.subarray(0, maxContentBytes));
+    const decoder = new TextDecoder('utf-8');
+    return decoder.decode(truncatedBytes) + markerText + omissionNote;
+}
+function loadRecoveryProjections(args) {
+    const dagRes = (0, run_dag_js_1.projectRunDagV2)(args.truth.events);
+    if (dagRes.isErr()) {
+        return (0, neverthrow_1.err)('(Recovery context unavailable due to projection failure)');
+    }
+    const dag = dagRes.value;
+    const run = dag.runsById[args.runId];
+    if (!run) {
+        return (0, neverthrow_1.err)('(Recovery context unavailable: run not found)');
+    }
+    const outputsRes = (0, node_outputs_js_1.projectNodeOutputsV2)(args.truth.events);
+    if (outputsRes.isErr()) {
+        return (0, neverthrow_1.err)('(Recovery context unavailable due to outputs projection failure)');
+    }
+    return (0, neverthrow_1.ok)({ run, outputs: outputsRes.value });
+}
+function renderPendingPrompt(args) {
+    const step = (0, workflow_js_1.getStepById)(args.workflow, args.stepId);
+    const baseTitle = step?.title ?? args.stepId;
+    const basePrompt = step?.prompt ?? `Pending step: ${args.stepId}`;
+    const requireConfirmation = Boolean(step?.requireConfirmation);
+    const functionReferences = step?.functionReferences ?? [];
+    if (!args.rehydrateOnly) {
+        return (0, neverthrow_1.ok)({ stepId: args.stepId, title: baseTitle, prompt: basePrompt, requireConfirmation });
+    }
+    const projectionsRes = loadRecoveryProjections({ truth: args.truth, runId: args.runId });
+    if (projectionsRes.isErr()) {
+        return (0, neverthrow_1.ok)({
+            stepId: args.stepId,
+            title: baseTitle,
+            prompt: basePrompt + '\n\n' + projectionsRes.error,
+            requireConfirmation,
+        });
+    }
+    const { run, outputs } = projectionsRes.value;
+    const sections = buildRecoverySections({
+        nodeId: args.nodeId,
+        dag: run,
+        run,
+        outputs,
+        workflow: args.workflow,
+        stepId: args.stepId,
+        loopPath: args.loopPath,
+        functionReferences,
+    });
+    if (sections.length === 0) {
+        return (0, neverthrow_1.ok)({ stepId: args.stepId, title: baseTitle, prompt: basePrompt, requireConfirmation });
+    }
+    const recoveryText = `## Recovery Context\n\n${sections.join('\n\n')}`;
+    const combinedPrompt = `${basePrompt}\n\n${recoveryText}`;
+    const finalPrompt = applyPromptBudget(combinedPrompt);
+    return (0, neverthrow_1.ok)({ stepId: args.stepId, title: baseTitle, prompt: finalPrompt, requireConfirmation });
+}