onto-mcp 0.3.0 → 0.3.2

package/dist/core-runtime/cli/run-review-prompt-execution.js

@@ -14,6 +14,7 @@ import { REVIEW_EXECUTION_STEP_IDS, REVIEW_PROGRESS_TOTAL_STEPS, } from "../revi
 import { printOntoReleaseChannelNotice } from "../release-channel/release-channel.js";
 import { executeReviewViaCodexNested } from "./codex-nested-dispatch.js";
 import { ReviewStructuredFailureError, writeAndThrowStructuredFailureRecord, } from "../review/failure-records.js";
+import { assertReviewExecutionPlanSessionBoundary, } from "../review/execution-plan-boundary.js";
 function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
@@ -143,6 +144,7 @@ const DEFAULT_LENS_MAX_RETRIES = 10;
 /** Base delay for bounded linear retries. Synthesize reuses the base delay. */
 const DEFAULT_LENS_RETRY_INITIAL_DELAY_MS = 8000;
 const DEFAULT_REVIEW_UNIT_TIMEOUT_MS = 600_000;
+const REVIEW_CANCEL_REQUEST_FILENAME = "review-cancel-request.yaml";
 class ReviewUnitTimeoutError extends Error {
     timeoutMs;
     constructor(unitId, timeoutMs) {
@@ -215,6 +217,12 @@ function haltArtifactFields(haltPhase, outcome) {
 function sleep(ms) {
     return new Promise((resolve) => setTimeout(resolve, ms));
 }
+async function readReviewCancelRequest(sessionRoot) {
+    const cancelPath = path.join(sessionRoot, REVIEW_CANCEL_REQUEST_FILENAME);
+    if (!(await fileExists(cancelPath)))
+        return null;
+    return readYamlDocument(cancelPath);
+}
 async function ensureNonEmptyOutputFile(outputPath) {
     if (!(await fileExists(outputPath))) {
         throw new Error(`Executor did not create output file: ${outputPath}`);
@@ -308,9 +316,14 @@ async function invokeExecutor(executorConfig, projectRoot, sessionRoot, dispatch
             ? combinedMessage
             : `Executor exited with code ${exitCode} for ${dispatch.unit_id}`);
     }
+    if (stderr.trim().length > 0) {
+        console.warn(`[review runner warning] ${dispatch.unit_id}: ${stderr.trim()}`);
+    }
     await ensureNonEmptyOutputFile(dispatch.output_path);
 }
 function toUnitExecutionResult(outcome) {
+    if (outcome.preservedResult)
+        return outcome.preservedResult;
     return {
         unit_id: outcome.dispatch.unit_id,
         unit_kind: outcome.dispatch.unit_kind,
@@ -326,6 +339,45 @@ function toUnitExecutionResult(outcome) {
         failure_message: outcome.failure?.message ?? null,
     };
 }
+function allUnitExecutionResults(artifact) {
+    if (!artifact)
+        return [];
+    return [
+        ...artifact.lens_execution_results,
+        ...(artifact.issue_artifact_execution_results ?? []),
+        ...(artifact.deliberation_execution_results ?? []),
+        ...(artifact.synthesize_execution_result
+            ? [artifact.synthesize_execution_result]
+            : []),
+    ];
+}
+function outcomeFromPreviousResult(result) {
+    const startedAtMs = Date.parse(result.started_at);
+    const completedAtMs = Date.parse(result.completed_at);
+    return {
+        dispatch: {
+            unit_id: result.unit_id,
+            unit_kind: result.unit_kind,
+            packet_path: result.packet_path,
+            output_path: result.output_path,
+        },
+        success: result.status === "completed",
+        startedAtMs: Number.isFinite(startedAtMs) ? startedAtMs : Date.now(),
+        completedAtMs: Number.isFinite(completedAtMs) ? completedAtMs : Date.now(),
+        ...(result.status === "failed"
+            ? {
+                failure: {
+                    unit_id: result.unit_id,
+                    unit_kind: result.unit_kind,
+                    packet_path: result.packet_path,
+                    output_path: result.output_path,
+                    message: result.failure_message ?? "Previous unit failed.",
+                },
+            }
+            : {}),
+        preservedResult: result,
+    };
+}
 function deriveExecutionStatus(params) {
     if (!params.synthesisExecuted) {
         return "halted_partial";
@@ -959,7 +1011,7 @@ async function writeReviewRunManifest(executionPlan, artifact, reviewExecutionPr
                     synthesize: reviewExecutionProfile.synthesize,
                     deliberation: reviewExecutionProfile.deliberation,
                     runtime_route: {
-                        execution_realization: executionPlan.execution_realization,
+                        execution_realization: route.execution_realization,
                         host_runtime: route.artifact_host_runtime,
                         worker_executor: route.executor,
                         runtime_provider: route.resolved_provider,
@@ -1149,6 +1201,22 @@ function issueArtifactProgress(artifactId) {
     const spec = issueArtifactSpec(artifactId);
     return { step: spec.progress_step, label: spec.progress_label };
 }
+function issueArtifactOutputPath(executionPlan, artifactId) {
+    switch (artifactId) {
+        case "finding-ledger":
+            return executionPlan.finding_ledger_path;
+        case "finding-relation-graph":
+            return executionPlan.finding_relation_graph_path;
+        case "issue-ledger":
+            return executionPlan.issue_ledger_path;
+        case "issue-stance-matrix":
+            return executionPlan.issue_stance_matrix_path;
+        case "deliberation-plan":
+            return executionPlan.deliberation_plan_path;
+        case "problem-framing":
+            return executionPlan.problem_framing_path;
+    }
+}
 async function runIssueArtifactDispatch(args) {
     const seat = await writeIssueArtifactPromptPacket({
         artifactId: args.artifactId,
@@ -1289,7 +1357,17 @@ async function runControlledLensDeliberation(args) {
         label: "lens deliberation responses",
         details: [`participating_lens_count=${deliberationDispatches.length}`],
     });
+    const shouldRunUnit = (unitId) => args.runUnitIds === undefined || args.runUnitIds.has(unitId);
+    const preservedOutcomeForDispatch = (dispatch) => {
+        const result = args.preservedResultsByUnitId?.get(dispatch.unit_id);
+        if (!result || result.status !== "completed") {
+            throw new Error(`Cannot preserve continuation unit without a completed prior result: ${dispatch.unit_id}`);
+        }
+        return outcomeFromPreviousResult(result);
+    };
     for (const dispatch of deliberationDispatches) {
+        if (!shouldRunUnit(dispatch.unit_id))
+            continue;
         const lensId = dispatch.unit_id.replace(/^deliberation-/, "");
         const ownOutput = lensOutputById.get(lensId);
         if (!ownOutput) {
@@ -1323,6 +1401,10 @@ async function runControlledLensDeliberation(args) {
             const dispatch = deliberationDispatches[currentIndex];
             if (!dispatch)
                 return;
+            if (!shouldRunUnit(dispatch.unit_id)) {
+                deliberationOutcomes[currentIndex] = preservedOutcomeForDispatch(dispatch);
+                continue;
+            }
             deliberationOutcomes[currentIndex] = await runSingleDispatchWithRetries({
                 projectRoot,
                 sessionRoot,
@@ -1349,41 +1431,47 @@ async function runControlledLensDeliberation(args) {
             content: await fs.readFile(dispatch.output_path, "utf8"),
         };
     }));
-    const teamleadPacketText = buildTeamleadControlledDeliberationPrompt({
-        session_id: executionPlan.session_id,
-        output_path: executionPlan.deliberation_output_path,
-        lens_outputs: lensOutputs,
-        lens_deliberation_responses: lensDeliberationResponses,
-        ...(issueArtifactContext ? { issue_artifact_context: issueArtifactContext } : {}),
-    });
-    await fs.writeFile(executionPlan.teamlead_deliberation_prompt_packet_path, `${teamleadPacketText.trimEnd()}\n`, "utf8");
-    await registerGeneratedPromptPacketRefForDispatch({
-        executionPlan,
-        consumerId: "controlled-deliberation",
-        packetPath: executionPlan.teamlead_deliberation_prompt_packet_path,
-    });
     const teamleadDispatch = {
         unit_id: "controlled-deliberation",
         unit_kind: "deliberation",
         packet_path: executionPlan.teamlead_deliberation_prompt_packet_path,
         output_path: executionPlan.deliberation_output_path,
     };
-    await emitReviewProgress({
-        executionPlan,
-        step: 10,
-        label: "teamlead controlled deliberation",
-        details: [`output_path=${executionPlan.deliberation_output_path}`],
-    });
-    const teamleadOutcome = await runSingleDispatchWithRetries({
-        projectRoot,
-        sessionRoot,
-        executionPlan,
-        executorConfig: teamleadExecutorConfig,
-        dispatch: teamleadDispatch,
-        maxRetries: 1,
-        retryInitialDelayMs: DEFAULT_LENS_RETRY_INITIAL_DELAY_MS,
-        unitTimeoutMs,
-    });
+    let teamleadOutcome;
+    if (shouldRunUnit(teamleadDispatch.unit_id)) {
+        const teamleadPacketText = buildTeamleadControlledDeliberationPrompt({
+            session_id: executionPlan.session_id,
+            output_path: executionPlan.deliberation_output_path,
+            lens_outputs: lensOutputs,
+            lens_deliberation_responses: lensDeliberationResponses,
+            ...(issueArtifactContext ? { issue_artifact_context: issueArtifactContext } : {}),
+        });
+        await fs.writeFile(executionPlan.teamlead_deliberation_prompt_packet_path, `${teamleadPacketText.trimEnd()}\n`, "utf8");
+        await registerGeneratedPromptPacketRefForDispatch({
+            executionPlan,
+            consumerId: "controlled-deliberation",
+            packetPath: executionPlan.teamlead_deliberation_prompt_packet_path,
+        });
+        await emitReviewProgress({
+            executionPlan,
+            step: 10,
+            label: "teamlead controlled deliberation",
+            details: [`output_path=${executionPlan.deliberation_output_path}`],
+        });
+        teamleadOutcome = await runSingleDispatchWithRetries({
+            projectRoot,
+            sessionRoot,
+            executionPlan,
+            executorConfig: teamleadExecutorConfig,
+            dispatch: teamleadDispatch,
+            maxRetries: 1,
+            retryInitialDelayMs: DEFAULT_LENS_RETRY_INITIAL_DELAY_MS,
+            unitTimeoutMs,
+        });
+    }
+    else {
+        teamleadOutcome = preservedOutcomeForDispatch(teamleadDispatch);
+    }
     if (!teamleadOutcome.success) {
         throw new ReviewControlledDeliberationDispatchError(`Teamlead controlled deliberation failed: ${teamleadOutcome.failure?.message ?? "unknown error"}`, [...completedDeliberationOutcomes, teamleadOutcome], teamleadOutcome);
     }
@@ -1402,9 +1490,42 @@ export async function executeReviewPromptExecution(params) {
     const sessionRoot = path.resolve(params.sessionRoot);
     const executionPlanPath = path.join(sessionRoot, "execution-plan.yaml");
     const executionPlan = await readYamlDocument(executionPlanPath);
+    await assertReviewExecutionPlanSessionBoundary({ sessionRoot, executionPlan });
     const executionStartedAtMs = Date.now();
-    await resetExecutionOutputs(executionPlan);
-    await pruneGeneratedPromptPacketRefs(executionPlan);
+    const continuationPlan = params.continuationPlan;
+    const continuationMode = continuationPlan !== undefined;
+    const continuationRunUnitIds = new Set([
+        ...(continuationPlan?.frontierUnits ?? []),
+        ...(continuationPlan?.downstreamUnits ?? []),
+    ]
+        .filter((unit) => unit.dispatchDecision === "run")
+        .map((unit) => unit.unitId));
+    const previousExecutionResult = continuationMode && await fileExists(executionPlan.execution_result_path)
+        ? await readYamlDocument(executionPlan.execution_result_path)
+        : null;
+    const previousResultsByUnitId = new Map(allUnitExecutionResults(previousExecutionResult).map((result) => [
+        result.unit_id,
+        result,
+    ]));
+    const shouldRunUnit = (unitId) => !continuationMode || continuationRunUnitIds.has(unitId);
+    const preservedOutcomeForDispatch = (dispatch) => {
+        const result = previousResultsByUnitId.get(dispatch.unit_id);
+        if (!result || result.status !== "completed") {
+            throw new Error(`Cannot preserve continuation unit without a completed prior result: ${dispatch.unit_id}`);
+        }
+        return outcomeFromPreviousResult(result);
+    };
+    if (continuationMode) {
+        await appendMarkdownLogEntry(executionPlan.error_log_path, "runner continuation mode", [
+            `frontier_units: ${continuationPlan.frontierUnits.map((unit) => unit.unitId).join(", ")}`,
+            `downstream_units: ${continuationPlan.downstreamUnits.map((unit) => unit.unitId).join(", ")}`,
+            `preserved_artifact_count: ${continuationPlan.preservedArtifactRefs.length}`,
+        ].join("\n"));
+    }
+    else {
+        await resetExecutionOutputs(executionPlan);
+        await pruneGeneratedPromptPacketRefs(executionPlan);
+    }
     await ensureReviewContextManifestReadyForDispatch(executionPlan);
     await emitReviewProgress({
         executionPlan,
@@ -1453,6 +1574,77 @@ export async function executeReviewPromptExecution(params) {
     }
     const executionOutcomes = new Array(lensDispatches.length);
     let nextLensIndex = 0;
+    async function haltForCancellation(args) {
+        const completedLensOutcomes = executionOutcomes.filter(isSuccessfulOutcome);
+        const successfulLensDispatches = completedLensOutcomes.map((outcome) => outcome.dispatch);
+        const executionFailures = executionOutcomes
+            .filter(isFailureOutcome)
+            .map((outcome) => outcome.failure);
+        const degradedLensIds = executionFailures
+            .filter((failure) => failure.unit_kind === "lens")
+            .map((failure) => failure.unit_id);
+        const haltReason = `Review cancelled by MCP request: ${args.cancelRequest.reason}`;
+        await appendMarkdownLogEntry(executionPlan.error_log_path, "runner cancelled", [
+            haltReason,
+            `requested_at: ${args.cancelRequest.requested_at}`,
+            `phase: ${args.phase}`,
+        ].join("\n"));
+        const executionCompletedAtMs = Date.now();
+        await writeExecutionResultArtifact(executionPlan, {
+            session_id: executionPlan.session_id,
+            session_root: sessionRoot,
+            execution_realization: executionPlan.execution_realization,
+            host_runtime: executionPlan.host_runtime,
+            review_mode: executionPlan.review_mode,
+            execution_status: "halted_partial",
+            execution_started_at: isoFromTimestamp(executionStartedAtMs),
+            execution_completed_at: isoFromTimestamp(executionCompletedAtMs),
+            total_duration_ms: Math.max(0, executionCompletedAtMs - executionStartedAtMs),
+            max_concurrent_lenses: maxConcurrentLenses,
+            observed_dispatch_width: observedDispatchWidth,
+            planned_lens_ids: lensDispatches.map((dispatch) => dispatch.unit_id),
+            participating_lens_ids: successfulLensDispatches.map((dispatch) => dispatch.unit_id),
+            degraded_lens_ids: degradedLensIds,
+            excluded_lens_ids: lensDispatches
+                .map((dispatch) => dispatch.unit_id)
+                .filter((lensId) => !successfulLensDispatches.some((dispatch) => dispatch.unit_id === lensId) &&
+                !degradedLensIds.includes(lensId)),
+            executed_lens_count: successfulLensDispatches.length,
+            synthesis_executed: false,
+            deliberation_status: args.deliberationStatus ?? "not_performed",
+            halt_reason: haltReason,
+            ...haltArtifactFields("cancellation", null),
+            error_log_path: executionPlan.error_log_path,
+            lens_completion_barrier_ref: executionPlan.lens_completion_barrier_path ??
+                path.join(sessionRoot, "lens-completion-barrier.yaml"),
+            lens_execution_results: executionOutcomes
+                .filter((outcome) => outcome !== undefined)
+                .map(toUnitExecutionResult),
+            issue_artifact_execution_results: args.issueArtifactOutcomes?.map(toUnitExecutionResult) ?? [],
+            deliberation_execution_results: args.deliberationExecutionResults?.map(toUnitExecutionResult) ?? [],
+            synthesize_execution_result: args.synthesizeOutcome
+                ? toUnitExecutionResult(args.synthesizeOutcome)
+                : null,
+        }, params.reviewExecutionProfile);
+        return {
+            session_root: sessionRoot,
+            executed_lens_count: successfulLensDispatches.length,
+            synthesis_output_path: executionPlan.synthesis_output_path,
+            participating_lens_ids: successfulLensDispatches.map((dispatch) => dispatch.unit_id),
+            degraded_lens_ids: degradedLensIds,
+            synthesis_executed: false,
+            error_log_path: executionPlan.error_log_path,
+            halt_reason: haltReason,
+            ...haltArtifactFields("cancellation", null),
+        };
+    }
+    const initialCancelRequest = await readReviewCancelRequest(sessionRoot);
+    if (initialCancelRequest) {
+        return haltForCancellation({
+            cancelRequest: initialCancelRequest,
+            phase: "before_lens_dispatch",
+        });
+    }
     async function runLensWorker(workerIndex) {
         // Stagger initial dispatch to avoid thundering-herd on external APIs.
         // Only the very first dispatch of each worker is staggered; subsequent
@@ -1471,6 +1663,13 @@ export async function executeReviewPromptExecution(params) {
             if (!dispatch) {
                 return;
             }
+            if (await readReviewCancelRequest(sessionRoot)) {
+                return;
+            }
+            if (!shouldRunUnit(dispatch.unit_id)) {
+                executionOutcomes[currentIndex] = preservedOutcomeForDispatch(dispatch);
+                continue;
+            }
             console.log(`[review runner] starting ${dispatch.unit_kind}: ${dispatch.unit_id}`);
             await appendExecutionProgress(executionPlan.error_log_path, `runner dispatch started: ${dispatch.unit_id}`, [
                 `unit_id: ${dispatch.unit_id}`,
@@ -1539,7 +1738,8 @@ export async function executeReviewPromptExecution(params) {
             }
         }
     }
-    if (params.reviewExecutionProfile?.mode === "nested-workers" &&
+    if (!continuationMode &&
+        params.reviewExecutionProfile?.mode === "nested-workers" &&
         params.reviewExecutionProfile.worker_executor === "codex") {
         console.log("[review runner] mode=nested-workers worker_executor=codex");
         await appendExecutionProgress(executionPlan.error_log_path, "runner profile dispatch: nested-workers", [
@@ -1611,6 +1811,13 @@ export async function executeReviewPromptExecution(params) {
     else {
         await Promise.all(Array.from({ length: Math.min(maxConcurrentLenses, lensDispatches.length) }, async (_, workerIndex) => runLensWorker(workerIndex)));
     }
+    const postLensCancelRequest = await readReviewCancelRequest(sessionRoot);
+    if (postLensCancelRequest) {
+        return haltForCancellation({
+            cancelRequest: postLensCancelRequest,
+            phase: "after_lens_dispatch",
+        });
+    }
     const successfulLensDispatches = executionOutcomes
         .filter(isSuccessfulOutcome)
         .map((outcome) => outcome.dispatch);
@@ -1755,6 +1962,24 @@ export async function executeReviewPromptExecution(params) {
         };
     };
     for (const artifactId of PRE_DELIBERATION_ISSUE_ARTIFACT_IDS) {
+        const cancelRequest = await readReviewCancelRequest(sessionRoot);
+        if (cancelRequest) {
+            return haltForCancellation({
+                cancelRequest,
+                phase: `before_issue_artifact:${artifactId}`,
+                issueArtifactOutcomes,
+            });
+        }
+        if (!shouldRunUnit(artifactId)) {
+            issueArtifactOutcomes.push(preservedOutcomeForDispatch({
+                unit_id: artifactId,
+                unit_kind: "issue_artifact",
+                packet_path: executionPlan.issue_artifact_prompt_packet_seats.find((seat) => seat.artifact_id === artifactId)?.packet_path ??
+                    path.join(executionPlan.prompt_packets_root, issueArtifactSpec(artifactId).prompt_packet_file_name),
+                output_path: issueArtifactOutputPath(executionPlan, artifactId),
+            }));
+            continue;
+        }
         try {
             issueArtifactOutcomes.push(await runIssueArtifactDispatch({
                 projectRoot,
@@ -1778,6 +2003,14 @@ export async function executeReviewPromptExecution(params) {
         executionPlan,
     });
     let controlledDeliberation;
+    const preDeliberationCancelRequest = await readReviewCancelRequest(sessionRoot);
+    if (preDeliberationCancelRequest) {
+        return haltForCancellation({
+            cancelRequest: preDeliberationCancelRequest,
+            phase: "before_controlled_deliberation",
+            issueArtifactOutcomes,
+        });
+    }
     try {
         controlledDeliberation = await runControlledLensDeliberation({
             projectRoot,
@@ -1789,6 +2022,12 @@ export async function executeReviewPromptExecution(params) {
             maxConcurrentLenses,
             unitTimeoutMs,
             issueArtifactContext,
+            ...(continuationMode
+                ? {
+                    runUnitIds: continuationRunUnitIds,
+                    preservedResultsByUnitId: previousResultsByUnitId,
+                }
+                : {}),
         });
     }
     catch (error) {
@@ -1856,32 +2095,43 @@ export async function executeReviewPromptExecution(params) {
             ...haltArtifactFields("controlled_lens_deliberation", failedDeliberationOutcome),
         };
     }
-    try {
-        issueArtifactOutcomes.push(await runIssueArtifactDispatch({
-            projectRoot,
-            sessionRoot,
-            executionPlan,
-            executorConfig: teamleadExecutorConfig,
-            artifactId: "problem-framing",
-            lensOutputPaths,
-            deliberationResponsePaths: controlledDeliberation.deliberationDispatches.map((dispatch) => dispatch.output_path),
-            deliberationOutputPath: executionPlan.deliberation_output_path,
-            problemFramingProfileRef: await resolveProblemFramingProfileRef({
-                projectRoot,
-                executionPlan,
-            }),
-            unitTimeoutMs,
+    if (!shouldRunUnit("problem-framing")) {
+        issueArtifactOutcomes.push(preservedOutcomeForDispatch({
+            unit_id: "problem-framing",
+            unit_kind: "issue_artifact",
+            packet_path: executionPlan.issue_artifact_prompt_packet_seats.find((seat) => seat.artifact_id === "problem-framing")?.packet_path ??
+                path.join(executionPlan.prompt_packets_root, issueArtifactSpec("problem-framing").prompt_packet_file_name),
+            output_path: executionPlan.problem_framing_path,
         }));
     }
-    catch (error) {
-        return haltAfterIssueArtifactFailure({
-            error,
-            deliberationStatus: "performed",
-            deliberationExecutionResults: [
-                ...controlledDeliberation.deliberationOutcomes,
-                controlledDeliberation.teamleadOutcome,
-            ],
-        });
+    else {
+        try {
+            issueArtifactOutcomes.push(await runIssueArtifactDispatch({
+                projectRoot,
+                sessionRoot,
+                executionPlan,
+                executorConfig: teamleadExecutorConfig,
+                artifactId: "problem-framing",
+                lensOutputPaths,
+                deliberationResponsePaths: controlledDeliberation.deliberationDispatches.map((dispatch) => dispatch.output_path),
+                deliberationOutputPath: executionPlan.deliberation_output_path,
+                problemFramingProfileRef: await resolveProblemFramingProfileRef({
+                    projectRoot,
+                    executionPlan,
+                }),
+                unitTimeoutMs,
+            }));
+        }
+        catch (error) {
+            return haltAfterIssueArtifactFailure({
+                error,
+                deliberationStatus: "performed",
+                deliberationExecutionResults: [
+                    ...controlledDeliberation.deliberationOutcomes,
+                    controlledDeliberation.teamleadOutcome,
+                ],
+            });
+        }
     }
     const synthesizePacketRuntimePath = path.join(executionPlan.prompt_packets_root, "synthesize.runtime.prompt.md");
     const synthesizePacketText = await fs.readFile(executionPlan.synthesize_prompt_packet_path, "utf8");
@@ -1905,47 +2155,68 @@ export async function executeReviewPromptExecution(params) {
         packet_path: synthesizePacketRuntimePath,
         output_path: executionPlan.synthesis_output_path,
     };
-    await emitReviewProgress({
-        executionPlan,
-        step: 12,
-        label: "synthesize and write execution result",
-        details: [`participating_lens_count=${successfulLensDispatches.length}`],
-    });
-    console.log("[review runner] starting synthesize: synthesize");
-    await appendExecutionProgress(executionPlan.error_log_path, "runner dispatch started: synthesize", [
-        `unit_id: ${synthesizeDispatch.unit_id}`,
-        `unit_kind: ${synthesizeDispatch.unit_kind}`,
-        `packet_path: ${synthesizeDispatch.packet_path}`,
-        `output_path: ${synthesizeDispatch.output_path}`,
-    ]);
+    const preSynthesizeCancelRequest = await readReviewCancelRequest(sessionRoot);
+    if (preSynthesizeCancelRequest) {
+        return haltForCancellation({
+            cancelRequest: preSynthesizeCancelRequest,
+            phase: "before_synthesize",
+            issueArtifactOutcomes,
+            deliberationExecutionResults: [
+                ...controlledDeliberation.deliberationOutcomes,
+                controlledDeliberation.teamleadOutcome,
+            ],
+            deliberationStatus: "performed",
+        });
+    }
+    if (shouldRunUnit("synthesize")) {
+        await emitReviewProgress({
+            executionPlan,
+            step: 12,
+            label: "synthesize and write execution result",
+            details: [`participating_lens_count=${successfulLensDispatches.length}`],
+        });
+        console.log("[review runner] starting synthesize: synthesize");
+        await appendExecutionProgress(executionPlan.error_log_path, "runner dispatch started: synthesize", [
+            `unit_id: ${synthesizeDispatch.unit_id}`,
+            `unit_kind: ${synthesizeDispatch.unit_kind}`,
+            `packet_path: ${synthesizeDispatch.packet_path}`,
+            `output_path: ${synthesizeDispatch.output_path}`,
+        ]);
+    }
     const synthesizeStartedAtMs = Date.now();
     const synthesizeMaxRetries = 1;
     let synthesizeOutcome = null;
     let synthesizeLastError = undefined;
     let synthesizeSucceeded = false;
-    for (let attempt = 0; attempt <= synthesizeMaxRetries; attempt++) {
-        try {
-            await invokeExecutor(synthesizeExecutorConfig, projectRoot, sessionRoot, synthesizeDispatch, unitTimeoutMs);
-            synthesizeSucceeded = true;
-            break;
-        }
-        catch (error) {
-            synthesizeLastError = error;
-            if (!isReviewUnitTimeoutError(error) && attempt < synthesizeMaxRetries) {
-                const retryDelay = DEFAULT_LENS_RETRY_INITIAL_DELAY_MS;
-                console.log(`[review runner] synthesize attempt ${attempt + 1} failed, retrying in ${retryDelay}ms...`);
-                await appendExecutionProgress(executionPlan.error_log_path, "runner synthesize retry", [
-                    `attempt: ${attempt + 1}/${synthesizeMaxRetries}`,
-                    `retry_delay_ms: ${retryDelay}`,
-                    `error: ${error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)}`,
-                ]);
-                await sleep(retryDelay);
-            }
-            if (isReviewUnitTimeoutError(error))
+    if (shouldRunUnit("synthesize")) {
+        for (let attempt = 0; attempt <= synthesizeMaxRetries; attempt++) {
+            try {
+                await invokeExecutor(synthesizeExecutorConfig, projectRoot, sessionRoot, synthesizeDispatch, unitTimeoutMs);
+                synthesizeSucceeded = true;
                 break;
+            }
+            catch (error) {
+                synthesizeLastError = error;
+                if (!isReviewUnitTimeoutError(error) && attempt < synthesizeMaxRetries) {
+                    const retryDelay = DEFAULT_LENS_RETRY_INITIAL_DELAY_MS;
+                    console.log(`[review runner] synthesize attempt ${attempt + 1} failed, retrying in ${retryDelay}ms...`);
+                    await appendExecutionProgress(executionPlan.error_log_path, "runner synthesize retry", [
+                        `attempt: ${attempt + 1}/${synthesizeMaxRetries}`,
+                        `retry_delay_ms: ${retryDelay}`,
+                        `error: ${error instanceof Error ? error.message.slice(0, 200) : String(error).slice(0, 200)}`,
+                    ]);
+                    await sleep(retryDelay);
+                }
+                if (isReviewUnitTimeoutError(error))
+                    break;
+            }
         }
     }
-    if (synthesizeSucceeded) {
+    else {
+        synthesizeOutcome = preservedOutcomeForDispatch(synthesizeDispatch);
+        synthesizeSucceeded = true;
+    }
+    if (synthesizeSucceeded && synthesizeOutcome === null) {
         synthesizeOutcome = {
             dispatch: synthesizeDispatch,
             success: true,

package/dist/core-runtime/path-boundary.js

@@ -0,0 +1,58 @@
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+export function isPathInsideRoot(root, candidate) {
+    const relative = path.relative(path.resolve(root), path.resolve(candidate));
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
+}
+export async function realpathIfExists(targetPath) {
+    try {
+        return await fs.realpath(targetPath);
+    }
+    catch {
+        return null;
+    }
+}
+export function realpathIfExistsSync(targetPath) {
+    try {
+        return fsSync.realpathSync(targetPath);
+    }
+    catch {
+        return null;
+    }
+}
+export async function realpathNearestExisting(targetPath) {
+    let current = path.resolve(targetPath);
+    while (true) {
+        const real = await realpathIfExists(current);
+        if (real)
+            return real;
+        const parent = path.dirname(current);
+        if (parent === current)
+            return null;
+        current = parent;
+    }
+}
+export function isPathInsideRootRealpathAwareSync(root, candidate) {
+    const realRoot = realpathIfExistsSync(root) ?? path.resolve(root);
+    const realCandidate = realpathIfExistsSync(candidate) ?? path.resolve(candidate);
+    return isPathInsideRoot(realRoot, realCandidate);
+}
+export async function assertPathInsideRoot(args) {
+    const root = path.resolve(args.root);
+    const candidate = path.resolve(args.candidate);
+    if (!isPathInsideRoot(root, candidate)) {
+        throw new Error(`${args.label} escapes allowed root: ${candidate}`);
+    }
+    const realRoot = (await realpathIfExists(root)) ?? root;
+    const realCandidate = await realpathIfExists(candidate);
+    if (realCandidate && !isPathInsideRoot(realRoot, realCandidate)) {
+        throw new Error(`${args.label} realpath escapes allowed root: ${realCandidate}`);
+    }
+    if (!realCandidate) {
+        const nearest = await realpathNearestExisting(path.dirname(candidate));
+        if (nearest && !isPathInsideRoot(realRoot, nearest)) {
+            throw new Error(`${args.label} parent realpath escapes allowed root: ${nearest}`);
+        }
+    }
+}