@exaudeus/workrail 0.12.0 → 0.13.0

package/dist/v2/durable-core/schemas/export-bundle/index.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ManifestRecordV1Schema = exports.DomainEventV1Schema = exports.ExecutionSnapshotFileV1Schema = exports.BundleImportErrorSchema = exports.BundleImportErrorCodeSchema = exports.ExportBundleV1Schema = exports.SessionContentsV1Schema = exports.ProducerInfoV1Schema = exports.IntegrityManifestV1Schema = exports.IntegrityEntryV1Schema = void 0;
+exports.importCollisionPolicy = importCollisionPolicy;
+exports.importValidationOrder = importValidationOrder;
+const zod_1 = require("zod");
+const constants_js_1 = require("../../constants.js");
+const index_js_1 = require("../execution-snapshot/index.js");
+const events_js_1 = require("../session/events.js");
+const index_js_2 = require("../session/index.js");
+const Sha256DigestSchema = zod_1.z
+    .string()
+    .regex(constants_js_1.SHA256_DIGEST_PATTERN, 'Expected sha256:<64 hex chars>')
+    .describe('SHA-256 digest in format sha256:<64 lowercase hex>');
+exports.IntegrityEntryV1Schema = zod_1.z.object({
+    path: zod_1.z.string().min(1).describe('Location within bundle (e.g., "session/events")'),
+    sha256: Sha256DigestSchema.describe('JCS canonical JSON + SHA-256'),
+    bytes: zod_1.z.number().int().nonnegative().describe('Byte length of JCS canonical UTF-8'),
+});
+exports.IntegrityManifestV1Schema = zod_1.z.object({
+    kind: zod_1.z.literal('sha256_manifest_v1').describe('Integrity scheme identifier'),
+    entries: zod_1.z
+        .array(exports.IntegrityEntryV1Schema)
+        .min(1)
+        .describe('Integrity entries for each major artifact path'),
+});
+exports.ProducerInfoV1Schema = zod_1.z.object({
+    appVersion: zod_1.z.string().min(1).describe('Application version that produced the bundle'),
+    appliedConfigHash: Sha256DigestSchema.optional().describe('Optional: hash of applied config'),
+});
+const SnapshotsMapV1Schema = zod_1.z
+    .record(zod_1.z.string().min(1).describe('SnapshotRef (sha256:<digest>)'), index_js_1.ExecutionSnapshotFileV1Schema)
+    .describe('Content-addressed snapshot storage');
+const PinnedWorkflowsMapV1Schema = zod_1.z
+    .record(zod_1.z.string().min(1).describe('WorkflowHash (sha256:<digest>)'), zod_1.z.unknown().describe('CompiledWorkflowV1 or equivalent snapshot'))
+    .describe('Pinned workflow definitions by hash');
+exports.SessionContentsV1Schema = zod_1.z.object({
+    sessionId: zod_1.z.string().min(1).describe('Stable session identifier'),
+    events: zod_1.z
+        .array(events_js_1.DomainEventV1Schema)
+        .describe('Ordered session events by ascending eventIndex'),
+    manifest: zod_1.z
+        .array(index_js_2.ManifestRecordV1Schema)
+        .describe('Ordered manifest records by ascending manifestIndex'),
+    snapshots: SnapshotsMapV1Schema.describe('Content-addressed snapshot CAS'),
+    pinnedWorkflows: PinnedWorkflowsMapV1Schema.describe('Pinned workflow definitions'),
+});
+exports.ExportBundleV1Schema = zod_1.z.object({
+    bundleSchemaVersion: zod_1.z.literal(1).describe('Bundle format version (1)'),
+    bundleId: zod_1.z.string().min(1).describe('Stable bundle identifier'),
+    exportedAt: zod_1.z.string().datetime().describe('ISO 8601 timestamp (informational only)'),
+    producer: exports.ProducerInfoV1Schema.describe('Informational producer metadata'),
+    integrity: exports.IntegrityManifestV1Schema.describe('Corruption detection manifest'),
+    session: exports.SessionContentsV1Schema.describe('Session durable truth'),
+});
+exports.BundleImportErrorCodeSchema = zod_1.z.enum([
+    'BUNDLE_INVALID_FORMAT',
+    'BUNDLE_UNSUPPORTED_VERSION',
+    'BUNDLE_INTEGRITY_FAILED',
+    'BUNDLE_MISSING_SNAPSHOT',
+    'BUNDLE_MISSING_PINNED_WORKFLOW',
+    'BUNDLE_EVENT_ORDER_INVALID',
+    'BUNDLE_MANIFEST_ORDER_INVALID',
+]);
+exports.BundleImportErrorSchema = zod_1.z.object({
+    code: exports.BundleImportErrorCodeSchema,
+    message: zod_1.z.string().min(1).describe('Human-readable error message'),
+    retry: zod_1.z.enum(['yes', 'no']).describe('Whether caller should retry'),
+    details: zod_1.z.record(zod_1.z.unknown()).optional().describe('Additional debugging context'),
+});
+function importCollisionPolicy(args) {
+    return 'import_as_new';
+}
+function importValidationOrder() {
+    return ['schema', 'integrity', 'ordering', 'references'];
+}
+var index_js_3 = require("../execution-snapshot/index.js");
+Object.defineProperty(exports, "ExecutionSnapshotFileV1Schema", { enumerable: true, get: function () { return index_js_3.ExecutionSnapshotFileV1Schema; } });
+var events_js_2 = require("../session/events.js");
+Object.defineProperty(exports, "DomainEventV1Schema", { enumerable: true, get: function () { return events_js_2.DomainEventV1Schema; } });
+var index_js_4 = require("../session/index.js");
+Object.defineProperty(exports, "ManifestRecordV1Schema", { enumerable: true, get: function () { return index_js_4.ManifestRecordV1Schema; } });

package/dist/v2/durable-core/schemas/lib/decision-trace-ref.d.ts

@@ -0,0 +1,80 @@
+import { z } from 'zod';
+export declare const DecisionTraceRefKindSchema: z.ZodEnum<["step_id", "loop_id", "condition_id", "iteration"]>;
+export type DecisionTraceRefKind = z.infer<typeof DecisionTraceRefKindSchema>;
+export declare const DecisionTraceRefV1Schema: z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"step_id">;
+    stepId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "step_id";
+    stepId: string;
+}, {
+    kind: "step_id";
+    stepId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"loop_id">;
+    loopId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "loop_id";
+    loopId: string;
+}, {
+    kind: "loop_id";
+    loopId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"condition_id">;
+    conditionId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "condition_id";
+    conditionId: string;
+}, {
+    kind: "condition_id";
+    conditionId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"iteration">;
+    value: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    value: number;
+    kind: "iteration";
+}, {
+    value: number;
+    kind: "iteration";
+}>]>;
+export type DecisionTraceRefV1 = z.infer<typeof DecisionTraceRefV1Schema>;
+export declare const MAX_DECISION_TRACE_REFS_PER_ENTRY = 10;
+export declare const DecisionTraceRefsV1Schema: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+    kind: z.ZodLiteral<"step_id">;
+    stepId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "step_id";
+    stepId: string;
+}, {
+    kind: "step_id";
+    stepId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"loop_id">;
+    loopId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "loop_id";
+    loopId: string;
+}, {
+    kind: "loop_id";
+    loopId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"condition_id">;
+    conditionId: z.ZodString;
+}, "strict", z.ZodTypeAny, {
+    kind: "condition_id";
+    conditionId: string;
+}, {
+    kind: "condition_id";
+    conditionId: string;
+}>, z.ZodObject<{
+    kind: z.ZodLiteral<"iteration">;
+    value: z.ZodNumber;
+}, "strict", z.ZodTypeAny, {
+    value: number;
+    kind: "iteration";
+}, {
+    value: number;
+    kind: "iteration";
+}>]>, "many">>;
+export type DecisionTraceRefsV1 = z.infer<typeof DecisionTraceRefsV1Schema>;

package/dist/v2/durable-core/schemas/lib/decision-trace-ref.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DecisionTraceRefsV1Schema = exports.MAX_DECISION_TRACE_REFS_PER_ENTRY = exports.DecisionTraceRefV1Schema = exports.DecisionTraceRefKindSchema = void 0;
+const zod_1 = require("zod");
+const constants_js_1 = require("../../constants.js");
+exports.DecisionTraceRefKindSchema = zod_1.z.enum([
+    'step_id',
+    'loop_id',
+    'condition_id',
+    'iteration',
+]);
+const StepIdRefSchema = zod_1.z.object({
+    kind: zod_1.z.literal('step_id'),
+    stepId: zod_1.z.string().regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'stepId must be delimiter-safe: [a-z0-9_-]+'),
+}).strict();
+const LoopIdRefSchema = zod_1.z.object({
+    kind: zod_1.z.literal('loop_id'),
+    loopId: zod_1.z.string().regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'loopId must be delimiter-safe: [a-z0-9_-]+'),
+}).strict();
+const ConditionIdRefSchema = zod_1.z.object({
+    kind: zod_1.z.literal('condition_id'),
+    conditionId: zod_1.z.string().regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'conditionId must be delimiter-safe: [a-z0-9_-]+'),
+}).strict();
+const IterationRefSchema = zod_1.z.object({
+    kind: zod_1.z.literal('iteration'),
+    value: zod_1.z.number().int().nonnegative(),
+}).strict();
+exports.DecisionTraceRefV1Schema = zod_1.z.discriminatedUnion('kind', [
+    StepIdRefSchema,
+    LoopIdRefSchema,
+    ConditionIdRefSchema,
+    IterationRefSchema,
+]);
+exports.MAX_DECISION_TRACE_REFS_PER_ENTRY = 10;
+exports.DecisionTraceRefsV1Schema = zod_1.z
+    .array(exports.DecisionTraceRefV1Schema)
+    .max(exports.MAX_DECISION_TRACE_REFS_PER_ENTRY)
+    .optional();

package/dist/v2/durable-core/schemas/lib/dedupe-key.d.ts

@@ -0,0 +1,8 @@
+import { z } from 'zod';
+import type { Brand } from '../../../../runtime/brand.js';
+export type DedupeKeyV1 = Brand<string, 'v2.DedupeKeyV1'>;
+export declare const DEDUPE_KEY_PATTERN: RegExp;
+export declare const MAX_DEDUPE_KEY_LENGTH = 256;
+export declare const DedupeKeyV1Schema: z.ZodString;
+export declare function buildDedupeKey(kind: string, parts: readonly string[]): DedupeKeyV1;
+export declare function isValidDedupeKey(value: string): value is DedupeKeyV1;

package/dist/v2/durable-core/schemas/lib/dedupe-key.js

@@ -0,0 +1,28 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DedupeKeyV1Schema = exports.MAX_DEDUPE_KEY_LENGTH = exports.DEDUPE_KEY_PATTERN = void 0;
+exports.buildDedupeKey = buildDedupeKey;
+exports.isValidDedupeKey = isValidDedupeKey;
+const zod_1 = require("zod");
+exports.DEDUPE_KEY_PATTERN = /^[a-z0-9_:>-]+$/;
+exports.MAX_DEDUPE_KEY_LENGTH = 256;
+exports.DedupeKeyV1Schema = zod_1.z
+    .string()
+    .min(1)
+    .max(exports.MAX_DEDUPE_KEY_LENGTH)
+    .regex(exports.DEDUPE_KEY_PATTERN, 'dedupeKey must be ASCII-safe: [a-z0-9_:->]+');
+function buildDedupeKey(kind, parts) {
+    const key = [kind, ...parts].join(':');
+    if (!exports.DEDUPE_KEY_PATTERN.test(key)) {
+        throw new Error(`Invalid dedupeKey: "${key}" does not match pattern ${exports.DEDUPE_KEY_PATTERN}`);
+    }
+    if (key.length > exports.MAX_DEDUPE_KEY_LENGTH) {
+        throw new Error(`Invalid dedupeKey: "${key}" exceeds max length ${exports.MAX_DEDUPE_KEY_LENGTH}`);
+    }
+    return key;
+}
+function isValidDedupeKey(value) {
+    return (value.length > 0 &&
+        value.length <= exports.MAX_DEDUPE_KEY_LENGTH &&
+        exports.DEDUPE_KEY_PATTERN.test(value));
+}

package/dist/v2/durable-core/schemas/lib/utf8-bounded-string.d.ts

@@ -0,0 +1,6 @@
+import { z } from 'zod';
+export declare function utf8BoundedString(opts: {
+    readonly maxBytes: number;
+    readonly label: string;
+    readonly minLength?: number;
+}): z.ZodEffects<z.ZodString, string, string>;

package/dist/v2/durable-core/schemas/lib/utf8-bounded-string.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.utf8BoundedString = utf8BoundedString;
+const zod_1 = require("zod");
+function utf8BoundedString(opts) {
+    const encoder = new TextEncoder();
+    let schema = zod_1.z.string();
+    if (opts.minLength !== undefined && opts.minLength > 0) {
+        schema = schema.min(opts.minLength);
+    }
+    return schema.refine((s) => encoder.encode(s).length <= opts.maxBytes, { message: `${opts.label} exceeds ${opts.maxBytes} UTF-8 bytes` });
+}

package/dist/v2/durable-core/schemas/session/events.d.ts

@@ -496,8 +496,8 @@ export declare const DomainEventV1Schema: z.ZodDiscriminatedUnion<"kind", [z.Zod
                         kind: "workflow_step";
                         stepId: string;
                     }>]>;
-                    message: z.ZodString;
-                    suggestedFix: z.ZodOptional<z.ZodString>;
+                    message: z.ZodEffects<z.ZodString, string, string>;
+                    suggestedFix: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
                 }, "strip", z.ZodTypeAny, {
                     message: string;
                     code: "USER_ONLY_DEPENDENCY" | "MISSING_REQUIRED_OUTPUT" | "INVALID_REQUIRED_OUTPUT" | "REQUIRED_CAPABILITY_UNKNOWN" | "REQUIRED_CAPABILITY_UNAVAILABLE" | "INVARIANT_VIOLATION" | "STORAGE_CORRUPTION_DETECTED";
@@ -853,7 +853,7 @@ export declare const DomainEventV1Schema: z.ZodDiscriminatedUnion<"kind", [z.Zod
         outputChannel: z.ZodEnum<["recap", "artifact"]>;
         payload: z.ZodDiscriminatedUnion<"payloadKind", [z.ZodObject<{
             payloadKind: z.ZodLiteral<"notes">;
-            notesMarkdown: z.ZodString;
+            notesMarkdown: z.ZodEffects<z.ZodString, string, string>;
         }, "strip", z.ZodTypeAny, {
             payloadKind: "notes";
             notesMarkdown: string;
@@ -1770,33 +1770,155 @@ export declare const DomainEventV1Schema: z.ZodDiscriminatedUnion<"kind", [z.Zod
         runId: string;
         nodeId: string;
     }>;
-    data: z.ZodObject<{
+    data: z.ZodEffects<z.ZodObject<{
         traceId: z.ZodString;
         entries: z.ZodArray<z.ZodObject<{
             kind: z.ZodEnum<["selected_next_step", "evaluated_condition", "entered_loop", "exited_loop", "detected_non_tip_advance"]>;
-            summary: z.ZodString;
-            refs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            summary: z.ZodEffects<z.ZodString, string, string>;
+            refs: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<"kind", [z.ZodObject<{
+                kind: z.ZodLiteral<"step_id">;
+                stepId: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                kind: "step_id";
+                stepId: string;
+            }, {
+                kind: "step_id";
+                stepId: string;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"loop_id">;
+                loopId: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                kind: "loop_id";
+                loopId: string;
+            }, {
+                kind: "loop_id";
+                loopId: string;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"condition_id">;
+                conditionId: z.ZodString;
+            }, "strict", z.ZodTypeAny, {
+                kind: "condition_id";
+                conditionId: string;
+            }, {
+                kind: "condition_id";
+                conditionId: string;
+            }>, z.ZodObject<{
+                kind: z.ZodLiteral<"iteration">;
+                value: z.ZodNumber;
+            }, "strict", z.ZodTypeAny, {
+                value: number;
+                kind: "iteration";
+            }, {
+                value: number;
+                kind: "iteration";
+            }>]>, "many">>;
         }, "strip", z.ZodTypeAny, {
             kind: "selected_next_step" | "evaluated_condition" | "entered_loop" | "exited_loop" | "detected_non_tip_advance";
             summary: string;
-            refs?: Record<string, unknown> | undefined;
+            refs?: ({
+                kind: "step_id";
+                stepId: string;
+            } | {
+                kind: "loop_id";
+                loopId: string;
+            } | {
+                kind: "condition_id";
+                conditionId: string;
+            } | {
+                value: number;
+                kind: "iteration";
+            })[] | undefined;
         }, {
             kind: "selected_next_step" | "evaluated_condition" | "entered_loop" | "exited_loop" | "detected_non_tip_advance";
             summary: string;
-            refs?: Record<string, unknown> | undefined;
+            refs?: ({
+                kind: "step_id";
+                stepId: string;
+            } | {
+                kind: "loop_id";
+                loopId: string;
+            } | {
+                kind: "condition_id";
+                conditionId: string;
+            } | {
+                value: number;
+                kind: "iteration";
+            })[] | undefined;
         }>, "many">;
     }, "strip", z.ZodTypeAny, {
         entries: {
             kind: "selected_next_step" | "evaluated_condition" | "entered_loop" | "exited_loop" | "detected_non_tip_advance";
             summary: string;
-            refs?: Record<string, unknown> | undefined;
+            refs?: ({
+                kind: "step_id";
+                stepId: string;
+            } | {
+                kind: "loop_id";
+                loopId: string;
+            } | {
+                kind: "condition_id";
+                conditionId: string;
+            } | {
+                value: number;
+                kind: "iteration";
+            })[] | undefined;
+        }[];
+        traceId: string;
+    }, {
+        entries: {
+            kind: "selected_next_step" | "evaluated_condition" | "entered_loop" | "exited_loop" | "detected_non_tip_advance";
+            summary: string;
+            refs?: ({
+                kind: "step_id";
+                stepId: string;
+            } | {
+                kind: "loop_id";
+                loopId: string;
+            } | {
+                kind: "condition_id";
+                conditionId: string;
+            } | {
+                value: number;
+                kind: "iteration";
+            })[] | undefined;
+        }[];
+        traceId: string;
+    }>, {
+        entries: {
+            kind: "selected_next_step" | "evaluated_condition" | "entered_loop" | "exited_loop" | "detected_non_tip_advance";
+            summary: string;
+            refs?: ({
+                kind: "step_id";
+                stepId: string;
+            } | {
+                kind: "loop_id";
+                loopId: string;
+            } | {
+                kind: "condition_id";
+                conditionId: string;
+            } | {
+                value: number;
+                kind: "iteration";
+            })[] | undefined;
         }[];
         traceId: string;
     }, {
         entries: {
             kind: "selected_next_step" | "evaluated_condition" | "entered_loop" | "exited_loop" | "detected_non_tip_advance";
             summary: string;
-            refs?: Record<string, unknown> | undefined;
+            refs?: ({
+                kind: "step_id";
+                stepId: string;
+            } | {
+                kind: "loop_id";
+                loopId: string;
+            } | {
+                kind: "condition_id";
+                conditionId: string;
+            } | {
+                value: number;
+                kind: "iteration";
+            })[] | undefined;
         }[];
         traceId: string;
     }>;
@@ -1807,7 +1929,19 @@ export declare const DomainEventV1Schema: z.ZodDiscriminatedUnion<"kind", [z.Zod
         entries: {
             kind: "selected_next_step" | "evaluated_condition" | "entered_loop" | "exited_loop" | "detected_non_tip_advance";
             summary: string;
-            refs?: Record<string, unknown> | undefined;
+            refs?: ({
+                kind: "step_id";
+                stepId: string;
+            } | {
+                kind: "loop_id";
+                loopId: string;
+            } | {
+                kind: "condition_id";
+                conditionId: string;
+            } | {
+                value: number;
+                kind: "iteration";
+            })[] | undefined;
         }[];
         traceId: string;
     };
@@ -1826,7 +1960,19 @@ export declare const DomainEventV1Schema: z.ZodDiscriminatedUnion<"kind", [z.Zod
         entries: {
             kind: "selected_next_step" | "evaluated_condition" | "entered_loop" | "exited_loop" | "detected_non_tip_advance";
             summary: string;
-            refs?: Record<string, unknown> | undefined;
+            refs?: ({
+                kind: "step_id";
+                stepId: string;
+            } | {
+                kind: "loop_id";
+                loopId: string;
+            } | {
+                kind: "condition_id";
+                conditionId: string;
+            } | {
+                value: number;
+                kind: "iteration";
+            })[] | undefined;
         }[];
         traceId: string;
     };

package/dist/v2/durable-core/schemas/session/events.js

@@ -4,9 +4,17 @@ exports.DomainEventV1Schema = exports.DomainEventEnvelopeV1Schema = void 0;
 const zod_1 = require("zod");
 const json_zod_js_1 = require("../../canonical/json-zod.js");
 const index_js_1 = require("../../ids/index.js");
+const preferences_js_1 = require("./preferences.js");
+const constants_js_1 = require("../../constants.js");
+const decision_trace_ref_js_1 = require("../lib/decision-trace-ref.js");
+const dedupe_key_js_1 = require("../lib/dedupe-key.js");
+const utf8_bounded_string_js_1 = require("../lib/utf8-bounded-string.js");
+function utf8ByteLength(s) {
+    return new TextEncoder().encode(s).length;
+}
 const sha256DigestSchema = zod_1.z
     .string()
-    .regex(/^sha256:[0-9a-f]{64}$/, 'Expected sha256:<64 hex chars>')
+    .regex(constants_js_1.SHA256_DIGEST_PATTERN, 'Expected sha256:<64 hex chars>')
     .describe('sha256 digest in WorkRail v2 format');
 const workflowHashSchema = sha256DigestSchema
     .transform((v) => (0, index_js_1.asWorkflowHash)((0, index_js_1.asSha256Digest)(v)))
@@ -20,7 +28,7 @@ exports.DomainEventEnvelopeV1Schema = zod_1.z.object({
     eventIndex: zod_1.z.number().int().nonnegative(),
     sessionId: zod_1.z.string().min(1),
     kind: zod_1.z.string().min(1),
-    dedupeKey: zod_1.z.string().min(1),
+    dedupeKey: dedupe_key_js_1.DedupeKeyV1Schema,
     scope: zod_1.z
         .object({
         runId: zod_1.z.string().min(1).optional(),
@@ -68,7 +76,12 @@ const EdgeCreatedDataV1Schema = zod_1.z
 const OutputChannelSchema = zod_1.z.enum(['recap', 'artifact']);
 const NotesPayloadV1Schema = zod_1.z.object({
     payloadKind: zod_1.z.literal('notes'),
-    notesMarkdown: zod_1.z.string().min(1),
+    notesMarkdown: zod_1.z
+        .string()
+        .min(1)
+        .refine((s) => utf8ByteLength(s) <= constants_js_1.MAX_OUTPUT_NOTES_MARKDOWN_BYTES, {
+        message: `notesMarkdown exceeds max ${constants_js_1.MAX_OUTPUT_NOTES_MARKDOWN_BYTES} UTF-8 bytes`,
+    }),
 });
 const ArtifactRefPayloadV1Schema = zod_1.z.object({
     payloadKind: zod_1.z.literal('artifact_ref'),
@@ -103,21 +116,32 @@ const BlockerCodeSchema = zod_1.z.enum([
     'STORAGE_CORRUPTION_DETECTED',
 ]);
 const BlockerPointerSchema = zod_1.z.discriminatedUnion('kind', [
-    zod_1.z.object({ kind: zod_1.z.literal('context_key'), key: zod_1.z.string().min(1) }),
+    zod_1.z.object({ kind: zod_1.z.literal('context_key'), key: zod_1.z.string().min(1).regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'context_key must be delimiter-safe: [a-z0-9_-]+') }),
     zod_1.z.object({ kind: zod_1.z.literal('context_budget') }),
     zod_1.z.object({ kind: zod_1.z.literal('output_contract'), contractRef: zod_1.z.string().min(1) }),
     zod_1.z.object({ kind: zod_1.z.literal('capability'), capability: zod_1.z.enum(['delegation', 'web_browsing']) }),
-    zod_1.z.object({ kind: zod_1.z.literal('workflow_step'), stepId: zod_1.z.string().min(1) }),
+    zod_1.z.object({ kind: zod_1.z.literal('workflow_step'), stepId: zod_1.z.string().min(1).regex(constants_js_1.DELIMITER_SAFE_ID_PATTERN, 'stepId must be delimiter-safe: [a-z0-9_-]+') }),
 ]);
 const BlockerSchema = zod_1.z.object({
     code: BlockerCodeSchema,
     pointer: BlockerPointerSchema,
-    message: zod_1.z.string().min(1),
-    suggestedFix: zod_1.z.string().min(1).optional(),
+    message: zod_1.z
+        .string()
+        .min(1)
+        .refine((s) => utf8ByteLength(s) <= constants_js_1.MAX_BLOCKER_MESSAGE_BYTES, {
+        message: `Blocker message exceeds ${constants_js_1.MAX_BLOCKER_MESSAGE_BYTES} bytes (UTF-8)`,
+    }),
+    suggestedFix: zod_1.z
+        .string()
+        .min(1)
+        .refine((s) => utf8ByteLength(s) <= constants_js_1.MAX_BLOCKER_SUGGESTED_FIX_BYTES, {
+        message: `Blocker suggestedFix exceeds ${constants_js_1.MAX_BLOCKER_SUGGESTED_FIX_BYTES} bytes (UTF-8)`,
+    })
+        .optional(),
 });
 const BlockerReportV1Schema = zod_1.z
     .object({
-    blockers: zod_1.z.array(BlockerSchema).min(1).max(10),
+    blockers: zod_1.z.array(BlockerSchema).min(1).max(constants_js_1.MAX_BLOCKERS),
 })
     .superRefine((v, ctx) => {
     const keyFor = (b) => {
@@ -165,21 +189,19 @@ const AdvanceRecordedDataV1Schema = zod_1.z.object({
     intent: zod_1.z.literal('ack_pending'),
     outcome: AdvanceRecordedOutcomeV1Schema,
 });
-const AutonomySchema = zod_1.z.enum(['guided', 'full_auto_stop_on_user_deps', 'full_auto_never_stop']);
-const RiskPolicySchema = zod_1.z.enum(['conservative', 'balanced', 'aggressive']);
 const PreferencesChangedDataV1Schema = zod_1.z
     .object({
     changeId: zod_1.z.string().min(1),
     source: zod_1.z.enum(['user', 'workflow_recommendation', 'system']),
     delta: zod_1.z
         .array(zod_1.z.discriminatedUnion('key', [
-        zod_1.z.object({ key: zod_1.z.literal('autonomy'), value: AutonomySchema }),
-        zod_1.z.object({ key: zod_1.z.literal('riskPolicy'), value: RiskPolicySchema }),
+        zod_1.z.object({ key: zod_1.z.literal('autonomy'), value: preferences_js_1.AutonomyV2Schema }),
+        zod_1.z.object({ key: zod_1.z.literal('riskPolicy'), value: preferences_js_1.RiskPolicyV2Schema }),
     ]))
         .min(1),
     effective: zod_1.z.object({
-        autonomy: AutonomySchema,
-        riskPolicy: RiskPolicySchema,
+        autonomy: preferences_js_1.AutonomyV2Schema,
+        riskPolicy: preferences_js_1.RiskPolicyV2Schema,
     }),
 })
     .superRefine((v, ctx) => {
@@ -230,7 +252,7 @@ exports.DomainEventV1Schema = zod_1.z.discriminatedUnion('kind', [
         data: zod_1.z.object({
             key: zod_1.z.enum(['git_branch', 'git_head_sha', 'repo_root_hash']),
             value: zod_1.z.discriminatedUnion('type', [
-                zod_1.z.object({ type: zod_1.z.literal('short_string'), value: zod_1.z.string().min(1).max(80) }),
+                zod_1.z.object({ type: zod_1.z.literal('short_string'), value: zod_1.z.string().min(1).max(constants_js_1.MAX_OBSERVATION_SHORT_STRING_LENGTH) }),
                 zod_1.z.object({ type: zod_1.z.literal('git_sha1'), value: zod_1.z.string().regex(/^[0-9a-f]{40}$/) }),
                 zod_1.z.object({ type: zod_1.z.literal('sha256'), value: sha256DigestSchema }),
             ]),
@@ -335,16 +357,21 @@ exports.DomainEventV1Schema = zod_1.z.discriminatedUnion('kind', [
     exports.DomainEventEnvelopeV1Schema.extend({
         kind: zod_1.z.literal('decision_trace_appended'),
         scope: zod_1.z.object({ runId: zod_1.z.string().min(1), nodeId: zod_1.z.string().min(1) }),
-        data: zod_1.z.object({
+        data: zod_1.z
+            .object({
             traceId: zod_1.z.string().min(1),
             entries: zod_1.z
                 .array(zod_1.z.object({
                 kind: zod_1.z.enum(['selected_next_step', 'evaluated_condition', 'entered_loop', 'exited_loop', 'detected_non_tip_advance']),
-                summary: zod_1.z.string().min(1).max(512),
-                refs: zod_1.z.record(zod_1.z.unknown()).optional(),
+                summary: (0, utf8_bounded_string_js_1.utf8BoundedString)({ maxBytes: constants_js_1.MAX_DECISION_TRACE_ENTRY_SUMMARY_BYTES, label: 'decision trace entry summary', minLength: 1 }),
+                refs: decision_trace_ref_js_1.DecisionTraceRefsV1Schema,
             }))
                 .min(1)
-                .max(25),
-        }),
+                .max(constants_js_1.MAX_DECISION_TRACE_ENTRIES),
+        })
+            .refine((data) => {
+            const totalBytes = data.entries.reduce((sum, entry) => sum + utf8ByteLength(entry.summary), 0);
+            return totalBytes <= constants_js_1.MAX_DECISION_TRACE_TOTAL_BYTES;
+        }, { message: `Decision trace total bytes exceeds ${constants_js_1.MAX_DECISION_TRACE_TOTAL_BYTES}` }),
     }),
 ]);

package/dist/v2/durable-core/schemas/session/manifest.d.ts

@@ -6,7 +6,7 @@ export declare const ManifestRecordV1Schema: z.ZodDiscriminatedUnion<"kind", [z.
     kind: z.ZodLiteral<"segment_closed">;
     firstEventIndex: z.ZodNumber;
     lastEventIndex: z.ZodNumber;
-    segmentRelPath: z.ZodString;
+    segmentRelPath: z.ZodEffects<z.ZodEffects<z.ZodString, string, string>, string, string>;
     sha256: z.ZodString;
     bytes: z.ZodNumber;
 }, "strip", z.ZodTypeAny, {

package/dist/v2/durable-core/schemas/session/manifest.js

@@ -6,6 +6,11 @@ const sha256DigestSchema = zod_1.z
     .string()
     .regex(/^sha256:[0-9a-f]{64}$/, 'Expected sha256:<64 hex chars>')
     .describe('sha256 digest in WorkRail v2 format');
+const relativePathSchema = zod_1.z
+    .string()
+    .min(1)
+    .refine((path) => !path.startsWith('/') && !path.startsWith('\\'), 'Path must be relative (no absolute paths)')
+    .refine((path) => !path.includes('../') && !path.includes('..\\'), 'Path must not contain path traversal (..)');
 exports.ManifestRecordV1Schema = zod_1.z.discriminatedUnion('kind', [
     zod_1.z.object({
         v: zod_1.z.literal(1),
@@ -14,7 +19,7 @@ exports.ManifestRecordV1Schema = zod_1.z.discriminatedUnion('kind', [
         kind: zod_1.z.literal('segment_closed'),
         firstEventIndex: zod_1.z.number().int().nonnegative(),
         lastEventIndex: zod_1.z.number().int().nonnegative(),
-        segmentRelPath: zod_1.z.string().min(1),
+        segmentRelPath: relativePathSchema,
         sha256: sha256DigestSchema,
         bytes: zod_1.z.number().int().nonnegative(),
     }),

package/dist/v2/durable-core/schemas/session/preferences.d.ts

@@ -0,0 +1,5 @@
+import { z } from 'zod';
+export type AutonomyV2 = 'guided' | 'full_auto_stop_on_user_deps' | 'full_auto_never_stop';
+export type RiskPolicyV2 = 'conservative' | 'balanced' | 'aggressive';
+export declare const AutonomyV2Schema: z.ZodEnum<["guided", "full_auto_stop_on_user_deps", "full_auto_never_stop"]>;
+export declare const RiskPolicyV2Schema: z.ZodEnum<["conservative", "balanced", "aggressive"]>;