@exaudeus/workrail 3.74.3 → 3.76.0

package/dist/coordinators/pipeline-run-context.js

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PipelineRunContextSchema = exports.ReviewPhaseRecordSchema = exports.CodingPhaseRecordSchema = exports.ShapingPhaseRecordSchema = exports.DiscoveryPhaseRecordSchema = exports.MIN_NOTES_LENGTH_FOR_PHASE_RESULT = void 0;
+exports.buildPhaseResult = buildPhaseResult;
+exports.parsePipelineRunContext = parsePipelineRunContext;
+const zod_1 = require("zod");
+const neverthrow_1 = require("neverthrow");
+const index_js_1 = require("../v2/durable-core/schemas/artifacts/index.js");
+exports.MIN_NOTES_LENGTH_FOR_PHASE_RESULT = 50;
+function buildPhaseResult(artifact, recapMarkdown) {
+    if (artifact !== null) {
+        const maybeConf = artifact.confidenceBand;
+        const confidenceBand = maybeConf === 'high' || maybeConf === 'medium' || maybeConf === 'low'
+            ? maybeConf
+            : null;
+        return { kind: 'full', artifact, confidenceBand, recapMarkdown };
+    }
+    if (recapMarkdown !== null && recapMarkdown.trim().length > exports.MIN_NOTES_LENGTH_FOR_PHASE_RESULT) {
+        return { kind: 'partial', recapMarkdown: recapMarkdown.trim() };
+    }
+    return { kind: 'fallback', recapMarkdown };
+}
+const PhaseResultFullDiscoverySchema = zod_1.z.object({
+    kind: zod_1.z.literal('full'),
+    artifact: index_js_1.DiscoveryHandoffArtifactV1Schema,
+    confidenceBand: zod_1.z.enum(['high', 'medium', 'low']).nullable(),
+    recapMarkdown: zod_1.z.string().nullable(),
+});
+const PhaseResultFullShapingSchema = zod_1.z.object({
+    kind: zod_1.z.literal('full'),
+    artifact: index_js_1.ShapingHandoffArtifactV1Schema,
+    confidenceBand: zod_1.z.enum(['high', 'medium', 'low']).nullable(),
+    recapMarkdown: zod_1.z.string().nullable(),
+});
+const PhaseResultFullCodingSchema = zod_1.z.object({
+    kind: zod_1.z.literal('full'),
+    artifact: index_js_1.CodingHandoffArtifactV1Schema,
+    confidenceBand: zod_1.z.enum(['high', 'medium', 'low']).nullable(),
+    recapMarkdown: zod_1.z.string().nullable(),
+});
+const PhaseResultFullReviewSchema = zod_1.z.object({
+    kind: zod_1.z.literal('full'),
+    artifact: index_js_1.ReviewVerdictArtifactV1Schema,
+    confidenceBand: zod_1.z.enum(['high', 'medium', 'low']).nullable(),
+    recapMarkdown: zod_1.z.string().nullable(),
+});
+const PhaseResultPartialSchema = zod_1.z.object({
+    kind: zod_1.z.literal('partial'),
+    recapMarkdown: zod_1.z.string(),
+});
+const PhaseResultFallbackSchema = zod_1.z.object({
+    kind: zod_1.z.literal('fallback'),
+    recapMarkdown: zod_1.z.string().nullable(),
+});
+exports.DiscoveryPhaseRecordSchema = zod_1.z.object({
+    completedAt: zod_1.z.string(),
+    sessionHandle: zod_1.z.string().min(1),
+    result: zod_1.z.discriminatedUnion('kind', [
+        PhaseResultFullDiscoverySchema,
+        PhaseResultPartialSchema,
+        PhaseResultFallbackSchema,
+    ]),
+});
+exports.ShapingPhaseRecordSchema = zod_1.z.object({
+    completedAt: zod_1.z.string(),
+    sessionHandle: zod_1.z.string().min(1),
+    result: zod_1.z.discriminatedUnion('kind', [
+        PhaseResultFullShapingSchema,
+        PhaseResultPartialSchema,
+        PhaseResultFallbackSchema,
+    ]),
+});
+exports.CodingPhaseRecordSchema = zod_1.z.object({
+    completedAt: zod_1.z.string(),
+    sessionHandle: zod_1.z.string().min(1),
+    result: zod_1.z.discriminatedUnion('kind', [
+        PhaseResultFullCodingSchema,
+        PhaseResultPartialSchema,
+        PhaseResultFallbackSchema,
+    ]),
+});
+exports.ReviewPhaseRecordSchema = zod_1.z.object({
+    completedAt: zod_1.z.string(),
+    sessionHandle: zod_1.z.string().min(1),
+    result: zod_1.z.discriminatedUnion('kind', [
+        PhaseResultFullReviewSchema,
+        PhaseResultPartialSchema,
+        PhaseResultFallbackSchema,
+    ]),
+});
+exports.PipelineRunContextSchema = zod_1.z.object({
+    runId: zod_1.z.string().min(1),
+    goal: zod_1.z.string().min(1),
+    workspace: zod_1.z.string().min(1),
+    startedAt: zod_1.z.string(),
+    pipelineMode: zod_1.z.enum(['FULL', 'IMPLEMENT', 'REVIEW_ONLY', 'QUICK_REVIEW']),
+    status: zod_1.z.enum(['in_progress', 'completed']).optional(),
+    phases: zod_1.z.object({
+        discovery: exports.DiscoveryPhaseRecordSchema.optional(),
+        shaping: exports.ShapingPhaseRecordSchema.optional(),
+        coding: exports.CodingPhaseRecordSchema.optional(),
+        review: exports.ReviewPhaseRecordSchema.optional(),
+    }),
+});
+function parsePipelineRunContext(raw) {
+    const result = exports.PipelineRunContextSchema.safeParse(raw);
+    if (!result.success) {
+        const issues = result.error.issues
+            .map((i) => `${i.path.join('.')}: ${i.message}`)
+            .join('; ');
+        return (0, neverthrow_1.err)(`PipelineRunContext parse failed: ${issues}`);
+    }
+    return (0, neverthrow_1.ok)(result.data);
+}

package/dist/infrastructure/storage/schema-validating-workflow-storage.js

@@ -21,6 +21,29 @@ const VALIDATION_ERROR_PREFIX = '[ValidationError]';
 function reportValidationFailure(workflowId, sourceKind, error) {
     console.error(`${VALIDATION_ERROR_PREFIX} ${sourceKind}/${workflowId}: ${error}`);
 }
+function extractValidationErrors(err) {
+    if (err instanceof error_handler_1.MCPError && typeof err.data?.details === 'string') {
+        try {
+            const ajvErrors = JSON.parse(err.data.details);
+            if (Array.isArray(ajvErrors) && ajvErrors.length > 0) {
+                return ajvErrors.map((e) => {
+                    const location = e.instancePath ? `at '${e.instancePath}'` : 'at root';
+                    const detail = (() => {
+                        if (e.keyword === 'additionalProperties' && e.params && typeof e.params === 'object') {
+                            const prop = e.params.additionalProperty;
+                            return `additional property '${String(prop)}' is not allowed`;
+                        }
+                        return e.message ?? e.keyword ?? 'unknown error';
+                    })();
+                    return `${location}: ${detail}`;
+                });
+            }
+        }
+        catch {
+        }
+    }
+    return [err instanceof Error ? err.message : String(err)];
+}
 class SchemaValidatingWorkflowStorage {
     constructor(inner) {
         this.inner = inner;
@@ -71,7 +94,7 @@ class SchemaValidatingWorkflowStorage {
                     warnings.push({
                         workflowId: workflow.definition.id,
                         sourceKind: workflow.source.kind,
-                        errors: [errorMessage],
+                        errors: extractValidationErrors(err),
                     });
                 }
             }
@@ -158,7 +181,7 @@ class SchemaValidatingCompositeWorkflowStorage {
                     warnings.push({
                         workflowId: workflow.definition.id,
                         sourceKind: workflow.source.kind,
-                        errors: [errorMessage],
+                        errors: extractValidationErrors(err),
                     });
                 }
             }

package/dist/manifest.json

@@ -473,16 +473,16 @@
       "sha256": "5fe866e54f796975dec5d8ba9983aefd86074db212d3fccd64eed04bc9f0b3da",
       "bytes": 8011
     },
-    "console-ui/assets/index-ByqIsoyt.js": {
-      "sha256": "86f5c9d133d4c98fef157087edd26d9a811fd0e68018a797b52a9a44eb501ead",
-      "bytes": 768234
+    "console-ui/assets/index-DFZjlsUM.js": {
+      "sha256": "32444c14f8151326508fdfd00dd46abffc2034064849a411fac1e779da707eca",
+      "bytes": 767524
     },
     "console-ui/assets/index-DHrKiMCf.css": {
       "sha256": "40290b50e21ee7e82433efe13b1aa31c1ea608bd057a5c4e324982f284bc928b",
       "bytes": 60673
     },
     "console-ui/index.html": {
-      "sha256": "9f03a646bde4274beaade4ded2699065b901624e5173627ebd20babed3f2e7e3",
+      "sha256": "1c656cb35c24495d9db4392e51d43d0f07f800e724c1e901df5fd48a43e2418d",
       "bytes": 417
     },
     "console/standalone-console.d.ts": {
@@ -526,36 +526,44 @@
       "bytes": 77
     },
     "coordinators/adaptive-pipeline.d.ts": {
-      "sha256": "8f1e9ee8e14fe847d57ab65d75dab48b08afd376af1fb70c65f760f4a26ff855",
-      "bytes": 2811
+      "sha256": "1ab143720fd019202368715d774a045b55cf953827571570d1396a62d9cacda0",
+      "bytes": 3512
     },
     "coordinators/adaptive-pipeline.js": {
       "sha256": "afac18f8fc5fd75bc5ddd32cb3aaf8e02c22210c4ece001a4dd3c69ac2c10c8a",
       "bytes": 4588
     },
+    "coordinators/context-assembly.d.ts": {
+      "sha256": "ce8e19d9c2902329a96d2447d7d7c6489bafdafc9c8cfdb23423994524640d14",
+      "bytes": 466
+    },
+    "coordinators/context-assembly.js": {
+      "sha256": "6f8f3480b4cd42af02e279d9a67587eb0ce55b32611a94ce8dccf57a6589b71d",
+      "bytes": 7937
+    },
     "coordinators/modes/full-pipeline.d.ts": {
-      "sha256": "94735f14cbacab0c37f4474b636646b7bd6b9e3b2304181f14b3939157ebe3dd",
-      "bytes": 462
+      "sha256": "88230513db280be8b63106fef82a408499ba16a7acfbe5fa69f86af0a0c3ae04",
+      "bytes": 450
     },
     "coordinators/modes/full-pipeline.js": {
-      "sha256": "040b412e33ecb46dcc27c9968c9c0cc5d416880a03dab6f93ed09b8f447c21aa",
-      "bytes": 13161
+      "sha256": "99dc73260d66bb5c9e5c8f477467f5f934aad81b171d0e1cbe661109e939f9e7",
+      "bytes": 20365
     },
     "coordinators/modes/implement-shared.d.ts": {
-      "sha256": "fbad9d91d84d2112b273175618686489a7f106385e0e62d6cab80804d6d0f2d7",
-      "bytes": 708
+      "sha256": "3203d8cb8a51dfe0cf88f3ab29d2dd5e0e60ae3b9c9dcc9f426a8581f55e71ff",
+      "bytes": 918
     },
     "coordinators/modes/implement-shared.js": {
-      "sha256": "96f95d9fca1c511eb1b12247148d0e0de3dd3add5aacd72e2a8bba4b36f5995b",
-      "bytes": 13636
+      "sha256": "ef9385ab3881aafcf677a9a8823b139f1b197436276c448ff67cc3b4500acf98",
+      "bytes": 14254
     },
     "coordinators/modes/implement.d.ts": {
       "sha256": "23919c24d62a0bf15296a52fbc594cca8b1b34e6f8d98dcf7dede8d97ad4cabb",
       "bytes": 347
     },
     "coordinators/modes/implement.js": {
-      "sha256": "59b0dddf00587db1d565c1e460cdad1f75b4ca32687e3649452b0f4de90a3061",
-      "bytes": 5482
+      "sha256": "e779f11315f4e911aa71318271070d7ffc7f2cc243c33669285b6f10b7c0d901",
+      "bytes": 8265
     },
     "coordinators/modes/quick-review.d.ts": {
       "sha256": "03a4f29a07047b0bf788d84f8e0ebab63d64c8eb98aa57087943a8fb84563998",
@@ -573,6 +581,14 @@
       "sha256": "a7da0b06ea4b16ae71b3d08a559dade91b01ffe1270633eb8ac1c355d57126eb",
       "bytes": 1198
     },
+    "coordinators/pipeline-run-context.d.ts": {
+      "sha256": "8fc743a1458e4d7a0971c968d51749d55a3bc114b286efe6b2030eb062809589",
+      "bytes": 68469
+    },
+    "coordinators/pipeline-run-context.js": {
+      "sha256": "5489319764a0dbd1b037521e014784fab518c4ff4f9137e045129e6845793e55",
+      "bytes": 4790
+    },
     "coordinators/pr-review.d.ts": {
       "sha256": "0dba830dd29cd82c58300ca9fdfb4c29d0acd0b257740ce3e65f2360239a106b",
       "bytes": 4501
@@ -1026,8 +1042,8 @@
       "bytes": 2023
     },
     "infrastructure/storage/schema-validating-workflow-storage.js": {
-      "sha256": "4004fac4f8cb1b5cadbe060a389fe6a97377eedc6d4209b92da0d82d36a5e1b0",
-      "bytes": 7801
+      "sha256": "06a8dd9b05f3186dc305d39436b49c6c13e08b30b1fa9ae1f3d6161789c3b993",
+      "bytes": 8878
     },
     "infrastructure/storage/storage.d.ts": {
       "sha256": "481c5c0ef797baa7f18cff6a468a1de6d1ef34dd4b35f53e318e30b825b31e63",
@@ -1794,8 +1810,8 @@
       "bytes": 854
     },
     "trigger/coordinator-deps.js": {
-      "sha256": "1b400abbd6158e900d4559c74b9f3069a46b60fd02d046f36e30cc40a58acb51",
-      "bytes": 22626
+      "sha256": "ceff71f1fd76b8ce7c490eee80fb2c13496d53adc321b85be525784eeafe930a",
+      "bytes": 29393
     },
     "trigger/delivery-action.d.ts": {
       "sha256": "bba98a08e35653304b604cd3ec126374cb731620db27ee2c8d6782d5b5b31207",
@@ -2058,8 +2074,8 @@
       "bytes": 1343
     },
     "v2/durable-core/domain/artifact-contract-validator.js": {
-      "sha256": "d7ad3b9c3c3bbb54616682640be23bb04b6256bb96f8fad5daf56cc0df43ec36",
-      "bytes": 6500
+      "sha256": "f3b3e7505a820ab3870b19994d9a4d8e61d9051452a28d86feef737d24c144a3",
+      "bytes": 10619
     },
     "v2/durable-core/domain/assessment-consequence-event-builder.d.ts": {
       "sha256": "be91245e615888ae4675c093a9f323500099dbe6d1250ced4726764e1029e9ad",
@@ -2414,20 +2430,20 @@
       "bytes": 1242
     },
     "v2/durable-core/schemas/artifacts/discovery-handoff.d.ts": {
-      "sha256": "ccf5b234bc4e1d98a688ecdf555cb8a0cc4e171209f31845d13ac89ef747bbe9",
-      "bytes": 1174
+      "sha256": "36b933327a0aed2b767834c4567c7bc51209f9f39e844f3a2503ddccc70ec93e",
+      "bytes": 2323
     },
     "v2/durable-core/schemas/artifacts/discovery-handoff.js": {
-      "sha256": "78b5ce8abef29a1f15d8e10f33a9174f8d027550ffdfc419ddad03db8d0fc7d6",
-      "bytes": 1138
+      "sha256": "2c8e2f51df1691a34e64bfb4ecfbfd8b4447ca961824612c366f9a30092bfe9b",
+      "bytes": 1624
     },
     "v2/durable-core/schemas/artifacts/index.d.ts": {
-      "sha256": "7821aa8564f8900b81396497e26ad3718805c64daf02147f1427d35dfe6c957d",
-      "bytes": 1557
+      "sha256": "016e3d46d2eac61e12caf851f8b9d46512b2a3a186bbab7d672127f7f48eb168",
+      "bytes": 1976
     },
     "v2/durable-core/schemas/artifacts/index.js": {
-      "sha256": "6755939280959c6a8ad70a5141a0a8803ad136eb1064f6238bb08e294c2330d0",
-      "bytes": 5772
+      "sha256": "55392c70481c4a89aebf42ad7b1becb17e128d575b3bd832f7fd8f2b85ae89b9",
+      "bytes": 7493
     },
     "v2/durable-core/schemas/artifacts/loop-control.d.ts": {
       "sha256": "95dabfdcedb1a71c58c38a805dcf24c76254783bc0b2c7d429a3b8ffb94202ed",
@@ -2437,6 +2453,14 @@
       "sha256": "c4b2ed38f9fdda3fbe3e4b68b0a228890fd9a7c73117a6d202928acabe6fc0f9",
       "bytes": 2115
     },
+    "v2/durable-core/schemas/artifacts/phase-handoff.d.ts": {
+      "sha256": "e56371b1e7e5ca83c2867c04d9e1c4b9f24ca654905c5c24d2577acc48a005c4",
+      "bytes": 3228
+    },
+    "v2/durable-core/schemas/artifacts/phase-handoff.js": {
+      "sha256": "05e038285bcd4a140a22b71e7bf1a53ee123de8f23b021b4e9cb9164e266b02a",
+      "bytes": 2651
+    },
     "v2/durable-core/schemas/artifacts/review-verdict.d.ts": {
       "sha256": "2b9f7ae6b3fafe6c26f266bb249c8c286144eb1f753c803d4358ef81e30d1736",
       "bytes": 2211

package/dist/trigger/coordinator-deps.js

@@ -38,10 +38,12 @@ const fs = __importStar(require("node:fs"));
 const os = __importStar(require("node:os"));
 const path = __importStar(require("node:path"));
 const node_crypto_1 = require("node:crypto");
+const neverthrow_1 = require("neverthrow");
 const start_js_1 = require("../mcp/handlers/v2-execution/start.js");
 const v2_token_ops_js_1 = require("../mcp/handlers/v2-token-ops.js");
 const index_js_1 = require("../context-assembly/index.js");
 const infra_js_1 = require("../context-assembly/infra.js");
+const pipeline_run_context_js_1 = require("../coordinators/pipeline-run-context.js");
 function createCoordinatorDeps(deps) {
     const { ctx, execFileAsync, consoleService } = deps;
     let dispatch = null;
@@ -485,5 +487,134 @@ function createCoordinatorDeps(deps) {
             }
             return 'timeout';
         },
+        generateRunId: () => (0, node_crypto_1.randomUUID)(),
+        readActiveRunId: async (workspace) => {
+            const runsDir = path.join(workspace, '.workrail', 'pipeline-runs');
+            try {
+                const entries = await fs.promises.readdir(runsDir);
+                const candidates = [];
+                for (const entry of entries) {
+                    if (!entry.endsWith('-context.json'))
+                        continue;
+                    try {
+                        const raw = await fs.promises.readFile(path.join(runsDir, entry), 'utf-8');
+                        const ctx = JSON.parse(raw);
+                        if (typeof ctx !== 'object' || ctx === null)
+                            continue;
+                        const c = ctx;
+                        if (typeof c['runId'] !== 'string')
+                            continue;
+                        if (c['status'] === 'completed')
+                            continue;
+                        candidates.push({ runId: c['runId'], startedAt: String(c['startedAt'] ?? '') });
+                    }
+                    catch {
+                        continue;
+                    }
+                }
+                if (candidates.length === 0)
+                    return (0, neverthrow_1.ok)(null);
+                candidates.sort((a, b) => b.startedAt.localeCompare(a.startedAt));
+                if (candidates.length > 1) {
+                    process.stderr.write(`[WARN coordinator] ${candidates.length} in-progress pipeline runs found -- resuming newest (${candidates[0].runId}). ` +
+                        `Others: ${candidates.slice(1).map(c => c.runId).join(', ')}. Run 'worktrain cleanup' to clear stale runs.\n`);
+                }
+                return (0, neverthrow_1.ok)(candidates[0].runId);
+            }
+            catch (e) {
+                if (e.code === 'ENOENT')
+                    return (0, neverthrow_1.ok)(null);
+                const msg = e instanceof Error ? e.message : String(e);
+                process.stderr.write(`[WARN coordinator] readActiveRunId failed -- crash recovery skipped: ${msg}\n`);
+                return (0, neverthrow_1.err)(`readActiveRunId failed: ${msg}`);
+            }
+        },
+        markPipelineRunComplete: async (workspace, runId) => {
+            const runsDir = path.join(workspace, '.workrail', 'pipeline-runs');
+            const filePath = path.join(runsDir, `${runId}-context.json`);
+            const tmpPath = filePath + '.tmp';
+            try {
+                const raw = await fs.promises.readFile(filePath, 'utf-8');
+                const existing = JSON.parse(raw);
+                const updated = { ...existing, status: 'completed' };
+                await fs.promises.writeFile(tmpPath, JSON.stringify(updated, null, 2) + '\n', 'utf-8');
+                await fs.promises.rename(tmpPath, filePath);
+                return (0, neverthrow_1.ok)(undefined);
+            }
+            catch (e) {
+                try {
+                    await fs.promises.unlink(tmpPath);
+                }
+                catch { }
+                return (0, neverthrow_1.err)(`markPipelineRunComplete failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        },
+        readPipelineContext: async (workspace, runId) => {
+            const runsDir = path.join(workspace, '.workrail', 'pipeline-runs');
+            const filePath = path.join(runsDir, `${runId}-context.json`);
+            try {
+                const raw = await fs.promises.readFile(filePath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                return (0, pipeline_run_context_js_1.parsePipelineRunContext)(parsed);
+            }
+            catch (e) {
+                if (e.code === 'ENOENT') {
+                    return (0, neverthrow_1.ok)(null);
+                }
+                const msg = e instanceof Error ? e.message : String(e);
+                return (0, neverthrow_1.err)(`readPipelineContext failed: ${msg}`);
+            }
+        },
+        createPipelineContext: async (workspace, runId, goal, pipelineMode) => {
+            const runsDir = path.join(workspace, '.workrail', 'pipeline-runs');
+            const filePath = path.join(runsDir, `${runId}-context.json`);
+            const tmpPath = filePath + '.tmp';
+            try {
+                await fs.promises.mkdir(runsDir, { recursive: true });
+                const initial = { runId, goal, workspace, startedAt: new Date().toISOString(), pipelineMode, phases: {} };
+                await fs.promises.writeFile(tmpPath, JSON.stringify(initial, null, 2) + '\n', 'utf-8');
+                await fs.promises.rename(tmpPath, filePath);
+                return (0, neverthrow_1.ok)(undefined);
+            }
+            catch (e) {
+                try {
+                    await fs.promises.unlink(tmpPath);
+                }
+                catch { }
+                return (0, neverthrow_1.err)(`createPipelineContext failed: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        },
+        writePhaseRecord: async (workspace, runId, entry) => {
+            const runsDir = path.join(workspace, '.workrail', 'pipeline-runs');
+            const filePath = path.join(runsDir, `${runId}-context.json`);
+            const tmpPath = filePath + '.tmp';
+            try {
+                await fs.promises.mkdir(runsDir, { recursive: true });
+                const raw = await fs.promises.readFile(filePath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                const existing = (0, pipeline_run_context_js_1.parsePipelineRunContext)(parsed);
+                if (existing.isErr() || existing.value === null) {
+                    return (0, neverthrow_1.err)(`writePhaseRecord: context file missing or invalid for runId=${runId}`);
+                }
+                const updated = {
+                    ...existing.value,
+                    phases: {
+                        ...existing.value.phases,
+                        [entry.phase]: entry.record,
+                    },
+                };
+                await fs.promises.writeFile(tmpPath, JSON.stringify(updated, null, 2) + '\n', 'utf-8');
+                await fs.promises.rename(tmpPath, filePath);
+                return (0, neverthrow_1.ok)(undefined);
+            }
+            catch (e) {
+                const msg = e instanceof Error ? e.message : String(e);
+                try {
+                    await fs.promises.unlink(tmpPath);
+                }
+                catch { }
+                return (0, neverthrow_1.err)(`writePhaseRecord failed: ${msg}`);
+            }
+        },
     };
 }

package/dist/v2/durable-core/domain/artifact-contract-validator.js

@@ -25,6 +25,12 @@ function validateArtifactContract(artifacts, contract) {
             return validateCoordinatorSignalContract(artifacts, contractRef, required);
         case index_js_1.REVIEW_VERDICT_CONTRACT_REF:
             return validateReviewVerdictContract(artifacts, contractRef, required);
+        case index_js_1.DISCOVERY_HANDOFF_CONTRACT_REF:
+            return validateDiscoveryHandoffContract(artifacts, contractRef, required);
+        case index_js_1.SHAPING_HANDOFF_CONTRACT_REF:
+            return validateShapingHandoffContract(artifacts, contractRef, required);
+        case index_js_1.CODING_HANDOFF_CONTRACT_REF:
+            return validateCodingHandoffContract(artifacts, contractRef, required);
         default:
             return {
                 valid: false,
@@ -129,6 +135,99 @@ function validateReviewVerdictContract(artifacts, contractRef, required) {
     }
     return { valid: true, artifact: parseResult.data };
 }
+function validateDiscoveryHandoffContract(artifacts, contractRef, required) {
+    const handoffArtifacts = artifacts.filter(index_js_1.isDiscoveryHandoffArtifact);
+    if (handoffArtifacts.length === 0) {
+        if (required) {
+            return {
+                valid: false,
+                error: {
+                    code: 'MISSING_REQUIRED_ARTIFACT',
+                    contractRef,
+                    message: `Required artifact missing: ${contractRef}. Agent must provide an artifact with kind='wr.discovery_handoff'.`,
+                },
+            };
+        }
+        return { valid: true, artifact: null };
+    }
+    const artifact = handoffArtifacts[0];
+    const parseResult = index_js_1.DiscoveryHandoffArtifactV1Schema.safeParse(artifact);
+    if (!parseResult.success) {
+        const issues = parseResult.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`);
+        return {
+            valid: false,
+            error: {
+                code: 'INVALID_ARTIFACT_SCHEMA',
+                contractRef,
+                message: `Artifact schema validation failed for ${contractRef}`,
+                issues,
+            },
+        };
+    }
+    return { valid: true, artifact: parseResult.data };
+}
+function validateShapingHandoffContract(artifacts, contractRef, required) {
+    const handoffArtifacts = artifacts.filter(index_js_1.isShapingHandoffArtifact);
+    if (handoffArtifacts.length === 0) {
+        if (required) {
+            return {
+                valid: false,
+                error: {
+                    code: 'MISSING_REQUIRED_ARTIFACT',
+                    contractRef,
+                    message: `Required artifact missing: ${contractRef}. Agent must provide an artifact with kind='wr.shaping_handoff'.`,
+                },
+            };
+        }
+        return { valid: true, artifact: null };
+    }
+    const artifact = handoffArtifacts[0];
+    const parseResult = index_js_1.ShapingHandoffArtifactV1Schema.safeParse(artifact);
+    if (!parseResult.success) {
+        const issues = parseResult.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`);
+        return {
+            valid: false,
+            error: {
+                code: 'INVALID_ARTIFACT_SCHEMA',
+                contractRef,
+                message: `Artifact schema validation failed for ${contractRef}`,
+                issues,
+            },
+        };
+    }
+    return { valid: true, artifact: parseResult.data };
+}
+function validateCodingHandoffContract(artifacts, contractRef, required) {
+    const handoffArtifacts = artifacts.filter(index_js_1.isCodingHandoffArtifact);
+    if (handoffArtifacts.length === 0) {
+        if (required) {
+            return {
+                valid: false,
+                error: {
+                    code: 'MISSING_REQUIRED_ARTIFACT',
+                    contractRef,
+                    message: `Required artifact missing: ${contractRef}. Agent must provide an artifact with kind='wr.coding_handoff'.`,
+                },
+            };
+        }
+        return { valid: true, artifact: null };
+    }
+    const artifact = handoffArtifacts[0];
+    const parseResult = index_js_1.CodingHandoffArtifactV1Schema.safeParse(artifact);
+    if (!parseResult.success) {
+        const issues = parseResult.error.issues.map((issue) => `${issue.path.join('.')}: ${issue.message}`);
+        return {
+            valid: false,
+            error: {
+                code: 'INVALID_ARTIFACT_SCHEMA',
+                contractRef,
+                message: `Artifact schema validation failed for ${contractRef}`,
+                issues,
+            },
+        };
+    }
+    return { valid: true, artifact: parseResult.data };
+}
 function requiresArtifactValidation(outputContract) {
     if (!outputContract)
         return false;

package/dist/v2/durable-core/schemas/artifacts/discovery-handoff.d.ts

@@ -7,6 +7,27 @@ export declare const DiscoveryHandoffArtifactV1Schema: z.ZodObject<{
     designDocPath: z.ZodString;
     confidenceBand: z.ZodEnum<["high", "medium", "low"]>;
     keyInvariants: z.ZodArray<z.ZodString, "many">;
+    rejectedDirections: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        direction: z.ZodString;
+        reason: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        reason: string;
+        direction: string;
+    }, {
+        reason: string;
+        direction: string;
+    }>, "many">>;
+    implementationConstraints: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
+    keyCodebaseLocations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        relevance: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        path: string;
+        relevance: string;
+    }, {
+        path: string;
+        relevance: string;
+    }>, "many">>;
 }, "strict", z.ZodTypeAny, {
     kind: "wr.discovery_handoff";
     version: 1;
@@ -14,6 +35,15 @@ export declare const DiscoveryHandoffArtifactV1Schema: z.ZodObject<{
     designDocPath: string;
     confidenceBand: "low" | "high" | "medium";
     keyInvariants: string[];
+    rejectedDirections?: {
+        reason: string;
+        direction: string;
+    }[] | undefined;
+    implementationConstraints?: string[] | undefined;
+    keyCodebaseLocations?: {
+        path: string;
+        relevance: string;
+    }[] | undefined;
 }, {
     kind: "wr.discovery_handoff";
     version: 1;
@@ -21,6 +51,15 @@ export declare const DiscoveryHandoffArtifactV1Schema: z.ZodObject<{
     designDocPath: string;
     confidenceBand: "low" | "high" | "medium";
     keyInvariants: string[];
+    rejectedDirections?: {
+        reason: string;
+        direction: string;
+    }[] | undefined;
+    implementationConstraints?: string[] | undefined;
+    keyCodebaseLocations?: {
+        path: string;
+        relevance: string;
+    }[] | undefined;
 }>;
 export type DiscoveryHandoffArtifactV1 = z.infer<typeof DiscoveryHandoffArtifactV1Schema>;
 export declare function isDiscoveryHandoffArtifact(artifact: unknown): artifact is {

package/dist/v2/durable-core/schemas/artifacts/discovery-handoff.js

@@ -12,7 +12,16 @@ exports.DiscoveryHandoffArtifactV1Schema = zod_1.z
     selectedDirection: zod_1.z.string().min(1),
     designDocPath: zod_1.z.string(),
     confidenceBand: zod_1.z.enum(['high', 'medium', 'low']),
-    keyInvariants: zod_1.z.array(zod_1.z.string().min(1)),
+    keyInvariants: zod_1.z.array(zod_1.z.string().min(1).max(200)).max(12),
+    rejectedDirections: zod_1.z.array(zod_1.z.object({
+        direction: zod_1.z.string().min(1).max(200),
+        reason: zod_1.z.string().min(1).max(300),
+    })).max(5).optional(),
+    implementationConstraints: zod_1.z.array(zod_1.z.string().min(1).max(200)).max(8).optional(),
+    keyCodebaseLocations: zod_1.z.array(zod_1.z.object({
+        path: zod_1.z.string().min(1).max(300),
+        relevance: zod_1.z.string().min(1).max(150),
+    })).max(10).optional(),
 })
     .strict();
 function isDiscoveryHandoffArtifact(artifact) {