@exaudeus/workrail 1.0.0 → 1.2.0

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

@@ -0,0 +1,20 @@
+import { type Result } from 'neverthrow';
+import type { Sha256PortV2 } from '../../ports/sha256.port.js';
+import type { AttemptId } from '../ids/index.js';
+import type { ExecutionSnapshotFileV1 } from '../schemas/execution-snapshot/index.js';
+import type { BlockerReportV1, ReasonV1 } from './reason-model.js';
+export type BlockedNodeBuildError = {
+    readonly code: 'BLOCKED_NODE_INVARIANT_VIOLATION';
+    readonly message: string;
+} | {
+    readonly code: 'BLOCKED_NODE_UNSUPPORTED_STATE';
+    readonly message: string;
+};
+export declare function buildBlockedNodeSnapshot(args: {
+    readonly priorSnapshot: ExecutionSnapshotFileV1;
+    readonly primaryReason: ReasonV1;
+    readonly attemptId: AttemptId;
+    readonly validationRef: string;
+    readonly blockers: BlockerReportV1;
+    readonly sha256: Sha256PortV2;
+}): Result<ExecutionSnapshotFileV1, BlockedNodeBuildError>;

package/dist/v2/durable-core/domain/blocked-node-builder.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildBlockedNodeSnapshot = buildBlockedNodeSnapshot;
+const neverthrow_1 = require("neverthrow");
+const attempt_id_derivation_js_1 = require("../ids/attempt-id-derivation.js");
+function toContractViolationReason(reason) {
+    switch (reason.kind) {
+        case 'invalid_required_output':
+            return { kind: 'invalid_required_output', contractRef: reason.contractRef };
+        case 'missing_required_output':
+            return { kind: 'missing_required_output', contractRef: reason.contractRef };
+        case 'missing_context_key':
+            return { kind: 'missing_context_key', key: reason.key };
+        case 'context_budget_exceeded':
+            return { kind: 'context_budget_exceeded' };
+        default:
+            return null;
+    }
+}
+function toTerminalReason(reason) {
+    switch (reason.kind) {
+        case 'user_only_dependency':
+            return { kind: 'user_only_dependency', detail: reason.detail, stepId: reason.stepId };
+        case 'required_capability_unknown':
+            return { kind: 'required_capability_unknown', capability: reason.capability };
+        case 'required_capability_unavailable':
+            return { kind: 'required_capability_unavailable', capability: reason.capability };
+        case 'invariant_violation':
+            return { kind: 'invariant_violation' };
+        case 'storage_corruption_detected':
+            return { kind: 'storage_corruption_detected' };
+        case 'evaluation_error':
+            return { kind: 'evaluation_error' };
+        default:
+            return null;
+    }
+}
+function buildBlockedPayload(args) {
+    const retryable = toContractViolationReason(args.primaryReason);
+    if (retryable) {
+        const retryAttemptId = (0, attempt_id_derivation_js_1.deriveChildAttemptId)(args.attemptId, args.sha256);
+        return (0, neverthrow_1.ok)({
+            kind: 'retryable_block',
+            reason: retryable,
+            retryAttemptId: String(retryAttemptId),
+            validationRef: args.validationRef,
+            blockers: args.blockers,
+        });
+    }
+    const terminal = toTerminalReason(args.primaryReason);
+    if (terminal) {
+        return (0, neverthrow_1.ok)({
+            kind: 'terminal_block',
+            reason: terminal,
+            validationRef: args.validationRef,
+            blockers: args.blockers,
+        });
+    }
+    return (0, neverthrow_1.err)({
+        code: 'BLOCKED_NODE_INVARIANT_VIOLATION',
+        message: `Unsupported primary reason for blocked snapshot: ${args.primaryReason.kind}`,
+    });
+}
+function buildBlockedNodeSnapshot(args) {
+    const state = args.priorSnapshot.enginePayload.engineState;
+    if (state.kind !== 'running' && state.kind !== 'blocked') {
+        return (0, neverthrow_1.err)({
+            code: 'BLOCKED_NODE_UNSUPPORTED_STATE',
+            message: `Blocked nodes can only be created from running or blocked state (got: ${state.kind})`,
+        });
+    }
+    const blockedRes = buildBlockedPayload({
+        primaryReason: args.primaryReason,
+        attemptId: args.attemptId,
+        validationRef: args.validationRef,
+        blockers: args.blockers,
+        sha256: args.sha256,
+    });
+    if (blockedRes.isErr())
+        return (0, neverthrow_1.err)(blockedRes.error);
+    return (0, neverthrow_1.ok)({
+        ...args.priorSnapshot,
+        enginePayload: {
+            ...args.priorSnapshot.enginePayload,
+            engineState: {
+                kind: 'blocked',
+                completed: state.completed,
+                loopStack: state.loopStack,
+                pending: state.pending,
+                blocked: blockedRes.value,
+            },
+        },
+    });
+}

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/decision-trace-builder.d.ts

@@ -0,0 +1,33 @@
+import type { Result } from 'neverthrow';
+export type DecisionTraceEntryKind = 'selected_next_step' | 'evaluated_condition' | 'entered_loop' | 'exited_loop' | 'detected_non_tip_advance';
+export type DecisionTraceRef = {
+    readonly kind: 'step_id';
+    readonly stepId: string;
+} | {
+    readonly kind: 'loop_id';
+    readonly loopId: string;
+} | {
+    readonly kind: 'condition_id';
+    readonly conditionId: string;
+} | {
+    readonly kind: 'iteration';
+    readonly value: number;
+};
+export interface DecisionTraceEntry {
+    readonly kind: DecisionTraceEntryKind;
+    readonly summary: string;
+    readonly refs?: readonly DecisionTraceRef[];
+}
+export declare function traceEnteredLoop(loopId: string, iteration: number): DecisionTraceEntry;
+export declare function traceEvaluatedCondition(loopId: string, iteration: number, result: boolean, source: 'artifact' | 'context' | 'legacy'): DecisionTraceEntry;
+export declare function traceExitedLoop(loopId: string, reason: string): DecisionTraceEntry;
+export declare function traceSelectedNextStep(stepId: string): DecisionTraceEntry;
+export declare function applyTraceBudget(entries: readonly DecisionTraceEntry[]): readonly DecisionTraceEntry[];
+export declare function buildDecisionTraceEventData(traceId: string, entries: readonly DecisionTraceEntry[]): Result<{
+    readonly traceId: string;
+    readonly entries: readonly {
+        readonly kind: string;
+        readonly summary: string;
+        readonly refs?: readonly DecisionTraceRef[];
+    }[];
+}, never>;

package/dist/v2/durable-core/domain/decision-trace-builder.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.traceEnteredLoop = traceEnteredLoop;
+exports.traceEvaluatedCondition = traceEvaluatedCondition;
+exports.traceExitedLoop = traceExitedLoop;
+exports.traceSelectedNextStep = traceSelectedNextStep;
+exports.applyTraceBudget = applyTraceBudget;
+exports.buildDecisionTraceEventData = buildDecisionTraceEventData;
+const neverthrow_1 = require("neverthrow");
+const constants_js_1 = require("../constants.js");
+function traceEnteredLoop(loopId, iteration) {
+    return {
+        kind: 'entered_loop',
+        summary: `Entered loop '${loopId}' at iteration ${iteration}.`,
+        refs: [{ kind: 'loop_id', loopId }, { kind: 'iteration', value: iteration }],
+    };
+}
+function traceEvaluatedCondition(loopId, iteration, result, source) {
+    const decision = result ? 'continue' : 'exit';
+    return {
+        kind: 'evaluated_condition',
+        summary: `Evaluated ${source} condition for loop '${loopId}' at iteration ${iteration}: ${decision}.`,
+        refs: [{ kind: 'loop_id', loopId }, { kind: 'iteration', value: iteration }],
+    };
+}
+function traceExitedLoop(loopId, reason) {
+    return {
+        kind: 'exited_loop',
+        summary: `Exited loop '${loopId}': ${reason}.`,
+        refs: [{ kind: 'loop_id', loopId }],
+    };
+}
+function traceSelectedNextStep(stepId) {
+    return {
+        kind: 'selected_next_step',
+        summary: `Selected next step '${stepId}'.`,
+        refs: [{ kind: 'step_id', stepId }],
+    };
+}
+const textEncoder = new TextEncoder();
+function utf8ByteLength(s) {
+    return textEncoder.encode(s).length;
+}
+function applyTraceBudget(entries) {
+    const capped = entries.slice(0, constants_js_1.MAX_DECISION_TRACE_ENTRIES);
+    let totalBytes = 0;
+    const result = [];
+    for (const entry of capped) {
+        let summary = entry.summary;
+        if (utf8ByteLength(summary) > constants_js_1.MAX_DECISION_TRACE_ENTRY_SUMMARY_BYTES) {
+            summary = truncateToUtf8Budget(summary, constants_js_1.MAX_DECISION_TRACE_ENTRY_SUMMARY_BYTES);
+        }
+        const entryBytes = utf8ByteLength(summary);
+        if (totalBytes + entryBytes > constants_js_1.MAX_DECISION_TRACE_TOTAL_BYTES) {
+            const remaining = constants_js_1.MAX_DECISION_TRACE_TOTAL_BYTES - totalBytes;
+            if (remaining > utf8ByteLength(constants_js_1.TRUNCATION_MARKER) + 10) {
+                summary = truncateToUtf8Budget(summary, remaining);
+                result.push({ ...entry, summary });
+            }
+            break;
+        }
+        totalBytes += entryBytes;
+        result.push(summary === entry.summary ? entry : { ...entry, summary });
+    }
+    return result;
+}
+function truncateToUtf8Budget(s, maxBytes) {
+    const markerBytes = utf8ByteLength(constants_js_1.TRUNCATION_MARKER);
+    const targetBytes = maxBytes - markerBytes;
+    if (targetBytes <= 0)
+        return constants_js_1.TRUNCATION_MARKER;
+    const encoded = textEncoder.encode(s);
+    if (encoded.length <= maxBytes)
+        return s;
+    let end = targetBytes;
+    while (end > 0 && (encoded[end] & 0xc0) === 0x80) {
+        end--;
+    }
+    const decoder = new TextDecoder();
+    return decoder.decode(encoded.slice(0, end)) + constants_js_1.TRUNCATION_MARKER;
+}
+function buildDecisionTraceEventData(traceId, entries) {
+    const budgeted = applyTraceBudget(entries);
+    return (0, neverthrow_1.ok)({
+        traceId,
+        entries: budgeted.map((e) => ({
+            kind: e.kind,
+            summary: e.summary,
+            refs: e.refs && e.refs.length > 0 ? e.refs : undefined,
+        })),
+    });
+}

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, 'en-US');
+    });
+    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/loop-control-evaluator.d.ts

@@ -0,0 +1,13 @@
+import { type LoopControlDecision, type LoopControlArtifactV1 } from '../schemas/artifacts/index.js';
+export type LoopControlEvaluationResult = {
+    readonly kind: 'found';
+    readonly decision: LoopControlDecision;
+    readonly artifact: LoopControlArtifactV1;
+} | {
+    readonly kind: 'not_found';
+    readonly reason: string;
+} | {
+    readonly kind: 'invalid';
+    readonly reason: string;
+};
+export declare function evaluateLoopControlFromArtifacts(artifacts: readonly unknown[], loopId: string): LoopControlEvaluationResult;

package/dist/v2/durable-core/domain/loop-control-evaluator.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateLoopControlFromArtifacts = evaluateLoopControlFromArtifacts;
+const index_js_1 = require("../schemas/artifacts/index.js");
+function evaluateLoopControlFromArtifacts(artifacts, loopId) {
+    if (artifacts.length === 0) {
+        return {
+            kind: 'not_found',
+            reason: `No artifacts provided to evaluate loop control for loopId=${loopId}`,
+        };
+    }
+    const artifact = (0, index_js_1.findLoopControlArtifact)(artifacts, loopId);
+    if (!artifact) {
+        return {
+            kind: 'not_found',
+            reason: `No loop control artifact found for loopId=${loopId}`,
+        };
+    }
+    return {
+        kind: 'found',
+        decision: artifact.decision,
+        artifact,
+    };
+}

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

@@ -0,0 +1,16 @@
+import type { WorkspaceAnchor } from '../../ports/workspace-anchor.port.js';
+export interface ObservationEventData {
+    readonly key: 'git_branch' | 'git_head_sha' | 'repo_root_hash';
+    readonly value: {
+        readonly type: 'short_string';
+        readonly value: string;
+    } | {
+        readonly type: 'git_sha1';
+        readonly value: string;
+    } | {
+        readonly type: 'sha256';
+        readonly value: string;
+    };
+    readonly confidence: 'low' | 'med' | 'high';
+}
+export declare function anchorsToObservations(anchors: readonly WorkspaceAnchor[]): readonly ObservationEventData[];

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.anchorsToObservations = anchorsToObservations;
+function anchorsToObservations(anchors) {
+    const observations = [];
+    for (const anchor of anchors) {
+        switch (anchor.key) {
+            case 'git_branch':
+                if (anchor.value.length > 80)
+                    break;
+                observations.push({
+                    key: 'git_branch',
+                    value: { type: 'short_string', value: anchor.value },
+                    confidence: 'high',
+                });
+                break;
+            case 'git_head_sha':
+                if (!/^[0-9a-f]{40}$/.test(anchor.value))
+                    break;
+                observations.push({
+                    key: 'git_head_sha',
+                    value: { type: 'git_sha1', value: anchor.value },
+                    confidence: 'high',
+                });
+                break;
+            case 'repo_root_hash':
+                if (!/^sha256:[0-9a-f]{64}$/.test(anchor.value))
+                    break;
+                observations.push({
+                    key: 'repo_root_hash',
+                    value: { type: 'sha256', value: anchor.value },
+                    confidence: 'high',
+                });
+                break;
+            default: {
+                const _exhaustive = anchor;
+                return _exhaustive;
+            }
+        }
+    }
+    return observations;
+}

package/dist/v2/durable-core/domain/outputs.js

@@ -9,10 +9,10 @@ function normalizeOutputsForAppend(outputs) {
         const aSha = a.payload.sha256 ?? '';
         const bSha = b.payload.sha256 ?? '';
         if (aSha !== bSha)
-            return aSha.localeCompare(bSha);
+            return aSha.localeCompare(bSha, 'en-US');
         const aType = a.payload.contentType ?? '';
         const bType = b.payload.contentType ?? '';
-        return aType.localeCompare(bType);
+        return aType.localeCompare(bType, 'en-US');
     });
     return [...recapFirst, ...sortedArtifacts];
 }

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>;