perttool 0.11.1 → 0.12.1

package/dist/cli.js

@@ -1,4 +1,6 @@
 #!/usr/bin/env node
+// R: Execute the active CLI contract and bind its results to document and persistence ports.
+import { createReadStream } from "node:fs";
 import { lstat } from "node:fs/promises";
 import process from "node:process";
 import { TextDecoder } from "node:util";
@@ -7,11 +9,11 @@ import { createNodeHost } from "./node/host.js";
 import { createHistoricalGraphGitEvidenceHost } from "./node/historical-host.js";
 import { exportMermaid, } from "./conversion/mermaid.js";
 import { importMermaid } from "./conversion/mermaid-import.js";
-import { getContract10Guide as getAssuranceGuide, renderContract10GuideResult as renderAssuranceGuideResult, serializeContract10GuideResult as serializeAssuranceGuideResult, } from "./help/contract10-guide.js";
+import { getContract11Guide as getAssuranceGuide, renderContract11GuideResult as renderAssuranceGuideResult, serializeContract11GuideResult as serializeAssuranceGuideResult, } from "./help/contract11-guide.js";
 import { commandOptionSets, } from "./command/registry.js";
-import { CONTRACT10_COMMAND_REGISTRY as ASSURANCE_COMMAND_REGISTRY, getContract10CommandDiscovery as getAssuranceCommandDiscovery, renderContract10CommandHelpResult as renderAssuranceCommandHelpResult, serializeContract10CommandHelpResult as serializeAssuranceCommandHelpResult, } from "./command/contract10-discovery.js";
+import { CONTRACT11_COMMAND_REGISTRY as ASSURANCE_COMMAND_REGISTRY, getContract11CommandDiscovery as getAssuranceCommandDiscovery, renderContract11CommandHelpResult as renderAssuranceCommandHelpResult, serializeContract11CommandHelpResult as serializeAssuranceCommandHelpResult, } from "./command/contract11-discovery.js";
 import { handlerCommandUsageError, } from "./command/usage.js";
-import { renderContract10CommandUsageError as renderAssuranceCommandUsageError, serializeContract10CommandUsageError as serializeAssuranceCommandUsageError, validateContract10CommandInvocation as validateAssuranceCommandInvocation, } from "./command/contract10-usage.js";
+import { renderContract11CommandUsageError as renderAssuranceCommandUsageError, serializeContract11CommandUsageError as serializeAssuranceCommandUsageError, validateContract11CommandInvocation as validateAssuranceCommandInvocation, } from "./command/contract11-usage.js";
 import { agentGuidanceResultToJson } from "./guidance/projection.js";
 import { agentGuidanceExitCode, renderAgentGuidanceText, } from "./guidance/text.js";
 import { SafeWriteConflictError, SafeWriteVerificationError, } from "./io/safe-write.js";
@@ -27,9 +29,21 @@ import { TARGET_GRAMMAR_6_CAPABILITY, } from "./parser/document-parser.js";
 import { exportPlanAssuranceMermaid, importPlanAssuranceMermaid, } from "./assurance/mermaid.js";
 import { getJsonSchemaResult, renderJsonSchemaResult, serializeJsonSchemaResult, } from "./schema/registry.js";
 import { TOOL_VERSION } from "./version.js";
-import { analyzeDocument as analyzeContract8Document, checkDocument as checkContract8Document, planGrammarMigration as planContract10GrammarMigration, selectNextTasks as selectContract8NextTasks, } from "./application/contract10-runtime.js";
+import { checkDocument as checkContract8Document, planGrammarMigration as planContract10GrammarMigration, } from "./application/contract10-runtime.js";
+import { analyzeDocument as analyzeContract11Document, checkDocument as checkContract11Document, selectNextTasks as selectContract11NextTasks, planReviewProjection, } from "./application/contract11-runtime.js";
+import { planPlanReviewCreate, planPlanReviewResolve } from "./application/plan-review-mutation.js";
+import { parsePlanReviewSource, PLAN_REVIEW_SOURCE_CAPABILITY } from "./plan-review/source.js";
+import { projectPlanReviewState } from "./plan-review/projection.js";
+import { formatPlanReviewSource } from "./plan-review/format.js";
+import { persistPlanReviewMutation } from "./plan-review/write.js";
+import { PLAN_REVIEW_CREATE_REQUEST_ID, PLAN_REVIEW_RESOLVE_REQUEST_ID } from "./plan-review/mutation-types.js";
+import { normalizePlanReviewCreateRequest, normalizePlanReviewResolveRequest } from "./plan-review/request.js";
+import { planReviewBaseText, scanPlanReviewDeclarationBlocks } from "./plan-review/source-lexical.js";
+import { composePlanReviewAdvanceCandidate, assessPlanReviewAdvanceHistory } from "./plan-review/advance.js";
 import { contract9CheckResultToJson, contract9ProjectResultToJson, liftContract9AnalysisResultJson, liftContract9NextResultJson, renderContract9ScheduleAlerts, contract9WireJson, } from "./application/contract9-projection.js";
 import { planContract9GrammarMigration } from "./application/contract9-format-migration.js";
+import { planContract11GrammarMigration } from "./application/contract11-migration.js";
+import { liftContract11Candidate } from "./application/contract11-candidate.js";
 import { planContract9TemporalMutation } from "./application/contract9-temporal-mutation.js";
 import { composeContract9MixedMutation, composeContract9TemporalMutation } from "./application/contract9-mixed-mutation.js";
 import { planAcceptanceReceiptMutation, planCriterionSetReplacement, showMilestoneAcceptance, } from "./milestone-acceptance/mutation.js";
@@ -48,9 +62,9 @@ import { compilePlanningIntentRequest, isPlanningIntentRequest, } from "./planni
 import { renderPlanningHistoricalObservationText, renderPlanningObservationText, renderPlanningPoolReadText, renderPlanningReshapePreflightText, } from "./planning-pool/human.js";
 const historicalGitEvidenceHost = createHistoricalGraphGitEvidenceHost();
 const { analyzeDocument: _analyzeContract7Document, checkDocument: _checkContract7Document, selectNextTasks: _selectContract7NextTasks, planFormat, planProjectInit, projectInitResultToJson, renderProjectInitResult, withProjectInitOutput, planUnitMigration, withUnitMigrationWrite, getProjectMetadata, contract7ProjectResultToJson, renderContract7ProjectText, planAdvance, planBatchMutation, planFinishActuals, planLifecycle, planMutation, planAssuranceMutation, renderTargetGovernanceDecision, contract7InspectionResultToJson, contract7MutationResultToJson, contract7SnakeJson, contract6WorkEventToJson, renderAdvanceHistoryGuard, prepareTargetPlanAssuranceAdvanceHistory, prepareAdvanceHistory, withAdvanceHistoryRace, withTargetPlanAssuranceAdvanceHistoryRace, persistTargetPlanAssuranceResult, inspectTargetPlanAssurance, inspectTargetCurrentProjectActuals, inspectTargetProjectHistoryFile, renderTargetProjectHistoryText, targetProjectHistoryResultToJson, observeTargetProjectVelocity, renderTargetVelocityObservationText, targetVelocityObservationResultToJson, getAgentHelp, documentContentFromBytes, readDocumentContent, readBytes, recheckAdvanceHistoryBaseline, captureAdvanceHistoryBaseline, createArtifactFile, createValidatedDocumentFile, createTargetGrammar6DocumentFile, replaceTargetGrammar6DocumentFile, replaceValidatedDocumentFile, inspectTargetHistoricalGraphFile, renderTargetHistoricalGraphText, targetHistoricalGraphResultToJson, } = createCliApplicationFacade(createNodeHost(), historicalGitEvidenceHost);
-const analyzeDocument = analyzeContract8Document;
-const checkDocument = checkContract8Document;
-const selectNextTasks = selectContract8NextTasks;
+const analyzeDocument = analyzeContract11Document;
+const checkDocument = checkContract11Document;
+const selectNextTasks = selectContract11NextTasks;
 function contract9MutationResultToJson(result, ...args) {
     return Object.freeze({
         ...contract7MutationResultToJson(result, ...args),
@@ -231,7 +245,7 @@ async function readStdin() {
 function writeJson(value) {
     const contract8Value = typeof value === "object" && value !== null && !Array.isArray(value) &&
         "cli_contract_version" in value
-        ? { ...value, cli_contract_version: 10 }
+        ? { ...value, cli_contract_version: 11 }
         : value;
     process.stdout.write(`${JSON.stringify(contract8Value)}\n`);
 }
@@ -542,20 +556,25 @@ async function persistContract8CandidateResult(result, request) {
     if (!result.ok || !result.governance?.writeAuthorized || result.updatedText === null) {
         throw new TypeError("authorized Contract 8 result does not contain a digest-bound candidate");
     }
-    const validator = /^  version 9$/mu.test(result.updatedText)
+    const validator = /^  version 10$/mu.test(result.updatedText)
         ? (candidate) => {
-            const parsed = parsePlanningPoolSource(candidate, PLANNING_POOL_SOURCE_CAPABILITY);
+            const parsed = parsePlanReviewSource(candidate, PLAN_REVIEW_SOURCE_CAPABILITY);
             return { ok: parsed.ok, diagnostics: parsed.diagnostics };
         }
-        : /^  version 8$/mu.test(result.updatedText)
+        : /^  version 9$/mu.test(result.updatedText)
             ? (candidate) => {
-                const checked = checkDocument(candidate);
-                return { ok: checked.ok, diagnostics: checked.diagnostics };
+                const parsed = parsePlanningPoolSource(candidate, PLANNING_POOL_SOURCE_CAPABILITY);
+                return { ok: parsed.ok, diagnostics: parsed.diagnostics };
             }
-            : (candidate) => {
-                const parsed = parseMilestoneAcceptanceSource(candidate, MILESTONE_ACCEPTANCE_SOURCE_CAPABILITY);
-                return { ok: parsed.ok, diagnostics: [] };
-            };
+            : /^  version 8$/mu.test(result.updatedText)
+                ? (candidate) => {
+                    const checked = checkDocument(candidate);
+                    return { ok: checked.ok, diagnostics: checked.diagnostics };
+                }
+                : (candidate) => {
+                    const parsed = parseMilestoneAcceptanceSource(candidate, MILESTONE_ACCEPTANCE_SOURCE_CAPABILITY);
+                    return { ok: parsed.ok, diagnostics: [] };
+                };
     if (request.mode === "in_place") {
         await replaceValidatedDocumentFile(request.target, result.updatedText, {
             initialDigest: result.originalDigest,
@@ -578,6 +597,13 @@ async function commitCandidate(request, candidateText, initialDigest) {
     if (candidateText === null) {
         throw new SafeWriteVerificationError("invalid_candidate", "successful editing result has no candidate text");
     }
+    if (/^  version 10$/mu.test(candidateText)) {
+        const validator = (candidate) => {
+            const parsed = parsePlanReviewSource(candidate, PLAN_REVIEW_SOURCE_CAPABILITY);
+            return { ok: parsed.ok, diagnostics: parsed.diagnostics };
+        };
+        return commitValidatedCandidate(request, candidateText, initialDigest, validator);
+    }
     if (/^  version 9$/mu.test(candidateText)) {
         const validator = (candidate) => {
             const parsed = parsePlanningPoolSource(candidate, PLANNING_POOL_SOURCE_CAPABILITY);
@@ -668,37 +694,15 @@ function emitGrammarMigrationResult(format, result, sourceOperand, sourceDigest,
         process.stdout.write(diffOnly ? result.diff ?? "" : result.updatedText);
     }
 }
-async function runContract9DocumentMigration(args) {
-    const parsed = parseCommandOptions("document.migrate", args);
-    if (parsed.positionals.length !== 1 || parsed.values.get("target-grammar") !== "8")
-        throw new UsageError("document migrate requires <file> --target-grammar 8");
-    const sourceOperand = parsed.positionals[0];
-    const format = outputFormat(parsed.values.get("format"));
-    const input = await readDocument(sourceOperand);
-    const result = planContract9GrammarMigration(input.text);
-    let written = false;
-    if (result.ok && result.updatedText !== null && parsed.flags.has("write")) {
-        if (sourceOperand === "-")
-            throw new UsageError("document migrate --write requires a file");
-        await replaceValidatedDocumentFile(sourceOperand, result.updatedText, { initialDigest: input.digest, ...(parsed.values.get("expect-digest") === undefined ? {} : { expectedDigest: parsed.values.get("expect-digest") }) }, (candidate) => ({ ok: checkDocument(candidate).ok, diagnostics: [] }));
-        written = result.changed;
-    }
-    emitGrammarMigrationResult(format, result, sourceOperand, input.digest, Object.freeze({
-        mode: parsed.flags.has("write") ? "in_place" : "preview",
-        target: parsed.flags.has("write") ? sourceOperand : null,
-        written,
-    }), parsed.flags.has("diff"));
-    return result.ok ? 0 : 1;
-}
-async function runContract10DocumentMigration(args) {
+async function runVersionMigration(args, targetGrammar, planner, validate) {
     const parsed = parseCommandOptions("document.migrate", args);
-    if (parsed.positionals.length !== 1 || parsed.values.get("target-grammar") !== "9") {
-        throw new UsageError("document migrate requires <file> --target-grammar 9");
+    if (parsed.positionals.length !== 1 || parsed.values.get("target-grammar") !== targetGrammar) {
+        throw new UsageError(`document migrate requires <file> --target-grammar ${targetGrammar}`);
     }
     const sourceOperand = parsed.positionals[0];
     const format = outputFormat(parsed.values.get("format"));
     const input = await readDocument(sourceOperand);
-    const result = planContract10GrammarMigration(input.text);
+    const result = planner(input.text);
     let written = false;
     if (result.ok && result.updatedText !== null && parsed.flags.has("write")) {
         if (sourceOperand === "-")
@@ -708,10 +712,7 @@ async function runContract10DocumentMigration(args) {
             ...(parsed.values.get("expect-digest") === undefined
                 ? {}
                 : { expectedDigest: parsed.values.get("expect-digest") }),
-        }, (candidate) => {
-            const checked = parsePlanningPoolSource(candidate, PLANNING_POOL_SOURCE_CAPABILITY);
-            return { ok: checked.ok, diagnostics: checked.diagnostics };
-        });
+        }, validate);
         written = result.changed;
     }
     emitGrammarMigrationResult(format, result, sourceOperand, input.digest, Object.freeze({
@@ -721,6 +722,24 @@ async function runContract10DocumentMigration(args) {
     }), parsed.flags.has("diff"));
     return result.ok ? 0 : 1;
 }
+async function runSupportedGrammarMigration(args) {
+    const target = args.includes("--target-grammar")
+        ? args[args.indexOf("--target-grammar") + 1]
+        : args.find((value) => value.startsWith("--target-grammar="))?.slice("--target-grammar=".length);
+    if (target === "8")
+        return runVersionMigration(args, "8", planContract9GrammarMigration, (candidate) => ({ ok: checkDocument(candidate).ok, diagnostics: [] }));
+    if (target === "9")
+        return runVersionMigration(args, "9", planContract10GrammarMigration, (candidate) => {
+            const checked = parsePlanningPoolSource(candidate, PLANNING_POOL_SOURCE_CAPABILITY);
+            return { ok: checked.ok, diagnostics: checked.diagnostics };
+        });
+    if (target === "10")
+        return runVersionMigration(args, "10", planContract11GrammarMigration, (candidate) => {
+            const checked = parsePlanReviewSource(candidate, PLAN_REVIEW_SOURCE_CAPABILITY);
+            return { ok: checked.ok, diagnostics: checked.diagnostics };
+        });
+    return null;
+}
 async function runFormat(args) {
     const parsed = parseCommandOptions("document.format", args);
     if (parsed.positionals.length !== 1) {
@@ -739,11 +758,23 @@ async function runFormat(args) {
     catch (error) {
         return cliError(error instanceof Error ? error : new Error(String(error)), 3, "document.format", format === "json");
     }
-    const result = planFormat(input.text, {
-        maxDiagnostics,
-        originalLabel: source,
-        updatedLabel: "candidate",
-    });
+    const result = /^  version 10$/mu.test(input.text)
+        ? (() => {
+            const formatted = formatPlanReviewSource(input.text, PLAN_REVIEW_SOURCE_CAPABILITY, { maxDiagnostics });
+            return Object.freeze({
+                ...formatted, originalDigest: input.digest,
+                updatedDigest: formatted.formattedText === null ? null
+                    : sha256DigestUtf8(formatted.formattedText),
+                updatedText: formatted.formattedText,
+                diff: formatted.formattedText === null ? null
+                    : createUnifiedDiff(input.text, formatted.formattedText, { originalLabel: source, updatedLabel: "candidate" }),
+            });
+        })()
+        : planFormat(input.text, {
+            maxDiagnostics,
+            originalLabel: source,
+            updatedLabel: "candidate",
+        });
     const warningFailure = parsed.flags.has("warnings-as-errors") &&
         (result.diagnosticsTruncated ||
             result.diagnostics.some((diagnostic) => diagnostic.severity === "warning"));
@@ -1258,6 +1289,30 @@ async function readMutationRequest(source) {
         throw new UsageError(`mutation request is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
     }
 }
+class PlanReviewBatchTooLarge extends Error {
+}
+async function readPlanReviewBatchRequest(source) {
+    const maximumBytes = 8_388_608;
+    const chunks = [];
+    let totalBytes = 0;
+    const stream = source === "-" ? process.stdin : createReadStream(source, {
+        highWaterMark: 64 * 1024,
+    });
+    for await (const chunk of stream) {
+        const bytes = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+        totalBytes += bytes.length;
+        if (totalBytes > maximumBytes)
+            throw new PlanReviewBatchTooLarge();
+        chunks.push(bytes);
+    }
+    const text = new TextDecoder("utf-8", { fatal: true }).decode(Buffer.concat(chunks));
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new UsageError(`mutation request is not valid JSON: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
 async function runMutation(resource, action, args) {
     const parsed = parseCommandOptions(`${resource}.${action}`, args);
     const format = outputFormat(parsed.values.get("format"));
@@ -1357,7 +1412,7 @@ async function runMutation(resource, action, args) {
     const temporalRequest = contract9Invocation.ok
         ? planContract9TemporalMutation(input.text, contract9Invocation, { maxDiagnostics })
         : null;
-    const legacyPreview = legacyPlanner(input.text);
+    const legacyPreview = liftContract11Candidate(input.text, legacyPlanner, { originalLabel: source, updatedLabel: "candidate" });
     const result = temporalRequest === null
         ? legacyPreview
         : !legacyPreview.ok
@@ -1442,12 +1497,12 @@ async function runLifecycleMutation(action, args) {
     catch (error) {
         return cliError(error instanceof Error ? error : new Error(String(error)), 3, operation, format === "json");
     }
-    const result = planLifecycle(input.text, mutation, {
+    const result = liftContract11Candidate(input.text, (candidate) => planLifecycle(candidate, mutation, {
         maxDiagnostics,
         originalLabel: source,
         updatedLabel: "candidate",
         governance: governanceRequest(parsed, writeRequest),
-    });
+    }), { originalLabel: source, updatedLabel: "candidate" });
     const warningFailure = parsed.flags.has("warnings-as-errors") &&
         (result.diagnosticsTruncated ||
             result.diagnostics.some((diagnostic) => diagnostic.severity === "warning"));
@@ -1800,6 +1855,9 @@ function renderAdvanceSummary(details) {
     return [
         `ADVANCE removed_tasks=${list(details.removedTaskIds)} removed_gates=${list(details.removedGateIds)} removed_milestones=${list(details.removedMilestoneIds)} removed_work_events=${list("removedWorkEventIds" in details ? details.removedWorkEventIds : [])}`,
         `ADVANCE removed_planning_links=${list("removedPlanningLinks" in details ? details.removedPlanningLinks : [])} archived_works=${list("archivedWorkIds" in details ? details.archivedWorkIds : [])}`,
+        ...("removedPlanReviewRequestIds" in details
+            ? [`ADVANCE removed_plan_review_requests=${list(details.removedPlanReviewRequestIds)}`]
+            : []),
         `ADVANCE frontier_before=${list(details.frontierBefore)} frontier_after=${list(details.frontierAfter)} ready_before=${list(details.readyBefore)} ready_after=${list(details.readyAfter)}`,
         "",
     ].join("\n");
@@ -1829,6 +1887,22 @@ function renderAssuranceGuard(guard) {
         "",
     ].join("\n");
 }
+function mergeOuterAdvanceHistoryGuards(base, guards) {
+    return guards.reduce((current, guard) => Object.freeze({
+        ...current,
+        status: guard.status === "blocked" ? "blocked"
+            : guard.status === "forced" && current.status !== "blocked" ? "forced"
+                : current.status,
+        cause: guard.status === "passed" || guard.status === "not_applicable"
+            ? current.cause : guard.cause,
+        destructiveEntityIds: Object.freeze([...new Set([
+                ...current.destructiveEntityIds, ...guard.destructiveEntityIds,
+            ])].sort()),
+        overlappingEntityIds: Object.freeze([...new Set([
+                ...current.overlappingEntityIds, ...guard.overlappingEntityIds,
+            ])].sort()),
+    }), base);
+}
 async function runAdvance(args) {
     const parsed = parseCommandOptions("dag.advance", args);
     if (parsed.positionals.length !== 1) {
@@ -1851,10 +1925,28 @@ async function runAdvance(args) {
     catch (error) {
         return cliError(error instanceof Error ? error : new Error(String(error)), 3, "dag.advance", format === "json");
     }
-    const grammar9 = /^  version 9$/mu.test(input.text);
-    const strictInputText = grammar9
-        ? planningPoolBaseText(input.text, scanPlanningDeclarationBlocks(input.text))
+    const grammar10 = /^  version 10$/mu.test(input.text);
+    const reviewSource = grammar10
+        ? parsePlanReviewSource(input.text, PLAN_REVIEW_SOURCE_CAPABILITY, { maxDiagnostics })
+        : null;
+    if (reviewSource !== null && !reviewSource.ok) {
+        if (format === "json")
+            writeJson({ schema_version: "Perttool.CliError.v1",
+                cli_contract_version: 11, tool_version: TOOL_VERSION, operation: "dag.advance",
+                ok: false, diagnostics: reviewSource.diagnostics.map((value) => jsonDiagnostic(value)) });
+        else
+            for (const value of reviewSource.diagnostics) {
+                process.stderr.write(`${renderDiagnostic(value, source, color)}\n`);
+            }
+        return 1;
+    }
+    const reviewBaseText = grammar10
+        ? planReviewBaseText(input.text, scanPlanReviewDeclarationBlocks(input.text))
         : input.text;
+    const grammar9 = /^  version 9$/mu.test(reviewBaseText);
+    const strictInputText = grammar9
+        ? planningPoolBaseText(reviewBaseText, scanPlanningDeclarationBlocks(reviewBaseText))
+        : reviewBaseText;
     const acceptanceInputText = /^  version 8$/mu.test(strictInputText)
         ? temporalScheduleBaseText(strictInputText, scanTemporalDeclarationBlocks(strictInputText))
         : strictInputText;
@@ -1872,7 +1964,7 @@ async function runAdvance(args) {
         if (format === "json")
             writeJson({
                 schema_version: "Perttool.AdvanceResult.v4",
-                cli_contract_version: 10,
+                cli_contract_version: 11,
                 tool_version: TOOL_VERSION,
                 operation: "dag.advance",
                 ok: false,
@@ -1924,22 +2016,37 @@ async function runAdvance(args) {
             ...acceptancePlan.provisional.edits,
         ]), "Contract 8 acceptance-aware advance");
     const planningCleanup = grammar9 && contract7Planned.updatedText !== null
-        ? planPlanningAdvanceCleanup(input.text, contract7Planned.advance?.removedMilestoneIds ?? [], contract7Planned.advance?.removedTaskIds ?? [], parsed.flags.has("archive-empty-work"))
+        ? planPlanningAdvanceCleanup(reviewBaseText, contract7Planned.advance?.removedMilestoneIds ?? [], contract7Planned.advance?.removedTaskIds ?? [], parsed.flags.has("archive-empty-work"))
         : Object.freeze({
             edits: Object.freeze([]),
             removedPlanningLinks: Object.freeze([]),
             archivedWorkIds: Object.freeze([]),
             destructiveRecords: Object.freeze([]),
         });
-    const combinedEdits = contract7Planned.updatedText === null
+    const lowerCombinedEdits = contract7Planned.updatedText === null
         ? strictCombinedEdits
-        : normalizeTextEdits(input.text, [...strictCombinedEdits, ...planningCleanup.edits], "Contract 10 planning-aware advance");
-    const combinedText = contract7Planned.updatedText === null
+        : normalizeTextEdits(reviewBaseText, [...strictCombinedEdits, ...planningCleanup.edits], "Contract 10 planning-aware advance");
+    const versionLiftOffset = input.text.indexOf("  version 10") + "  version 9".length;
+    const liftedEdits = grammar10
+        ? Object.freeze(lowerCombinedEdits.map((edit) => Object.freeze({
+            ...edit,
+            startOffset: edit.startOffset >= versionLiftOffset ? edit.startOffset + 1 : edit.startOffset,
+            endOffset: edit.endOffset >= versionLiftOffset ? edit.endOffset + 1 : edit.endOffset,
+        })))
+        : lowerCombinedEdits;
+    const reviewCandidate = grammar10 && contract7Planned.updatedText !== null
+        ? composePlanReviewAdvanceCandidate(input.text, liftedEdits, contract7Planned.advance?.removedTaskIds ?? [])
+        : null;
+    const reviewFailed = reviewCandidate !== null && !reviewCandidate.ok;
+    const combinedEdits = reviewFailed ? Object.freeze([]) :
+        reviewCandidate?.edits ?? liftedEdits;
+    const combinedText = contract7Planned.updatedText === null ||
+        reviewFailed
         ? null
-        : applyTextEdits(input.text, combinedEdits);
+        : reviewCandidate?.updatedText ?? applyTextEdits(input.text, combinedEdits);
     const combinedCheck = combinedText === null
         ? null
-        : grammar9
+        : grammar9 || grammar10
             ? checkDocument(combinedText, { maxDiagnostics })
             : checkContract8Document(combinedText, { maxDiagnostics });
     if (combinedCheck !== null && !combinedCheck.ok) {
@@ -1951,6 +2058,7 @@ async function runAdvance(args) {
     const planned = Object.freeze({
         ...contract7Planned,
         schemaVersion: "Perttool.AdvanceResult.v4",
+        changed: reviewFailed ? false : contract7Planned.changed,
         originalDigest: input.digest,
         updatedText: combinedText,
         updatedDigest: combinedText === null ? null : sha256DigestUtf8(combinedText),
@@ -1959,7 +2067,11 @@ async function runAdvance(args) {
             updatedLabel: "candidate",
         }),
         edits: combinedEdits,
-        diagnostics: combinedDiagnostics?.diagnostics ?? contract7Planned.diagnostics,
+        ok: contract7Planned.ok && !reviewFailed,
+        diagnostics: Object.freeze([
+            ...(combinedDiagnostics?.diagnostics ?? contract7Planned.diagnostics),
+            ...(reviewCandidate?.diagnostics ?? []),
+        ]),
         diagnosticsTruncated: contract7Planned.diagnosticsTruncated ||
             (combinedCheck?.diagnosticsTruncated ?? false) ||
             (combinedDiagnostics?.truncated ?? false),
@@ -1970,6 +2082,7 @@ async function runAdvance(args) {
                 ...contract7Planned.advance,
                 removedPlanningLinks: planningCleanup.removedPlanningLinks,
                 archivedWorkIds: planningCleanup.archivedWorkIds,
+                ...(grammar10 ? { removedPlanReviewRequestIds: reviewCandidate?.removedRequestIds ?? Object.freeze([]) } : {}),
             }),
     });
     const initialWarningFailure = parsed.flags.has("warnings-as-errors") &&
@@ -1988,14 +2101,17 @@ async function runAdvance(args) {
         warningDenied: initialWarningFailure,
         maxDiagnostics,
         documentValidator: (candidateText, candidateMaxDiagnostics) => {
-            const planningBase = grammar9
-                ? planningPoolBaseText(candidateText, scanPlanningDeclarationBlocks(candidateText))
+            const reviewBase = /^  version 10$/mu.test(candidateText)
+                ? planReviewBaseText(candidateText, scanPlanReviewDeclarationBlocks(candidateText))
                 : candidateText;
+            const planningBase = /^  version 9$/mu.test(reviewBase)
+                ? planningPoolBaseText(reviewBase, scanPlanningDeclarationBlocks(reviewBase))
+                : reviewBase;
             const acceptanceBase = /^  version 8$/mu.test(planningBase)
                 ? temporalScheduleBaseText(planningBase, scanTemporalDeclarationBlocks(planningBase))
                 : planningBase;
             const acceptanceSource = parseMilestoneAcceptanceSource(acceptanceBase, MILESTONE_ACCEPTANCE_SOURCE_CAPABILITY);
-            const checked = grammar9
+            const checked = /^  version (?:9|10)$/mu.test(candidateText)
                 ? checkDocument(candidateText, { maxDiagnostics: candidateMaxDiagnostics })
                 : checkContract8Document(candidateText, { maxDiagnostics: candidateMaxDiagnostics });
             return {
@@ -2007,62 +2123,72 @@ async function runAdvance(args) {
             };
         },
     });
-    const planningAdvanceGuard = planningCleanup.destructiveRecords.length === 0
+    const planningRecords = grammar10
+        ? Object.freeze(planningCleanup.destructiveRecords.map((record) => Object.freeze({
+            ...record,
+            startOffset: record.startOffset >= versionLiftOffset ? record.startOffset + 1 : record.startOffset,
+            endOffset: record.endOffset >= versionLiftOffset ? record.endOffset + 1 : record.endOffset,
+        })))
+        : planningCleanup.destructiveRecords;
+    const needsReviewHistory = reviewCandidate?.ok === true &&
+        reviewCandidate.destructiveRecords.length > 0;
+    const captureAdditionalHistory = needsReviewHistory &&
+        writeRequest.mode === "in_place" && preparedBase.baseline === null &&
+        planned.ok && !initialWarningFailure &&
+        (planned.governance?.writeAuthorized ?? false);
+    const effectiveBaseline = captureAdditionalHistory
+        ? await captureAdvanceHistoryBaseline({
+            targetPath: sourceOperand, expectedSourceDigest: input.digest,
+        })
+        : preparedBase.baseline;
+    const planningAdvanceGuard = planningRecords.length === 0
+        ? planningHistoryNotApplicable([], "no_canonical_records")
+        : writeRequest.mode === "preview"
+            ? planningHistoryNotApplicable(planningRecords, "preview")
+            : writeRequest.mode === "out"
+                ? planningHistoryNotApplicable(planningRecords, "separate_output")
+                : effectiveBaseline === null
+                    ? planningHistoryNotApplicable(planningRecords, "authority_denied")
+                    : assessPlanningHistoryBaseline(input.text, planningRecords, effectiveBaseline, forceRequested);
+    const reviewAdvanceGuard = !needsReviewHistory
         ? planningHistoryNotApplicable([], "no_canonical_records")
         : writeRequest.mode === "preview"
-            ? planningHistoryNotApplicable(planningCleanup.destructiveRecords, "preview")
+            ? planningHistoryNotApplicable(reviewCandidate.destructiveRecords, "preview")
             : writeRequest.mode === "out"
-                ? planningHistoryNotApplicable(planningCleanup.destructiveRecords, "separate_output")
-                : preparedBase.baseline === null
-                    ? planningHistoryNotApplicable(planningCleanup.destructiveRecords, "authority_denied")
-                    : assessPlanningHistoryBaseline(input.text, planningCleanup.destructiveRecords, preparedBase.baseline, forceRequested);
-    const planningAdvanceBlocked = planningAdvanceGuard.status === "blocked";
+                ? planningHistoryNotApplicable(reviewCandidate.destructiveRecords, "separate_output")
+                : effectiveBaseline === null
+                    ? planningHistoryNotApplicable(reviewCandidate.destructiveRecords, "authority_denied")
+                    : assessPlanReviewAdvanceHistory(input.text, reviewCandidate, effectiveBaseline, forceRequested);
+    const outerAdvanceBlocked = planningAdvanceGuard.status === "blocked" ||
+        reviewAdvanceGuard.status === "blocked";
     const baseHistoryGuard = preparedBase.result.historyGuard;
     const combinedHistoryGuard = baseHistoryGuard === null
         ? null
-        : planningCleanup.destructiveRecords.length === 0
-            ? baseHistoryGuard
-            : Object.freeze({
-                ...baseHistoryGuard,
-                status: planningAdvanceGuard.status === "blocked"
-                    ? "blocked"
-                    : planningAdvanceGuard.status === "forced"
-                        ? "forced"
-                        : baseHistoryGuard.status,
-                cause: planningAdvanceGuard.status === "passed" ||
-                    planningAdvanceGuard.status === "not_applicable"
-                    ? baseHistoryGuard.cause
-                    : planningAdvanceGuard.cause,
-                destructiveEntityIds: Object.freeze([...new Set([
-                        ...baseHistoryGuard.destructiveEntityIds,
-                        ...planningAdvanceGuard.destructiveEntityIds,
-                    ])].sort()),
-                overlappingEntityIds: Object.freeze([...new Set([
-                        ...baseHistoryGuard.overlappingEntityIds,
-                        ...planningAdvanceGuard.overlappingEntityIds,
-                    ])].sort()),
-            });
-    const preparedDiagnostics = planningAdvanceBlocked
+        : mergeOuterAdvanceHistoryGuards(baseHistoryGuard, [planningAdvanceGuard, reviewAdvanceGuard]);
+    const preparedDiagnostics = outerAdvanceBlocked
         ? limitDiagnostics(sortDiagnostics([
             ...preparedBase.result.diagnostics,
             Object.freeze({
                 code: "PTADV-101",
                 severity: "error",
-                message: "advance history proof is blocked for canonical planning facts",
+                message: "advance history proof is blocked for canonical planning or Plan Review facts",
                 helpTopic: "editing",
                 data: Object.freeze({
-                    cause: planningAdvanceGuard.cause,
-                    entity_ids: planningAdvanceGuard.overlappingEntityIds,
+                    cause: planningAdvanceGuard.status === "blocked"
+                        ? planningAdvanceGuard.cause : reviewAdvanceGuard.cause,
+                    entity_ids: [...planningAdvanceGuard.overlappingEntityIds,
+                        ...reviewAdvanceGuard.overlappingEntityIds],
                 }),
             }),
         ]), maxDiagnostics)
         : null;
     const prepared = Object.freeze({
         ...preparedBase,
+        baseline: effectiveBaseline,
         result: Object.freeze({
             ...preparedBase.result,
             schemaVersion: "Perttool.AdvanceResult.v4",
-            ok: preparedBase.result.ok && !planningAdvanceBlocked,
+            ok: preparedBase.result.ok && !outerAdvanceBlocked,
             diagnostics: preparedDiagnostics?.diagnostics ?? preparedBase.result.diagnostics,
             diagnosticsTruncated: preparedBase.result.diagnosticsTruncated ||
                 (preparedDiagnostics?.truncated ?? false),
@@ -3055,7 +3181,7 @@ async function runNext(args) {
         if (format === "json") {
             writeJson({
                 schema_version: "Perttool.CliError.v1",
-                cli_contract_version: 9,
+                cli_contract_version: 11,
                 tool_version: TOOL_VERSION,
                 operation: "dag.next",
                 ok: false,
@@ -3074,28 +3200,33 @@ async function runNext(args) {
             result.diagnostics.some((diagnostic) => diagnostic.severity === "warning"));
     const ok = result.ok && !warningFailure;
     if (format === "json") {
-        writeJson(liftContract9NextResultJson({
-            schema_version: "Perttool.NextResult.v7",
-            cli_contract_version: 8,
-            recommendation_interface_version: 1,
-            tool_version: TOOL_VERSION,
-            operation: "dag.next",
-            ok,
-            document_id: result.documentId,
-            source,
-            source_digest: input.digest,
-            diagnostics: result.diagnostics.map(jsonDiagnostic),
-            diagnostics_truncated: result.diagnosticsTruncated,
-            grammar_version: result.grammarVersion,
-            ...(result.durationUnit === null ? {} : nextJson(result)),
-            temporal: snakeJson(result.temporal),
-            assurance: contract7SnakeJson(result.assurance),
-            acceptance: snakeJson(result.acceptance),
-        }, result));
+        writeJson({ plan_review: planReviewProjection(input.text), ...liftContract9NextResultJson({
+                schema_version: "Perttool.NextResult.v7",
+                cli_contract_version: 8,
+                recommendation_interface_version: 1,
+                tool_version: TOOL_VERSION,
+                operation: "dag.next",
+                ok,
+                document_id: result.documentId,
+                source,
+                source_digest: input.digest,
+                diagnostics: result.diagnostics.map(jsonDiagnostic),
+                diagnostics_truncated: result.diagnosticsTruncated,
+                grammar_version: result.grammarVersion,
+                ...(result.durationUnit === null ? {} : nextJson(result)),
+                temporal: snakeJson(result.temporal),
+                assurance: contract7SnakeJson(result.assurance),
+                acceptance: snakeJson(result.acceptance),
+            }, result), schema_version: "Perttool.NextResult.v9" });
     }
     else {
-        if (ok)
+        if (ok) {
+            const review = planReviewProjection(input.text);
+            if (review !== null) {
+                process.stdout.write(`PLAN_REVIEW ${JSON.stringify(review)}\n`);
+            }
             process.stdout.write(renderNextText(result));
+        }
         for (const diagnostic of result.diagnostics) {
             process.stderr.write(`${renderDiagnostic(diagnostic, source, color)}\n`);
         }
@@ -3284,16 +3415,12 @@ async function runMilestoneAcceptance(action, args) {
     return result.ok ? 0 : 1;
 }
 async function runDocumentMigration(args) {
-    const target = args.includes("--target-grammar")
-        ? args[args.indexOf("--target-grammar") + 1]
-        : args.find((value) => value.startsWith("--target-grammar="))?.slice("--target-grammar=".length);
-    if (target === "8")
-        return runContract9DocumentMigration(args);
-    if (target === "9")
-        return runContract10DocumentMigration(args);
+    const supported = await runSupportedGrammarMigration(args);
+    if (supported !== null)
+        return supported;
     const parsed = parseCommandOptions("document.migrate", args);
     if (parsed.positionals.length !== 1 || parsed.values.get("target-grammar") !== "7")
-        throw new UsageError("document migrate requires <file> --target-grammar 7, 8, or 9");
+        throw new UsageError("document migrate requires <file> --target-grammar 7, 8, 9, or 10");
     const sourceOperand = parsed.positionals[0];
     if (sourceOperand === "-")
         throw new UsageError("document migrate requires a repository file");
@@ -3955,6 +4082,229 @@ function planningHistoryDiagnostic(guard) {
         }),
     });
 }
+function planReviewRequestJson(request, sourceDigest) {
+    return Object.freeze({
+        id: request.id, qualified_id: request.qualifiedId,
+        task_id: request.taskId, qualified_task_id: request.qualifiedTaskId,
+        state: request.outcome === null ? "open" : "resolved",
+        task_reference_state: request.taskReferenceState, model: request.model,
+        reason: request.reason, created_at: request.createdAt,
+        created_by: request.createdBy, locator: request.locator,
+        outcome: request.outcome, resolved_at: request.resolvedAt,
+        resolved_by: request.resolvedBy, resolution_reason: request.resolutionReason,
+        reviewed_source_digest: request.reviewedSourceDigest,
+        change_request_digest: request.changeRequestDigest,
+        plan_basis_before: request.planBasisBefore,
+        plan_basis_after: request.planBasisAfter,
+        source_binding: Object.freeze({ source_digest: sourceDigest, span: jsonSpan(request.span) }),
+    });
+}
+function planReviewCliDiagnostic(code, message) {
+    return Object.freeze({ code, severity: "error", message,
+        helpTopic: "plan-review", data: Object.freeze({}) });
+}
+async function planReviewCommandInput(operation, args) {
+    const parsed = parseCommandOptions(operation, args);
+    const sourceOperand = parsed.positionals[0];
+    return Object.freeze({
+        parsed, sourceOperand,
+        source: sourceOperand === "-" ? "<stdin>" : sourceOperand,
+        format: outputFormat(parsed.values.get("format")),
+        input: await readDocument(sourceOperand),
+    });
+}
+function planReviewInputFailure(error, operation, args) {
+    if (error instanceof UsageError)
+        throw error;
+    return cliError(error instanceof Error ? error : new Error(String(error)), 3, operation, jsonRequested(args));
+}
+async function runPlanReviewRead(action, args) {
+    const operation = `plan.${action}`;
+    let commandInput;
+    try {
+        commandInput = await planReviewCommandInput(operation, args);
+    }
+    catch (error) {
+        return planReviewInputFailure(error, operation, args);
+    }
+    const { parsed, format, source, input } = commandInput;
+    const result = parsePlanReviewSource(input.text, PLAN_REVIEW_SOURCE_CAPABILITY);
+    const state = action === "review-list" ? parsed.values.get("state") ?? "all" : null;
+    if (state !== null && state !== "open" && state !== "resolved" && state !== "all") {
+        throw new UsageError("--state must be open, resolved, or all");
+    }
+    const id = action === "review-show" ? parsed.positionals[1] : null;
+    const matched = result.model?.requests.filter((request) => (id === null || request.id === id) &&
+        (state === null || state === "all" ||
+            (state === "open" ? request.outcome === null : request.outcome !== null))) ?? [];
+    const diagnostics = [
+        ...result.diagnostics,
+        ...(result.grammarVersion !== 10 ? [planReviewCliDiagnostic("PTREV-110", "Plan Review requires Grammar 10; migrate this document first")] : []),
+        ...(id !== null && result.ok && matched.length === 0 ? [planReviewCliDiagnostic("PTREV-105", `Plan Review Request ${id} was not found`)] : []),
+    ];
+    const ok = result.ok && result.model !== null &&
+        !diagnostics.some(({ severity }) => severity === "error");
+    const payload = Object.freeze({
+        schema_version: "Perttool.PlanReviewResult.v1", cli_contract_version: 11,
+        tool_version: TOOL_VERSION, operation, ok, document_id: result.documentId,
+        source, query: Object.freeze({ state, request_id: id }),
+        projection: result.model === null ? null : projectPlanReviewState(result.model),
+        requests: matched.map((request) => planReviewRequestJson(request, input.digest)),
+        diagnostics: diagnostics.map(jsonDiagnostic),
+    });
+    if (format === "json")
+        writeJson(payload);
+    else if (ok) {
+        for (const request of matched) {
+            process.stdout.write(`${request.id} ${request.taskId} ${request.outcome === null ? "open" : request.outcome}: ${request.reason}\n`);
+        }
+    }
+    else
+        for (const diagnostic of diagnostics) {
+            process.stderr.write(`${renderDiagnostic(diagnostic, source, "never")}\n`);
+        }
+    return ok ? 0 : 1;
+}
+function planReviewWriteRequest(parsed, sourceOperand) {
+    const inPlace = parsed.flags.has("in-place");
+    const output = parsed.values.get("output");
+    const expectedDigest = parsed.values.get("expected-digest");
+    if (inPlace && output !== undefined)
+        throw new UsageError("--output and --in-place are mutually exclusive");
+    if (parsed.flags.has("preview") && (inPlace || output !== undefined)) {
+        throw new UsageError("--preview cannot be combined with a write target");
+    }
+    if (inPlace && sourceOperand === "-")
+        throw new UsageError("--in-place requires a file");
+    if (expectedDigest !== undefined && !/^sha256:[0-9a-f]{64}$/.test(expectedDigest)) {
+        throw new UsageError("--expected-digest requires a lowercase SHA-256 digest");
+    }
+    if (inPlace)
+        return Object.freeze({ mode: "in_place", target: sourceOperand,
+            ...(expectedDigest === undefined ? {} : { expectedDigest }) });
+    if (output !== undefined)
+        return Object.freeze({ mode: "out", target: output });
+    return Object.freeze({ mode: "preview", target: null });
+}
+async function runPlanReviewMutation(action, args) {
+    const operation = `plan.${action}`;
+    let commandInput;
+    try {
+        commandInput = await planReviewCommandInput(operation, args);
+    }
+    catch (error) {
+        return planReviewInputFailure(error, operation, args);
+    }
+    const { parsed, format, sourceOperand, source, input } = commandInput;
+    const writeRequest = planReviewWriteRequest(parsed, sourceOperand);
+    if (writeRequest.mode === "in_place" && writeRequest.expectedDigest !== undefined &&
+        writeRequest.expectedDigest !== input.digest) {
+        return writeFailureExit(new SafeWriteConflictError("expected_digest_mismatch", "--expected-digest does not match the initial document digest"), operation, format === "json");
+    }
+    const requestPath = parsed.values.get("request");
+    let batchRequest;
+    if (requestPath !== undefined) {
+        if (sourceOperand === "-" && requestPath === "-") {
+            throw new UsageError("document and JSON request cannot both use stdin");
+        }
+        try {
+            batchRequest = await readPlanReviewBatchRequest(requestPath);
+        }
+        catch (error) {
+            if (error instanceof PlanReviewBatchTooLarge) {
+                batchRequest = null;
+            }
+            else {
+                if (error instanceof UsageError)
+                    throw error;
+                return cliError(error instanceof Error ? error : new Error(String(error)), 3, operation, format === "json");
+            }
+        }
+    }
+    const requestInput = action === "review-request"
+        ? Object.freeze({ schemaVersion: PLAN_REVIEW_CREATE_REQUEST_ID,
+            requestId: parsed.positionals[1], taskId: parsed.positionals[2],
+            reason: parsed.values.get("reason"), createdAt: parsed.values.get("created-at"),
+            actor: parsed.values.get("actor"),
+            ...(parsed.values.get("locator") === undefined ? {} : { locator: parsed.values.get("locator") }) })
+        : Object.freeze({ schemaVersion: PLAN_REVIEW_RESOLVE_REQUEST_ID,
+            requestId: parsed.positionals[1], outcome: parsed.values.get("outcome"),
+            resolvedAt: parsed.values.get("resolved-at"), actor: parsed.values.get("actor"),
+            resolutionReason: parsed.values.get("resolution-reason"),
+            acceptedOwners: Object.freeze(parsed.repeatedValues.get("accepted-owner") ?? []),
+            ...(requestPath === undefined ? {} : { request: batchRequest }), });
+    const normalizedCreate = action === "review-request"
+        ? normalizePlanReviewCreateRequest(requestInput) : null;
+    const normalizedResolve = action === "review-resolve"
+        ? normalizePlanReviewResolveRequest(requestInput) : null;
+    const expectedDigest = parsed.values.get("expected-digest");
+    const mutationOptions = expectedDigest === undefined ? {} : { expectedDigest };
+    const result = action === "review-request"
+        ? planPlanReviewCreate(input.text, requestInput, mutationOptions)
+        : planPlanReviewResolve(input.text, requestInput, mutationOptions);
+    let write = Object.freeze({
+        mode: writeRequest.mode, target: writeRequest.target, written: false,
+    });
+    if (result.ok && result.changed && writeRequest.mode !== "preview") {
+        try {
+            write = await persistPlanReviewMutation(result, writeRequest.mode === "in_place"
+                ? { mode: "in_place", target: writeRequest.target,
+                    ...(writeRequest.expectedDigest === undefined ? {} : { expectedDigest: writeRequest.expectedDigest }) }
+                : { mode: "out", source: sourceOperand, target: writeRequest.target }, createNodeHost().safePersistence);
+        }
+        catch (error) {
+            return writeFailureExit(error, operation, format === "json");
+        }
+    }
+    const requestWire = normalizedCreate?.request !== undefined && normalizedCreate.request !== null
+        ? snakeJson(normalizedCreate.request)
+        : normalizedResolve?.request === undefined || normalizedResolve.request === null ? null
+            : Object.freeze({ schema_version: PLAN_REVIEW_RESOLVE_REQUEST_ID,
+                request_id: normalizedResolve.request.requestId,
+                outcome: normalizedResolve.request.outcome, resolved_at: normalizedResolve.request.resolvedAt,
+                actor: normalizedResolve.request.actor, resolution_reason: normalizedResolve.request.resolutionReason,
+                accepted_owners: normalizedResolve.request.acceptedOwners,
+                change_request_digest: normalizedResolve.request.changeRequestDigest });
+    const requestBefore = result.requestBefore === null ? null
+        : planReviewRequestJson(result.requestBefore, input.digest);
+    const requestAfter = result.requestAfter === null ? null
+        : planReviewRequestJson(result.requestAfter, result.updatedDigest ?? input.digest);
+    const composed = result.composedMutation === null ? null : Object.freeze({
+        ok: result.composedMutation.ok, changed: result.composedMutation.changed,
+        original_digest: result.composedMutation.originalDigest,
+        updated_digest: result.composedMutation.updatedDigest,
+        updated_text: result.composedMutation.updatedText,
+        edits: snakeJson(result.composedMutation.edits),
+        diagnostics: result.composedMutation.diagnostics.map(jsonDiagnostic),
+        diagnostics_truncated: result.composedMutation.diagnosticsTruncated,
+    });
+    const payload = Object.freeze({
+        schema_version: "Perttool.PlanReviewMutationResult.v1", cli_contract_version: 11,
+        tool_version: TOOL_VERSION, operation, ok: result.ok,
+        document_id: result.documentId, source, request: requestWire,
+        request_before: requestBefore, request_after: requestAfter,
+        projection_before: result.projectionBefore, projection_after: result.projectionAfter,
+        plan_basis: snakeJson(result.planBasis),
+        plan_review_authority: result.planReviewAuthority,
+        composed_mutation: composed,
+        candidate: Object.freeze({ source_digest: input.digest,
+            candidate_digest: result.updatedDigest, text: result.updatedText,
+            changed: result.changed }),
+        edits: snakeJson(result.edits), diff: result.diff, write,
+        diagnostics: result.diagnostics.map(jsonDiagnostic),
+    });
+    if (format === "json")
+        writeJson(payload);
+    else if (result.ok && result.updatedText !== null) {
+        process.stdout.write(parsed.flags.has("diff") ? result.diff ?? "" : result.updatedText);
+    }
+    else
+        for (const diagnostic of result.diagnostics) {
+            process.stderr.write(`${renderDiagnostic(diagnostic, source, "never")}\n`);
+        }
+    return result.ok ? 0
+        : result.diagnostics.some(({ code, data }) => code === "PTREV-106" && data?.["cause"] === "expected_digest_mismatch") ? 5 : 1;
+}
 async function runPlanningReshapeApply(args) {
     const operation = "work.reshape.apply";
     const parsed = parseCommandOptions(operation, args);
@@ -4153,6 +4503,14 @@ async function dispatchCommand(descriptor, args) {
             return runRender(args);
         case "dag.history":
             return runHistoricalGraph(args);
+        case "plan.review-list":
+            return runPlanReviewRead("review-list", args);
+        case "plan.review-show":
+            return runPlanReviewRead("review-show", args);
+        case "plan.review-request":
+            return runPlanReviewMutation("review-request", args);
+        case "plan.review-resolve":
+            return runPlanReviewMutation("review-resolve", args);
         case "dag.import":
             return runImport(args);
         case "calendar.add":
@@ -4215,7 +4573,7 @@ async function dispatchCommand(descriptor, args) {
         const [resource, action] = descriptor.path;
         return runMutation(resource, action, args);
     }
-    throw new Error(`no Contract 10 handler for ${descriptor.operation}`);
+    throw new Error(`no Contract 11 handler for ${descriptor.operation}`);
 }
 function emitCommandUsage(error, json) {
     if (json) {