@navels/neal 0.1.0

package/dist/neal/prompts/specs.js

@@ -0,0 +1,572 @@
+function field(key, source, required, description) {
+    return { key, source, required, description };
+}
+function context(shapeName, fields) {
+    return { shapeName, fields };
+}
+const SHARED_PROVIDER_VARIANTS = [
+    {
+        provider: 'shared',
+        status: 'default',
+        notes: 'Default wording should stay shared across providers until fixture evidence justifies divergence.',
+    },
+    {
+        provider: 'openai-codex',
+        status: 'reserved_for_justified_divergence',
+        notes: 'Provider-specific overrides belong in prompt specs only when OpenAI Codex behavior demonstrably differs.',
+    },
+    {
+        provider: 'anthropic-claude',
+        status: 'reserved_for_justified_divergence',
+        notes: 'Provider-specific overrides belong in prompt specs only when Anthropic Claude behavior demonstrably differs.',
+    },
+];
+const PLAN_AUTHOR_CONTEXT = context('PlanAuthorPromptContext', [
+    field('planDoc', 'prompt_argument', true, 'Path to the draft or candidate plan artifact being rewritten.'),
+    field('companionDocs', 'repository_state', true, 'Companion docs explicitly referenced by the active plan.'),
+    field('repositoryState', 'repository_state', true, 'Current repository symbols and file structure that the plan must target concretely.'),
+    field('openFindings', 'review_history', false, 'Prior plan-review findings when refining the same plan artifact.'),
+    field('reviewMode', 'orchestrator_state', false, 'Plan review mode for ordinary vs derived-plan response wording.'),
+]);
+const PLAN_REVIEWER_CONTEXT = context('PlanReviewerPromptContext', [
+    field('planDoc', 'prompt_argument', true, 'Path to the plan artifact being reviewed.'),
+    field('reviewMarkdownPath', 'run_artifact', true, 'Review history artifact used to inspect prior findings and responses.'),
+    field('round', 'orchestrator_state', true, 'Review round number for the current plan-review loop.'),
+    field('mode', 'orchestrator_state', true, 'Plan review mode: ordinary plan or derived-plan.'),
+    field('parentPlanDoc', 'prompt_argument', false, 'Path to the parent plan when reviewing a derived plan.'),
+    field('derivedFromScopeNumber', 'orchestrator_state', false, 'Parent scope number when reviewing a derived plan.'),
+    field('repositoryState', 'repository_state', true, 'Current repository context and directly referenced companion docs.'),
+    field('inlineContext', 'repository_state', false, "Neal-inlined plan document, parent plan, and review-history sections for reviewers without repository read access; only valid with the 'no-read' access mode."),
+    field('accessMode', 'orchestrator_state', false, "Three-way reviewer doctrine access mode derived from the reviewer provider's structured-advisor tool access: 'tool-access' (inspect and execute), 'read-only' (read tools only; no command execution, test runs, or scratch work), or 'no-read' (judge entirely from Neal-inlined context). When absent the builder derives 'no-read' from inline-context presence, else 'tool-access'."),
+]);
+const SCOPE_CODER_CONTEXT = context('ScopeCoderPromptContext', [
+    field('planDoc', 'prompt_argument', true, 'Path to the active execute-mode plan.'),
+    field('progressText', 'run_artifact', true, 'Current Neal progress markdown used to keep the scope bounded.'),
+    field('openFindings', 'review_history', false, 'Open reviewer findings when responding inside the same scope.'),
+    field('verificationHint', 'orchestrator_state', false, 'Wrapper-provided verification guidance for reviewer-response rounds.'),
+    field('operatorGuidance', 'operator_input', false, 'Interactive blocked-recovery guidance when the scope is waiting on operator input.'),
+    field('recoveryMarkdownPath', 'run_artifact', false, 'Interactive blocked-recovery history artifact path.'),
+    field('blockedReason', 'orchestrator_state', false, 'Current blocked reason for interactive blocked recovery.'),
+    field('maxTurns', 'orchestrator_state', false, 'Blocked-recovery turn cap.'),
+    field('turnsTaken', 'orchestrator_state', false, 'Blocked-recovery turns already used.'),
+    field('terminalOnly', 'orchestrator_state', false, 'Whether only terminal replacement/block actions remain allowed.'),
+]);
+const SCOPE_REVIEWER_CONTEXT = context('ScopeReviewerPromptContext', [
+    field('planDoc', 'prompt_argument', true, 'Path to the active execute-mode plan.'),
+    field('baseCommit', 'orchestrator_state', true, 'Commit that defines the scope start.'),
+    field('headCommit', 'orchestrator_state', true, 'Commit that defines the scope head under review.'),
+    field('commits', 'orchestrator_state', true, 'Commits created during the current scope.'),
+    field('previousHeadCommit', 'orchestrator_state', false, 'Previous reviewer head commit when reviewing subsequent rounds.'),
+    field('diffStat', 'repository_state', true, 'Repo-derived diff summary for the scope commit range.'),
+    field('changedFiles', 'repository_state', true, 'Files changed in the scope commit range.'),
+    field('round', 'orchestrator_state', true, 'Review round number for the current scope.'),
+    field('parentScopeLabel', 'orchestrator_state', true, 'Active parent objective label for meaningful-progress review.'),
+    field('progressJustification', 'review_history', true, 'Coder-authored meaningful-progress JSON payload for the scope.'),
+    field('recentHistorySummary', 'review_history', true, 'Accepted-scope history for the active parent objective.'),
+    field('reviewMarkdownPath', 'run_artifact', true, 'Review artifact that carries prior findings and coder responses.'),
+    field('scratchDir', 'run_artifact', true, 'Run-local reviewer scratch directory for temporary verification artifacts.'),
+    field('inlineContext', 'repository_state', false, "Neal-inlined full diff, plan document, and review-history sections for reviewers without repository read access; only valid with the 'no-read' access mode."),
+    field('accessMode', 'orchestrator_state', false, "Three-way reviewer doctrine access mode derived from the reviewer provider's structured-advisor tool access: 'tool-access' (inspect and execute), 'read-only' (read tools only; no command execution, test runs, or scratch work), or 'no-read' (judge entirely from Neal-inlined context). When absent the builder derives 'no-read' from inline-context presence, else 'tool-access'."),
+]);
+const COMPLETION_CODER_CONTEXT = context('CompletionCoderPromptContext', [
+    field('planDoc', 'prompt_argument', true, 'Path to the execute-mode plan being evaluated for final completion.'),
+    field('packet', 'orchestrator_state', true, 'Whole-plan completion packet assembled from Neal run state.'),
+    field('repositoryState', 'repository_state', true, 'Current repository state used to ground the completion summary.'),
+]);
+const COMPLETION_REVIEWER_CONTEXT = context('CompletionReviewerPromptContext', [
+    field('planDoc', 'prompt_argument', true, 'Path to the execute-mode plan being evaluated for final completion.'),
+    field('packet', 'orchestrator_state', true, 'Whole-plan completion packet assembled from Neal run state.'),
+    field('summary', 'review_history', true, 'Coder-authored whole-plan completion summary under review.'),
+    field('scratchDir', 'run_artifact', true, 'Run-local final-completion reviewer scratch directory for temporary verification artifacts.'),
+    field('repositoryState', 'repository_state', true, 'Current repository state used to judge whole-plan completion.'),
+    field('inlineContext', 'repository_state', false, "Neal-inlined aggregate diff (or evidence-gap statement) and plan-document sections for reviewers without repository read access; only valid with the 'no-read' access mode."),
+    field('accessMode', 'orchestrator_state', false, "Three-way reviewer doctrine access mode derived from the reviewer provider's structured-advisor tool access: 'tool-access' (inspect and execute), 'read-only' (read tools only; no command execution, test runs, or scratch work), or 'no-read' (judge entirely from Neal-inlined context). When absent the builder derives 'no-read' from inline-context presence, else 'tool-access'."),
+]);
+export const PROMPT_SPECS = [
+    {
+        id: 'plan_author',
+        role: 'coder',
+        purpose: 'Author or revise Neal-executable plans without leaking planning-task scaffolding into final artifacts.',
+        requiredContext: PLAN_AUTHOR_CONTEXT,
+        schemaTarget: {
+            kind: 'structured_json',
+            schemaBuilder: 'buildCoderPlanSchema',
+            parser: 'validateCoderPlanPayload',
+            providerSurface: 'neal_json_block_protocol',
+        },
+        baseInstructions: {
+            kind: 'builder',
+            modulePath: 'src/neal/prompts/planning.ts',
+            exportName: 'buildPlanningPrompt',
+            inputShape: context('BuildPlanningPromptArgs', [field('planDoc', 'prompt_argument', true, 'Path to the draft plan artifact.')]),
+        },
+        providerVariants: SHARED_PROVIDER_VARIANTS,
+        evaluationNotes: [
+            'Render tests should assert the canonical Neal-executable execution-shape contract stays present.',
+            'Fixture cases should cover single-scope vs multi-scope decisions and cleanup of planning-only scaffolding.',
+        ],
+        firstMigrationPriority: 1,
+        currentHome: 'src/neal/prompts',
+        ownershipNotes: [
+            'Prompt spec owns plan-author instructions and required context only.',
+            'Plan review loop mechanics stay outside the prompt-spec library so the later adjudicator can consume them cleanly.',
+        ],
+        variants: [
+            {
+                kind: 'primary',
+                status: 'migration_target',
+                description: 'Initial plan-author prompt used by runCoderPlanRound.',
+                currentRoundEntrypoints: ['runCoderPlanRound'],
+                baseInstructions: {
+                    kind: 'builder',
+                    modulePath: 'src/neal/prompts/planning.ts',
+                    exportName: 'buildPlanningPrompt',
+                    inputShape: context('BuildPlanningPromptArgs', [field('planDoc', 'prompt_argument', true, 'Path to the draft plan artifact.')]),
+                },
+                schemaTarget: {
+                    kind: 'structured_json',
+                    schemaBuilder: 'buildCoderPlanSchema',
+                    parser: 'validateCoderPlanPayload',
+                    providerSurface: 'neal_json_block_protocol',
+                },
+            },
+            {
+                kind: 'response',
+                status: 'migration_target',
+                description: 'Plan-author response round used after plan-review findings.',
+                currentRoundEntrypoints: ['runCoderPlanResponseRound(reviewMode=plan)', 'runCoderPlanResponseRound(reviewMode=derived-plan)'],
+                baseInstructions: {
+                    kind: 'builder',
+                    modulePath: 'src/neal/prompts/planning.ts',
+                    exportName: 'buildCoderPlanResponsePrompt',
+                    inputShape: context('BuildCoderPlanResponsePromptArgs', [
+                        field('planDoc', 'prompt_argument', true, 'Path to the plan artifact being revised.'),
+                        field('openFindings', 'review_history', true, 'Open plan-review findings to address.'),
+                        field('reviewMode', 'orchestrator_state', false, 'Plan review mode for ordinary vs derived-plan response wording.'),
+                    ]),
+                },
+                schemaTarget: {
+                    kind: 'structured_json',
+                    schemaBuilder: 'buildCoderPlanResponseSchema',
+                    parser: 'validateCoderPlanResponsePayload',
+                    providerSurface: 'neal_json_block_protocol',
+                },
+            },
+        ],
+    },
+    {
+        id: 'plan_reviewer',
+        role: 'reviewer',
+        purpose: 'Review Neal-executable plans for execution-shape correctness, verification concreteness, and resume safety.',
+        requiredContext: PLAN_REVIEWER_CONTEXT,
+        schemaTarget: {
+            kind: 'structured_json',
+            schemaBuilder: 'buildPlanReviewerSchema',
+            parser: 'PlanReviewerPayload',
+            providerSurface: 'neal_json_block_protocol',
+        },
+        baseInstructions: {
+            kind: 'builder',
+            modulePath: 'src/neal/prompts/planning.ts',
+            exportName: 'buildPlanReviewerPrompt',
+            inputShape: context('BuildPlanReviewerPromptArgs', [
+                field('planDoc', 'prompt_argument', true, 'Path to the plan artifact under review.'),
+                field('round', 'orchestrator_state', true, 'Plan-review round number.'),
+                field('reviewMarkdownPath', 'run_artifact', true, 'Review history artifact path.'),
+                field('mode', 'orchestrator_state', false, 'Plan review mode for ordinary vs derived-plan review.'),
+            ]),
+        },
+        providerVariants: SHARED_PROVIDER_VARIANTS,
+        evaluationNotes: [
+            'Render tests should assert the reviewer prompt requires executionShape confirmation.',
+            'Render tests should assert shared adversarial plan-readiness posture and verification skepticism without adding implementation diff-review instructions.',
+            'Fixture cases should cover ordinary plans and derived plans.',
+        ],
+        firstMigrationPriority: 1,
+        currentHome: 'src/neal/prompts',
+        ownershipNotes: [
+            'Prompt spec owns plan-review instructions, not the loop convergence rules.',
+            'Derived-plan review is a variant of plan review rather than a separate top-level prompt-spec identity.',
+        ],
+        variants: [
+            {
+                kind: 'primary',
+                status: 'migration_target',
+                description: 'Ordinary plan-review round.',
+                currentRoundEntrypoints: ['runPlanReviewerRound(mode=plan)'],
+                baseInstructions: {
+                    kind: 'builder',
+                    modulePath: 'src/neal/prompts/planning.ts',
+                    exportName: 'buildPlanReviewerPrompt',
+                    inputShape: context('BuildPlanReviewerPromptArgs', [
+                        field('planDoc', 'prompt_argument', true, 'Path to the plan artifact under review.'),
+                        field('round', 'orchestrator_state', true, 'Plan-review round number.'),
+                        field('reviewMarkdownPath', 'run_artifact', true, 'Review history artifact path.'),
+                        field('inlineContext', 'repository_state', false, "Optional Neal-inlined plan/review-history context; only valid with the 'no-read' access mode, whose prompt contains no repository-access instructions."),
+                        field('accessMode', 'orchestrator_state', false, "Optional explicit doctrine access mode ('tool-access', 'read-only', or 'no-read'); when absent the builder derives 'no-read' from inline-context presence, else 'tool-access'."),
+                    ]),
+                },
+                schemaTarget: {
+                    kind: 'structured_json',
+                    schemaBuilder: 'buildPlanReviewerSchema',
+                    parser: 'PlanReviewerPayload',
+                    providerSurface: 'neal_json_block_protocol',
+                },
+            },
+            {
+                kind: 'derived_plan',
+                status: 'migration_target',
+                description: 'Derived-plan review after split-plan recovery.',
+                currentRoundEntrypoints: ['runPlanReviewerRound(mode=derived-plan)'],
+                baseInstructions: {
+                    kind: 'builder',
+                    modulePath: 'src/neal/prompts/planning.ts',
+                    exportName: 'buildPlanReviewerPrompt',
+                    inputShape: context('BuildPlanReviewerPromptDerivedArgs', [
+                        field('planDoc', 'prompt_argument', true, 'Path to the derived plan artifact under review.'),
+                        field('parentPlanDoc', 'prompt_argument', false, 'Path to the parent plan artifact.'),
+                        field('derivedFromScopeNumber', 'orchestrator_state', false, 'Parent scope number that the derived plan replaces.'),
+                        field('inlineContext', 'repository_state', false, "Optional Neal-inlined derived-plan/parent-plan/review-history context; only valid with the 'no-read' access mode, whose prompt contains no repository-access instructions."),
+                        field('accessMode', 'orchestrator_state', false, "Optional explicit doctrine access mode ('tool-access', 'read-only', or 'no-read'); when absent the builder derives 'no-read' from inline-context presence, else 'tool-access'."),
+                    ]),
+                },
+                schemaTarget: {
+                    kind: 'structured_json',
+                    schemaBuilder: 'buildPlanReviewerSchema',
+                    parser: 'PlanReviewerPayload',
+                    providerSurface: 'neal_json_block_protocol',
+                },
+            },
+        ],
+    },
+    {
+        id: 'scope_coder',
+        role: 'coder',
+        purpose: 'Execute exactly one bounded implementation scope and respond to in-scope review feedback without starting new scopes.',
+        requiredContext: SCOPE_CODER_CONTEXT,
+        schemaTarget: {
+            kind: 'structured_json',
+            schemaBuilder: 'buildCoderScopeSchema',
+            parser: 'validateCoderScopePayload',
+            providerSurface: 'neal_json_block_protocol',
+        },
+        baseInstructions: {
+            kind: 'builder',
+            modulePath: 'src/neal/prompts/execute.ts',
+            exportName: 'buildScopePrompt',
+            inputShape: context('BuildScopePromptArgs', [
+                field('planDoc', 'prompt_argument', true, 'Path to the active execute-mode plan.'),
+                field('progressText', 'run_artifact', true, 'Current Neal progress markdown.'),
+            ]),
+        },
+        providerVariants: SHARED_PROVIDER_VARIANTS,
+        evaluationNotes: [
+            'Render tests should assert structured execution envelope, progress-justification field requirements, and manual-gate instructions.',
+            'Future fixture cases should cover split-plan responses, manual-gate checks, and response-round schema invariants.',
+        ],
+        firstMigrationPriority: 2,
+        currentHome: 'mixed',
+        ownershipNotes: [
+            'Prompt spec owns execute-scope instructions, not state transitions, commit adoption, or blocked-recovery routing.',
+            'Blocked recovery stays as a capability variant rather than a separate top-level role id in v1.',
+        ],
+        variants: [
+            {
+                kind: 'primary',
+                status: 'migration_target',
+                description: 'Initial execute-scope coder round.',
+                currentRoundEntrypoints: ['runCoderScopeRound'],
+                baseInstructions: {
+                    kind: 'builder',
+                    modulePath: 'src/neal/prompts/execute.ts',
+                    exportName: 'buildScopePrompt',
+                    inputShape: context('BuildScopePromptArgs', [
+                        field('planDoc', 'prompt_argument', true, 'Path to the active execute-mode plan.'),
+                        field('progressText', 'run_artifact', true, 'Current Neal progress markdown.'),
+                    ]),
+                },
+                schemaTarget: {
+                    kind: 'structured_json',
+                    schemaBuilder: 'buildCoderScopeSchema',
+                    parser: 'validateCoderScopePayload',
+                    providerSurface: 'neal_json_block_protocol',
+                },
+            },
+            {
+                kind: 'response',
+                status: 'migration_target',
+                description: 'Reviewer-response round inside the same execute scope.',
+                currentRoundEntrypoints: ['runCoderResponseRound'],
+                baseInstructions: {
+                    kind: 'builder',
+                    modulePath: 'src/neal/prompts/execute.ts',
+                    exportName: 'buildCoderResponsePrompt',
+                    inputShape: context('BuildCoderResponsePromptArgs', [
+                        field('planDoc', 'prompt_argument', true, 'Path to the active execute-mode plan.'),
+                        field('progressText', 'run_artifact', true, 'Current Neal progress markdown.'),
+                        field('verificationHint', 'orchestrator_state', true, 'Wrapper-provided verification hint.'),
+                        field('openFindings', 'review_history', true, 'Open execute-review findings to address.'),
+                    ]),
+                },
+                schemaTarget: {
+                    kind: 'structured_json',
+                    schemaBuilder: 'buildCoderResponseSchema',
+                    parser: 'validateCoderResponsePayload',
+                    providerSurface: 'neal_json_block_protocol',
+                },
+            },
+            {
+                kind: 'response',
+                status: 'adjacent',
+                description: 'Interactive blocked-recovery response round.',
+                currentRoundEntrypoints: ['runBlockedRecoveryCoderRound'],
+                baseInstructions: {
+                    kind: 'builder',
+                    modulePath: 'src/neal/agents/prompts.ts',
+                    exportName: 'buildBlockedRecoveryCoderPrompt',
+                    inputShape: context('BuildBlockedRecoveryCoderPromptArgs', [
+                        field('planDoc', 'prompt_argument', true, 'Path to the active execute-mode plan.'),
+                        field('progressText', 'run_artifact', true, 'Current Neal progress markdown.'),
+                        field('recoveryMarkdownPath', 'run_artifact', true, 'Interactive blocked-recovery history artifact path.'),
+                        field('blockedReason', 'orchestrator_state', true, 'Current blocked reason.'),
+                        field('operatorGuidance', 'operator_input', true, 'Latest operator guidance.'),
+                    ]),
+                },
+                schemaTarget: {
+                    kind: 'structured_json',
+                    schemaBuilder: 'buildCoderBlockedRecoveryDispositionSchema',
+                    parser: 'validateCoderBlockedRecoveryDispositionPayload',
+                    providerSurface: 'neal_json_block_protocol',
+                },
+            },
+        ],
+    },
+    {
+        id: 'scope_reviewer',
+        role: 'reviewer',
+        purpose: 'Review execute-scope results for correctness, verification coverage, and meaningful progress toward the active parent objective.',
+        requiredContext: SCOPE_REVIEWER_CONTEXT,
+        schemaTarget: {
+            kind: 'structured_json',
+            schemaBuilder: 'buildReviewerSchema',
+            parser: 'ReviewerPayload',
+            providerSurface: 'neal_json_block_protocol',
+        },
+        baseInstructions: {
+            kind: 'builder',
+            modulePath: 'src/neal/prompts/execute.ts',
+            exportName: 'buildReviewerPrompt',
+            inputShape: context('BuildReviewerPromptArgs', [
+                field('planDoc', 'prompt_argument', true, 'Path to the active execute-mode plan.'),
+                field('baseCommit', 'orchestrator_state', true, 'Commit range base.'),
+                field('headCommit', 'orchestrator_state', true, 'Commit range head.'),
+                field('commits', 'orchestrator_state', true, 'Commits produced in the current scope.'),
+                field('round', 'orchestrator_state', true, 'Review round number.'),
+                field('reviewMarkdownPath', 'run_artifact', true, 'Review history artifact path.'),
+                field('progressJustification', 'review_history', true, 'Coder progress-justification payload.'),
+                field('scratchDir', 'run_artifact', true, 'Run-local scratch directory for reviewer verification artifacts.'),
+            ]),
+        },
+        providerVariants: SHARED_PROVIDER_VARIANTS,
+        evaluationNotes: [
+            'Render tests should assert reviewer prompts include shared adversarial falsification, verification skepticism, concrete finding-quality doctrine, meaningful-progress instructions, and parent-objective history.',
+            'Future fixture cases should cover cases where local correctness differs from parent-objective convergence.',
+        ],
+        firstMigrationPriority: 2,
+        currentHome: 'src/neal/prompts',
+        ownershipNotes: [
+            'Meaningful-progress remains a capability variant of scope review in v1 rather than its own top-level prompt spec.',
+            'Reviewer loop sequencing and acceptance transitions stay outside the prompt-spec library.',
+        ],
+        variants: [
+            {
+                kind: 'primary',
+                status: 'migration_target',
+                description: 'Execute-scope review round.',
+                currentRoundEntrypoints: ['runReviewerRound'],
+                baseInstructions: {
+                    kind: 'builder',
+                    modulePath: 'src/neal/prompts/execute.ts',
+                    exportName: 'buildReviewerPrompt',
+                    inputShape: context('BuildReviewerPromptArgs', [
+                        field('planDoc', 'prompt_argument', true, 'Path to the active execute-mode plan.'),
+                        field('baseCommit', 'orchestrator_state', true, 'Commit range base.'),
+                        field('headCommit', 'orchestrator_state', true, 'Commit range head.'),
+                        field('commits', 'orchestrator_state', true, 'Commits produced in the current scope.'),
+                        field('reviewMarkdownPath', 'run_artifact', true, 'Review history artifact path.'),
+                        field('parentScopeLabel', 'orchestrator_state', true, 'Active parent objective label.'),
+                        field('scratchDir', 'run_artifact', true, 'Run-local scratch directory for reviewer verification artifacts.'),
+                        field('inlineContext', 'repository_state', false, "Optional Neal-inlined diff/plan/review-history context; only valid with the 'no-read' access mode, whose prompt contains no repository-access instructions."),
+                        field('accessMode', 'orchestrator_state', false, "Optional explicit doctrine access mode ('tool-access', 'read-only', or 'no-read'); when absent the builder derives 'no-read' from inline-context presence, else 'tool-access'."),
+                    ]),
+                },
+                schemaTarget: {
+                    kind: 'structured_json',
+                    schemaBuilder: 'buildReviewerSchema',
+                    parser: 'ReviewerPayload',
+                    providerSurface: 'neal_json_block_protocol',
+                },
+            },
+            {
+                kind: 'meaningful_progress',
+                status: 'migration_target',
+                description: 'Meaningful-progress capability layered onto execute review, including ordinary accept, top-level already-satisfied accept, block_for_operator, replace_plan, and the empty derived-scope advance_parent action.',
+                currentRoundEntrypoints: ['runReviewerRound'],
+                baseInstructions: {
+                    kind: 'builder',
+                    modulePath: 'src/neal/prompts/execute.ts',
+                    exportName: 'buildReviewerPrompt',
+                    inputShape: context('BuildReviewerPromptMeaningfulProgressArgs', [
+                        field('progressJustification', 'review_history', true, 'Coder progress-justification payload.'),
+                        field('recentHistorySummary', 'review_history', true, 'Accepted scope history for the active parent objective.'),
+                    ]),
+                },
+                schemaTarget: {
+                    kind: 'structured_json',
+                    schemaBuilder: 'buildReviewerSchema',
+                    parser: 'ReviewerPayload',
+                    providerSurface: 'neal_json_block_protocol',
+                },
+            },
+        ],
+    },
+    {
+        id: 'completion_coder',
+        role: 'coder',
+        purpose: 'Summarize whole-plan completion state in compact structured JSON.',
+        requiredContext: COMPLETION_CODER_CONTEXT,
+        schemaTarget: {
+            kind: 'structured_json',
+            schemaBuilder: 'buildFinalCompletionSummarySchema',
+            parser: 'parseFinalCompletionSummaryPayload',
+            providerSurface: 'neal_json_block_protocol',
+        },
+        baseInstructions: {
+            kind: 'builder',
+            modulePath: 'src/neal/prompts/specialized.ts',
+            exportName: 'buildFinalCompletionSummaryPrompt',
+            inputShape: context('BuildFinalCompletionSummaryPromptArgs', [
+                field('planDoc', 'prompt_argument', true, 'Path to the execute-mode plan.'),
+                field('packet', 'orchestrator_state', true, 'Whole-plan completion packet.'),
+            ]),
+        },
+        providerVariants: SHARED_PROVIDER_VARIANTS,
+        evaluationNotes: [
+            'Render tests should assert the prompt requires JSON-only output and completion packet context.',
+        ],
+        firstMigrationPriority: 3,
+        currentHome: 'src/neal/prompts',
+        ownershipNotes: [
+            'Whole-plan completion summary is prompt-local; completion transitions remain outside the prompt-spec library.',
+        ],
+        variants: [
+            {
+                kind: 'final_completion',
+                status: 'migration_target',
+                description: 'Whole-plan completion summary round.',
+                currentRoundEntrypoints: ['runCoderFinalCompletionSummaryRound'],
+                baseInstructions: {
+                    kind: 'builder',
+                    modulePath: 'src/neal/prompts/specialized.ts',
+                    exportName: 'buildFinalCompletionSummaryPrompt',
+                    inputShape: context('BuildFinalCompletionSummaryPromptArgs', [
+                        field('planDoc', 'prompt_argument', true, 'Path to the execute-mode plan.'),
+                        field('packet', 'orchestrator_state', true, 'Whole-plan completion packet.'),
+                    ]),
+                },
+                schemaTarget: {
+                    kind: 'structured_json',
+                    schemaBuilder: 'buildFinalCompletionSummarySchema',
+                    parser: 'parseFinalCompletionSummaryPayload',
+                    providerSurface: 'neal_json_block_protocol',
+                },
+            },
+        ],
+    },
+    {
+        id: 'completion_reviewer',
+        role: 'reviewer',
+        purpose: 'Judge whole-plan completion and decide whether Neal should accept completion, continue execution, or block for operator input.',
+        requiredContext: COMPLETION_REVIEWER_CONTEXT,
+        schemaTarget: {
+            kind: 'structured_json',
+            schemaBuilder: 'buildFinalCompletionReviewerSchema',
+            parser: 'parseFinalCompletionReviewerPayload',
+            providerSurface: 'neal_json_block_protocol',
+        },
+        baseInstructions: {
+            kind: 'builder',
+            modulePath: 'src/neal/prompts/specialized.ts',
+            exportName: 'buildFinalCompletionReviewerPrompt',
+            inputShape: context('BuildFinalCompletionReviewerPromptArgs', [
+                field('planDoc', 'prompt_argument', true, 'Path to the execute-mode plan.'),
+                field('packet', 'orchestrator_state', true, 'Whole-plan completion packet.'),
+                field('summary', 'review_history', true, 'Coder-authored completion summary.'),
+                field('scratchDir', 'run_artifact', true, 'Run-local scratch directory for final-completion reviewer artifacts.'),
+            ]),
+        },
+        providerVariants: SHARED_PROVIDER_VARIANTS,
+        evaluationNotes: [
+            'Render tests should assert the reviewer prompt requires shared adversarial doctrine, aggregate range context, and one of the three structured completion actions.',
+        ],
+        firstMigrationPriority: 3,
+        currentHome: 'src/neal/prompts',
+        ownershipNotes: [
+            'Final completion review is plan-review-adjacent in the later adjudicator design, but prompt ownership remains separate from transition semantics.',
+        ],
+        variants: [
+            {
+                kind: 'final_completion',
+                status: 'migration_target',
+                description: 'Whole-plan final completion review round.',
+                currentRoundEntrypoints: ['runReviewerFinalCompletionRound'],
+                baseInstructions: {
+                    kind: 'builder',
+                    modulePath: 'src/neal/prompts/specialized.ts',
+                    exportName: 'buildFinalCompletionReviewerPrompt',
+                    inputShape: context('BuildFinalCompletionReviewerPromptArgs', [
+                        field('planDoc', 'prompt_argument', true, 'Path to the execute-mode plan.'),
+                        field('packet', 'orchestrator_state', true, 'Whole-plan completion packet.'),
+                        field('summary', 'review_history', true, 'Coder-authored completion summary.'),
+                        field('scratchDir', 'run_artifact', true, 'Run-local scratch directory for final-completion reviewer artifacts.'),
+                        field('inlineContext', 'repository_state', false, "Optional Neal-inlined aggregate-diff/plan context; only valid with the 'no-read' access mode, whose prompt contains no repository-access instructions."),
+                        field('accessMode', 'orchestrator_state', false, "Optional explicit doctrine access mode ('tool-access', 'read-only', or 'no-read'); when absent the builder derives 'no-read' from inline-context presence, else 'tool-access'."),
+                    ]),
+                },
+                schemaTarget: {
+                    kind: 'structured_json',
+                    schemaBuilder: 'buildFinalCompletionReviewerSchema',
+                    parser: 'parseFinalCompletionReviewerPayload',
+                    providerSurface: 'neal_json_block_protocol',
+                },
+            },
+        ],
+    },
+];
+function getContractFieldKeys(contract) {
+    return new Set(contract.fields.map((field) => field.key));
+}
+function validateBuilderInputShape(spec, builder, label) {
+    const allowedKeys = getContractFieldKeys(spec.requiredContext);
+    const extraKeys = builder.inputShape.fields.map((field) => field.key).filter((key) => !allowedKeys.has(key));
+    if (extraKeys.length > 0) {
+        throw new Error(`Prompt spec ${spec.id} ${label} references builder context keys missing from requiredContext: ${extraKeys.join(', ')}`);
+    }
+}
+function validatePromptSpecContracts(specs) {
+    for (const spec of specs) {
+        validateBuilderInputShape(spec, spec.baseInstructions, 'baseInstructions');
+        for (const variant of spec.variants) {
+            validateBuilderInputShape(spec, variant.baseInstructions, `variant ${variant.kind}/${variant.baseInstructions.exportName}`);
+        }
+    }
+}
+validatePromptSpecContracts(PROMPT_SPECS);
+const PROMPT_SPEC_MAP = new Map(PROMPT_SPECS.map((spec) => [spec.id, spec]));
+export function getPromptSpec(id) {
+    const spec = PROMPT_SPEC_MAP.get(id);
+    if (!spec) {
+        throw new Error(`Unknown prompt spec: ${id}`);
+    }
+    return spec;
+}