frontend-harness 0.1.0 → 0.2.1

package/dist/runtime/plan.js

@@ -1,23 +1,29 @@
 import fs from "node:fs";
-import path from "node:path";
 import { harnessPath, relativeHarnessPath } from "../storage/paths.js";
 import { writeJson, writeText } from "../storage/json.js";
 import { updatePlannedState } from "./state.js";
-import { resolveComponentPlacement } from "./project-discovery.js";
 import { buildComponentGraph } from "./graph.js";
 import { resolveProjectRelativePath } from "./project-paths.js";
 import { buildPolicyProvenance } from "./policy-provenance.js";
+import { discoverVerificationCommands } from "./verification-commands.js";
+import { inferPlanComponents, resolveComponentSource, resolvePlanComponents } from "./plan/component-resolver.js";
+import { buildExecutionGuidance, renderGuidance } from "./plan/guidance.js";
+import { readAgentPlanningProposal } from "./plan/proposal.js";
+import { inferFrontendWorkflow, inferTaskIntent, verificationForWorkflow } from "./plan/workflow.js";
+import { unitIdFromName } from "./common/naming.js";
 export function createPlan(projectRoot, input) {
     if (!input.taskText.trim()) {
         throw new Error("plan requires a task");
     }
     const normalizedInput = normalizePlanInput(projectRoot, input);
-    const task = understandTask(projectRoot, normalizedInput);
-    const components = inferComponents(projectRoot, task);
-    const units = buildExecutionUnits(components, task);
+    const proposal = normalizedInput.agentProposal ? readAgentPlanningProposal(projectRoot, normalizedInput.agentProposal) : null;
+    const task = understandTask(projectRoot, normalizedInput, proposal);
+    const resolved = resolvePlan(projectRoot, task, proposal);
+    const components = resolved.components;
+    const units = buildExecutionUnits(projectRoot, components, task, proposal);
     const componentGraph = buildComponentGraph(components, units);
     const executionGuidance = buildExecutionGuidance();
-    const guidance = renderGuidance(task, components, units, executionGuidance);
+    const guidance = renderGuidance(task, components, units, executionGuidance, resolved.meta);
     const output = {
         task,
         components,
@@ -25,7 +31,8 @@ export function createPlan(projectRoot, input) {
         executionGuidance,
         componentGraphPath: relativeHarnessPath("component-graph", "latest.json"),
         guidancePath: relativeHarnessPath("guidance", "latest.md"),
-        statePath: relativeHarnessPath("state.json")
+        statePath: relativeHarnessPath("state.json"),
+        meta: resolved.meta
     };
     writeJson(harnessPath(projectRoot, "plans", "latest.json"), output);
     writeJson(harnessPath(projectRoot, "execution-units", "latest.json"), {
@@ -33,22 +40,23 @@ export function createPlan(projectRoot, input) {
     });
     writeJson(harnessPath(projectRoot, "component-graph", "latest.json"), componentGraph);
     writeText(harnessPath(projectRoot, "guidance", "latest.md"), guidance);
-    updatePlannedState(projectRoot, task, components, units);
+    updatePlannedState(projectRoot, task, components, units, highSeverityAmbiguityBlockers(proposal));
     return output;
 }
-export function checkAgentPlanningDecision(projectRoot, file) {
+export function checkAgentPlanningProposal(projectRoot, file) {
     if (!file) {
-        throw new Error("decision check requires --file <agent-decision.json>");
+        throw new Error("proposal check requires --file <agent-proposal.json>");
     }
     const artifactPath = file;
     try {
-        const relativePath = validateRequiredReferencedFile(projectRoot, file, "agent decision");
-        const decision = readAgentPlanningDecision(projectRoot, relativePath);
+        const relativePath = validateRequiredReferencedFile(projectRoot, file, "agent proposal");
+        const proposal = readAgentPlanningProposal(projectRoot, relativePath);
+        validateProposalTargets(projectRoot, proposal);
         return {
             status: "passed",
             artifactPath: relativePath,
-            contractVersion: decision.contractVersion ?? null,
-            decision,
+            contractVersion: proposal.contractVersion ?? null,
+            proposal,
             errors: []
         };
     }
@@ -57,7 +65,7 @@ export function checkAgentPlanningDecision(projectRoot, file) {
             status: "failed",
             artifactPath,
             contractVersion: null,
-            decision: null,
+            proposal: null,
             errors: [error instanceof Error ? error.message : String(error)]
         };
     }
@@ -67,7 +75,7 @@ function normalizePlanInput(projectRoot, input) {
         taskText: input.taskText,
         ...optionalString("prd", validateReferencedFile(projectRoot, input.prd, "PRD")),
         ...optionalString("ui", validateReferencedFile(projectRoot, input.ui, "UI")),
-        ...optionalString("agentDecision", validateReferencedFile(projectRoot, input.agentDecision, "agent decision"))
+        ...optionalString("agentProposal", validateReferencedFile(projectRoot, input.agentProposal, "agent proposal"))
     };
 }
 function validateRequiredReferencedFile(projectRoot, file, label) {
@@ -83,14 +91,11 @@ function validateReferencedFile(projectRoot, file, label) {
     }
     return relativePath;
 }
-function understandTask(projectRoot, input) {
+function understandTask(projectRoot, input, proposal) {
     const text = input.taskText.trim();
-    const decision = input.agentDecision
-        ? readAgentPlanningDecision(projectRoot, input.agentDecision)
-        : null;
     const scope = text;
-    const decisionConstraints = decision?.constraintHints ?? [];
-    const frontendWorkflow = inferFrontendWorkflow(scope, input);
+    const proposalConstraints = proposal?.constraintHints ?? [];
+    const frontendWorkflow = inferFrontendWorkflow(scope, input, proposal);
     const intent = inferTaskIntent(scope, frontendWorkflow.kind);
     return {
         intent,
@@ -98,206 +103,116 @@ function understandTask(projectRoot, input) {
         constraints: [
             "Use the agent-invoked harness loop.",
             "CLI owns project facts and verification.",
-            "System owns deterministic planning; agent planning input is limited to bounded hints.",
+            "System owns final planning decisions; agent proposals are bounded inputs resolved through policy.",
             ...frontendWorkflow.implementationConstraints,
-            ...decisionConstraints
+            ...proposalConstraints
         ],
         frontendWorkflow,
         policyProvenance: buildPolicyProvenance(projectRoot, scope, frontendWorkflow.kind),
         inputs: {
             ...(input.prd ? { prd: input.prd } : {}),
             ...(input.ui ? { ui: input.ui } : {}),
-            ...(input.agentDecision ? { agentDecision: input.agentDecision } : {})
+            ...(input.agentProposal ? { agentProposal: input.agentProposal } : {})
         },
-        ...buildAgentPlanningMetadata(input.agentDecision, decision)
+        ...buildAgentPlanningMetadata(input.agentProposal, proposal)
     };
 }
-function inferTaskIntent(scope, workflowKind) {
-    const normalized = scope.toLowerCase();
-    if (workflowKind === "bug_fix" || /\b(fix|bug)\b|缺陷|修复|错误|报错/.test(normalized)) {
-        return "fix_bug";
-    }
-    if (/\brefactor\b|重构/.test(normalized)) {
-        return "refactor";
-    }
-    if (workflowKind === "frontend_test" || /\b(test|e2e|playwright|vitest)\b|测试|端到端|集成测试/.test(normalized)) {
-        return "add_test";
-    }
-    return "implement_page";
-}
-function buildAgentPlanningMetadata(decisionPath, decision) {
-    if (!decisionPath) {
+function buildAgentPlanningMetadata(proposalPath, proposal) {
+    if (!proposalPath) {
         return {
             reasoningMode: "deterministic"
         };
     }
     return {
         reasoningMode: "agent_assisted",
-        agentDecision: {
-            summary: buildAgentDecisionSummary(decisionPath),
-            artifactPath: decisionPath ?? null,
-            contractVersion: decision?.contractVersion ?? null,
-            intentSuggestion: decision?.intentSuggestion ?? null,
-            ...(decision?.constraintHints ? { constraintHints: decision.constraintHints } : {}),
-            ...(decision?.componentHints ? { componentHints: decision.componentHints } : {})
+        agentProposal: {
+            summary: buildAgentProposalSummary(proposalPath),
+            artifactPath: proposalPath ?? null,
+            contractVersion: proposal?.contractVersion ?? null,
+            intentSuggestion: proposal?.intentSuggestion ?? null,
+            ...(proposal?.constraintHints ? { constraintHints: proposal.constraintHints } : {}),
+            ...(proposal?.componentHints ? { componentHints: proposal.componentHints } : {}),
+            ...(proposal?.planningEvidence ? { planningEvidence: proposal.planningEvidence } : {})
         }
     };
 }
-function buildAgentDecisionSummary(decisionPath) {
-    return decisionPath
-        ? `Planning uses structured decision input from ${decisionPath}.`
-        : "Planning uses structured decision input.";
-}
-function inferComponents(projectRoot, task) {
-    const baseName = toPascalCase(task.scope) || "PlannedComponent";
-    const placement = resolveComponentPlacement(projectRoot, task.scope);
-    const componentKinds = inferComponentKinds(task.scope);
-    return componentKinds.map((kind) => {
-        const name = componentName(baseName, kind.suffix);
-        return {
-            name,
-            file: `${placement.sourceRoot}/${name}${placement.extension}`,
-            responsibility: task.intent === "fix_bug" ? "bug fix target" : kind.responsibility,
-            status: "unknown"
-        };
-    });
-}
-function inferComponentKinds(scope) {
-    const normalized = scope.toLowerCase();
-    const asksForTable = /\b(table|grid|list)\b/.test(normalized);
-    const asksForForm = /\b(form|create|edit|filter|search)\b/.test(normalized);
-    const asksForPage = /\b(page|screen|dashboard|view)\b/.test(normalized);
-    if (asksForPage && asksForTable && asksForForm) {
-        return [
-            {
-                suffix: "Page",
-                responsibility: "page composition and data-flow boundary"
-            },
-            {
-                suffix: "Table",
-                responsibility: "tabular list rendering"
+function buildAgentProposalSummary(proposalPath) {
+    return proposalPath
+        ? `Planning resolves structured agent proposal input from ${proposalPath}.`
+        : "Planning resolves structured agent proposal input.";
+}
+function resolvePlan(projectRoot, task, proposal) {
+    const evidenceTargets = validateProposalTargets(projectRoot, proposal);
+    const systemComponents = inferPlanComponents(projectRoot, task, evidenceTargets);
+    const warnings = [];
+    const resolvedComponents = resolvePlanComponents(projectRoot, systemComponents, proposal?.componentHints, task, warnings);
+    const components = resolvedComponents.components;
+    const workflowEvidence = acceptedWorkflowEvidence(task.frontendWorkflow?.kind, proposal?.planningEvidence);
+    const componentSource = resolveComponentSource(resolvedComponents.trace);
+    return {
+        components,
+        meta: {
+            decisionTrace: {
+                workflow: {
+                    source: workflowEvidence.accepted ? "agent" : "system",
+                    reason: workflowEvidence.accepted
+                        ? `agent planningEvidence workflow accepted: ${task.frontendWorkflow?.kind}`
+                        : `system classified workflow as ${task.frontendWorkflow?.kind ?? "unknown"}`
+                },
+                targets: {
+                    source: evidenceTargets.length ? "merged" : "system",
+                    reason: evidenceTargets.length
+                        ? "safe agent planningEvidence targetCandidates were merged into planning boundaries"
+                        : "system inferred planning boundary"
+                },
+                components: {
+                    source: componentSource,
+                    reason: componentSource === "system"
+                        ? "system component boundaries retained"
+                        : componentSource === "agent"
+                            ? "agent componentHints expanded the UI boundary"
+                            : "agent componentHints merged into system UI boundary"
+                },
+                componentHints: resolvedComponents.trace,
+                ...(proposal?.planningEvidence
+                    ? {
+                        agentEvidence: {
+                            source: "merged",
+                            reason: describePlanningEvidence(proposal.planningEvidence)
+                        }
+                    }
+                    : {})
             },
-            {
-                suffix: "Form",
-                responsibility: "form or filter interaction"
-            }
-        ];
-    }
-    return [
-        {
-            suffix: "",
-            responsibility: "planned UI/component implementation"
-        }
-    ];
-}
-function inferFrontendWorkflow(scope, input) {
-    const normalized = scope.toLowerCase();
-    const hasUiSource = Boolean(input.ui) || /\b(ui|stitch|figma|html|design|page|screen|component|view|dashboard)\b|页面|界面|组件|视图|看板|设计稿/.test(normalized);
-    const hasPrdSource = Boolean(input.prd) || /\b(prd|product|requirement|requirements|knowledge|document)\b|产品|需求|知识库|文档/.test(normalized);
-    const hasBugSignal = /\b(bug|fix|regression|error)\b|缺陷|修复|错误|报错/.test(normalized);
-    const hasTestSignal = /\b(e2e|integration test|test|playwright|vitest)\b|测试|端到端|集成测试/.test(normalized);
-    const hasApiSignal = /\b(api|swagger|endpoint|interface|request|dto)\b|接口|请求|对接|联调/.test(normalized);
-    const hasRequirementChange = /\b(requirement changes?|changed [a-z0-9 -]*requirements?|update [a-z0-9 -]*requirements?|sync [a-z0-9 -]*requirements?)\b|需求变更|变更需求|需求[^，。,.]*同步|同步[^，。,.]*需求/.test(normalized);
-    const kind = hasBugSignal
-        ? "bug_fix"
-        : hasRequirementChange
-            ? "requirement_change"
-            : hasTestSignal
-                ? "frontend_test"
-                : hasApiSignal
-                    ? "api_integration"
-                    : hasPrdSource && !hasUiSource
-                        ? "prd_knowledge"
-                        : "ui_implementation";
-    return workflowPolicy(kind, { hasPrdSource, hasUiSource });
-}
-function workflowPolicy(kind, inputSignals) {
-    const policies = {
-        ui_implementation: {
-            kind,
-            summary: "Implement or adapt frontend UI while preserving project semantics, component boundaries, and validation evidence.",
-            requiredKnowledgeActions: inputSignals.hasUiSource
-                ? ["Capture reusable UI semantics, component responsibilities, and design assumptions in project knowledge when they affect future work."]
-                : ["Reuse existing project knowledge before inventing new UI semantics."],
-            implementationConstraints: [
-                "Treat imported MCP/Stitch/Figma/HTML output as source material, not project-ready code.",
-                "Normalize generated UI into project components, naming, state, routing, and styling conventions."
-            ],
-            verificationFocus: ["typecheck", "component behavior", "responsive rendering", "visual regressions when UI source is provided"]
-        },
-        prd_knowledge: {
-            kind,
-            summary: "Convert PRD or requirement material into durable project knowledge before implementation.",
-            requiredKnowledgeActions: [
-                "Promote stable product concepts, terminology, permissions, workflows, and acceptance rules into .frontend-harness/knowledge/.",
-                "Keep raw PRD text separate from distilled project knowledge."
-            ],
-            implementationConstraints: [
-                "Do not implement product behavior until PRD-derived assumptions are explicit.",
-                "Mark unknown product decisions as blockers or assumptions instead of guessing."
-            ],
-            verificationFocus: ["knowledge coverage", "acceptance criteria traceability", "terminology consistency"]
-        },
-        api_integration: {
-            kind,
-            summary: "Integrate frontend behavior with API contracts using project knowledge plus Swagger/API evidence.",
-            requiredKnowledgeActions: [
-                "Reference relevant domain knowledge before mapping request parameters, DTOs, and response states.",
-                "Promote durable API assumptions when Swagger or backend behavior clarifies product rules."
-            ],
-            implementationConstraints: [
-                "Do not invent API fields, enum values, pagination contracts, or error shapes.",
-                "Keep request mapping, loading, empty, and error states inside the project API/state conventions."
-            ],
-            verificationFocus: ["typecheck", "API mapping", "loading/empty/error states", "integration tests or mocks"]
-        },
-        frontend_test: {
-            kind,
-            summary: "Add or update frontend E2E/integration coverage for user-visible behavior.",
-            requiredKnowledgeActions: [
-                "Use project knowledge to choose behavior-level assertions instead of implementation-detail assertions.",
-                "Promote durable testing conventions only when they apply beyond the current task."
-            ],
-            implementationConstraints: [
-                "Prefer behavior-focused integration or E2E tests over brittle snapshot-only checks.",
-                "Keep fixtures and mocks aligned with known API/product contracts."
-            ],
-            verificationFocus: ["targeted test", "typecheck", "critical user path", "failure diagnostics"]
-        },
-        bug_fix: {
-            kind,
-            summary: "Fix a frontend bug with evidence, minimal scope, and regression coverage proportional to risk.",
-            requiredKnowledgeActions: [
-                "Check project knowledge for intended behavior before changing code.",
-                "Promote the resolved product or technical rule if the bug revealed durable knowledge."
-            ],
-            implementationConstraints: [
-                "Reproduce or explain the bug before patching when evidence is available.",
-                "Keep the fix scoped to the failing behavior and avoid unrelated refactors."
-            ],
-            verificationFocus: ["regression test", "typecheck", "affected workflow", "repair evidence"]
-        },
-        requirement_change: {
-            kind,
-            summary: "Apply requirement changes and keep implementation, tests, and knowledge synchronized.",
-            requiredKnowledgeActions: [
-                "Update project knowledge for changed product rules before or alongside code changes.",
-                "Record obsolete assumptions so future agents do not reuse stale behavior."
-            ],
-            implementationConstraints: [
-                "Identify impacted UI, API mapping, tests, and knowledge before editing.",
-                "Do not leave previous requirement behavior undocumented when it changes."
-            ],
-            verificationFocus: ["changed acceptance criteria", "knowledge sync", "affected regression tests", "typecheck"]
+            warnings
         }
     };
-    return policies[kind];
-}
-function componentName(baseName, suffix) {
-    return suffix && !baseName.endsWith(suffix) ? `${baseName}${suffix}` : baseName;
 }
-function buildExecutionUnits(components, task) {
-    const units = components.map((component) => toUnit(component, task));
+function validateProposalTargets(projectRoot, proposal) {
+    const evidenceTargets = (proposal?.planningEvidence?.targetCandidates ?? [])
+        .map((candidate, index) => ({
+        path: candidate.path,
+        confidence: candidate.confidence,
+        label: `agent proposal planningEvidence.targetCandidates[${index}].path`
+    }));
+    const safeTargets = evidenceTargets.map((target) => ({
+        path: resolveProjectRelativePath(projectRoot, target.path, target.label).relativePath,
+        confidence: target.confidence
+    }));
+    return [...new Set(safeTargets
+            .filter((target) => target.confidence >= 0.7)
+            .map((target) => target.path))];
+}
+function describePlanningEvidence(evidence) {
+    return [
+        `${evidence.workflowCandidates?.length ?? 0} workflow candidate(s)`,
+        `${evidence.targetCandidates?.length ?? 0} target candidate(s)`,
+        `${evidence.verificationCandidates?.length ?? 0} verification candidate(s)`,
+        `${evidence.ambiguities?.length ?? 0} ambiguity item(s)`
+    ].join(", ");
+}
+function buildExecutionUnits(projectRoot, components, task, proposal) {
+    const verification = resolveVerificationFocus(projectRoot, task, proposal);
+    const units = components.map((component) => toUnit(component, task, verification));
     const pageUnit = units.find((unit) => unit.id.endsWith("-page"));
     if (pageUnit && units.length > 1) {
         pageUnit.dependsOn = units
@@ -306,266 +221,69 @@ function buildExecutionUnits(components, task) {
     }
     return units;
 }
-function toUnit(component, task) {
+function toUnit(component, task, verification) {
     return {
         id: unitIdFromName(component.name),
         file: component.file,
         task: `${task.intent}: ${task.scope}`,
-        verification: verificationForWorkflow(task.frontendWorkflow?.kind),
+        verification,
         dependsOn: [],
         parallelGroup: null
     };
 }
-function verificationForWorkflow(kind) {
-    if (kind === "frontend_test") {
-        return ["targeted test", "typecheck"];
-    }
-    if (kind === "bug_fix") {
-        return ["regression test", "typecheck"];
-    }
-    if (kind === "api_integration") {
-        return ["typecheck", "integration test or API mock"];
-    }
-    if (kind === "requirement_change") {
-        return ["typecheck", "affected regression test"];
-    }
-    if (kind === "prd_knowledge") {
-        return ["knowledge review"];
-    }
-    return ["typecheck"];
-}
-function readAgentPlanningDecision(projectRoot, file) {
-    const fullPath = path.resolve(projectRoot, file);
-    let parsed;
-    try {
-        parsed = JSON.parse(fs.readFileSync(fullPath, "utf8"));
-    }
-    catch (error) {
-        const detail = error instanceof Error ? error.message : String(error);
-        throw new Error(`agent decision file must contain valid JSON: ${file}: ${detail}`);
-    }
-    return parseAgentPlanningDecision(parsed, file);
-}
-function parseAgentPlanningDecision(value, file) {
-    if (!isRecord(value) || Array.isArray(value)) {
-        throw new Error(`agent decision file must contain a JSON object: ${file}`);
-    }
-    if ("decision" in value || "contractVersion" in value) {
-        return parseAgentPlanningDecisionEnvelope(value, file);
-    }
-    const allowedKeys = new Set(["intentSuggestion", "constraintHints", "componentHints"]);
-    return parseAgentPlanningDecisionObject(value, allowedKeys, "agent decision file");
+function resolveVerificationFocus(projectRoot, task, proposal) {
+    const base = verificationForWorkflow(task.frontendWorkflow?.kind);
+    const known = new Set([
+        "targeted test",
+        "regression test",
+        "integration test or API mock",
+        "affected regression test",
+        "knowledge review",
+        "documentation review",
+        "review findings",
+        ...discoverVerificationCommands(projectRoot)
+            .filter((command) => command.command)
+            .map((command) => command.name)
+    ]);
+    const evidence = (proposal?.planningEvidence?.verificationCandidates ?? [])
+        .map((candidate) => normalizeVerificationFocus(candidate.kind))
+        .filter((candidate) => candidate && known.has(candidate))
+        .slice(0, 10);
+    return [...new Set([...base, ...evidence])];
+}
+function normalizeVerificationFocus(value) {
+    const normalized = value.trim().toLowerCase().replace(/[_-]+/g, " ").replace(/\s+/g, " ");
+    const aliases = {
+        "targeted test": "targeted test",
+        "regression test": "regression test",
+        "integration test": "integration test or API mock",
+        "integration test or api mock": "integration test or API mock",
+        "api mock": "integration test or API mock",
+        "affected regression test": "affected regression test",
+        "knowledge review": "knowledge review",
+        "documentation review": "documentation review",
+        "review findings": "review findings",
+        "typecheck": "typecheck",
+        "test": "test",
+        "build": "build"
+    };
+    return aliases[normalized] ?? value.trim();
 }
-function parseAgentPlanningDecisionEnvelope(value, file) {
-    const allowedKeys = new Set(["contractVersion", "decision"]);
-    for (const key of Object.keys(value)) {
-        if (!allowedKeys.has(key)) {
-            throw new Error(`agent decision file contains unsupported field: ${key}`);
-        }
-    }
-    if (value["contractVersion"] !== 1) {
-        throw new Error("agent decision contractVersion must be 1");
-    }
-    if (!isRecord(value["decision"]) || Array.isArray(value["decision"])) {
-        throw new Error(`agent decision file decision must be a JSON object: ${file}`);
-    }
-    const decision = parseAgentPlanningDecisionObject(value["decision"], new Set(["intentSuggestion", "constraintHints", "componentHints"]), "agent decision file decision");
+function acceptedWorkflowEvidence(workflowKind, evidence) {
+    const candidates = [...(evidence?.workflowCandidates ?? [])].sort((left, right) => right.confidence - left.confidence);
+    const primary = candidates[0];
+    const runnerUp = candidates[1];
+    const margin = primary && runnerUp ? primary.confidence - runnerUp.confidence : primary?.confidence ?? 0;
     return {
-        contractVersion: 1,
-        ...decision
+        accepted: Boolean(primary && primary.kind === workflowKind && primary.confidence >= 0.75 && margin >= 0.2)
     };
 }
-function parseAgentPlanningDecisionObject(value, allowedKeys, label) {
-    for (const key of Object.keys(value)) {
-        if (!allowedKeys.has(key)) {
-            throw new Error(`${label} contains unsupported field: ${key}`);
-        }
-    }
-    const decision = {};
-    if (value["intentSuggestion"] !== undefined) {
-        decision.intentSuggestion = parseBoundedString(value["intentSuggestion"], "intentSuggestion");
-    }
-    if (value["constraintHints"] !== undefined) {
-        decision.constraintHints = parseStringArray(value["constraintHints"], "constraintHints");
-    }
-    if (value["componentHints"] !== undefined) {
-        decision.componentHints = parseComponentHints(value["componentHints"]);
-    }
-    return decision;
-}
-function parseStringArray(value, label) {
-    if (!Array.isArray(value)) {
-        throw new Error(`agent decision ${label} must be an array of strings`);
-    }
-    if (value.length > 10) {
-        throw new Error(`agent decision ${label} cannot contain more than 10 items`);
-    }
-    return value.map((item, index) => parseBoundedString(item, `${label}[${index}]`));
-}
-function parseComponentHints(value) {
-    if (!Array.isArray(value)) {
-        throw new Error("agent decision componentHints must be an array");
-    }
-    if (value.length > 10) {
-        throw new Error("agent decision componentHints cannot contain more than 10 items");
-    }
-    return value.map((item, index) => {
-        if (!isRecord(item) || Array.isArray(item)) {
-            throw new Error(`agent decision componentHints[${index}] must be an object`);
-        }
-        const allowedKeys = new Set(["name", "responsibility"]);
-        for (const key of Object.keys(item)) {
-            if (!allowedKeys.has(key)) {
-                throw new Error(`agent decision componentHints[${index}] contains unsupported field: ${key}`);
-            }
-        }
-        return {
-            ...(item["name"] !== undefined ? { name: parseBoundedString(item["name"], `componentHints[${index}].name`) } : {}),
-            ...(item["responsibility"] !== undefined
-                ? { responsibility: parseBoundedString(item["responsibility"], `componentHints[${index}].responsibility`) }
-                : {})
-        };
-    });
+function highSeverityAmbiguityBlockers(proposal) {
+    return (proposal?.planningEvidence?.ambiguities ?? [])
+        .filter((ambiguity) => ambiguity.severity === "high")
+        .map((ambiguity) => `High-severity planning ambiguity: ${ambiguity.question}`);
 }
 function optionalString(key, value) {
     return value === undefined ? {} : { [key]: value };
 }
-function parseBoundedString(value, label) {
-    if (typeof value !== "string") {
-        throw new Error(`agent decision ${label} must be a string`);
-    }
-    const trimmed = value.trim();
-    if (!trimmed) {
-        throw new Error(`agent decision ${label} cannot be empty`);
-    }
-    if (trimmed.length > 500) {
-        throw new Error(`agent decision ${label} cannot exceed 500 characters`);
-    }
-    return trimmed;
-}
-function isRecord(value) {
-    return typeof value === "object" && value !== null;
-}
-function unitIdFromName(name) {
-    return `unit-${name.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase()}`;
-}
-function buildExecutionGuidance() {
-    return [
-        {
-            order: 1,
-            action: "inspect_plan",
-            description: `Read ${relativeHarnessPath("plans", "latest.json")} and ${relativeHarnessPath("execution-units", "latest.json")} before editing.`,
-            command: null,
-            condition: null
-        },
-        {
-            order: 2,
-            action: "edit_files",
-            description: "Edit only the project files required by the planned execution units.",
-            command: null,
-            condition: null
-        },
-        {
-            order: 3,
-            action: "record_changes",
-            description: "Record each changed project file so the harness state reflects the execution boundary.",
-            command: "frontend-harness state record-change <file>",
-            condition: "after editing"
-        },
-        {
-            order: 4,
-            action: "verify",
-            description: "Run the configured verification commands and inspect the JSON result.",
-            command: "frontend-harness verify --json",
-            condition: "after recording changes"
-        },
-        {
-            order: 5,
-            action: "fix_failed_verification",
-            description: `If verification fails, generate and inspect ${relativeHarnessPath("repair", "latest.json")} before patching the relevant project files, recording new changes, and rerunning verification.`,
-            command: "frontend-harness repair packet --json",
-            condition: "when verification status is failed or error"
-        }
-    ];
-}
-function renderGuidance(task, components, units, executionGuidance) {
-    return `# Agent Execution Guidance
-
-## Task
-
-- Intent: ${task.intent}
-- Scope: ${task.scope}
-
-## Frontend Workflow Policy
-
-- Kind: ${task.frontendWorkflow?.kind ?? "unknown"}
-- Summary: ${task.frontendWorkflow?.summary ?? "No workflow policy inferred."}
-- Knowledge: ${(task.frontendWorkflow?.requiredKnowledgeActions ?? []).join(" ")}
-- Verification focus: ${(task.frontendWorkflow?.verificationFocus ?? []).join(", ")}
-
-## Project References
-
-${renderProjectReferences(task)}
-
-## Loop
-
-${executionGuidance.map(renderExecutionGuidanceStep).join("\n")}
-
-## Components
-
-${components.map((component) => `- ${component.name}: ${component.file} (${component.responsibility})`).join("\n")}
-
-## Units
-
-${units.map(renderUnitGuidance).join("\n")}
-`;
-}
-function renderProjectReferences(task) {
-    const provenance = task.policyProvenance;
-    if (!provenance) {
-        return "- No project-local skills or knowledge selected.";
-    }
-    const lines = [];
-    if (provenance.skillRoutes.length) {
-        lines.push("Selected skills:");
-        for (const route of provenance.skillRoutes) {
-            lines.push(`- ${route.name}: ${route.path}; source: ${route.source}; score: ${route.score}; reasons: ${route.reasons.join(", ")}`);
-        }
-    }
-    else {
-        lines.push("Selected skills: none.");
-    }
-    if (provenance.knowledgeReferences.length) {
-        lines.push("Selected knowledge:");
-        for (const knowledgePath of provenance.knowledgeReferences) {
-            const sha256 = provenance.knowledgeSha256[knowledgePath];
-            lines.push(`- ${knowledgePath}${sha256 ? `; sha256: ${sha256}` : ""}`);
-        }
-    }
-    else {
-        lines.push("Selected knowledge: none.");
-    }
-    lines.push(`Selection reason: ${provenance.selectionReason}`);
-    return lines.join("\n");
-}
-function renderExecutionGuidanceStep(step) {
-    const command = step.command ? ` Command: \`${step.command}\`.` : "";
-    const condition = step.condition ? ` Condition: ${step.condition}.` : "";
-    return `${step.order}. ${step.description}${command}${condition}`;
-}
-function renderUnitGuidance(unit) {
-    const dependencies = JSON.stringify(unit.dependsOn);
-    const parallelGroup = JSON.stringify(unit.parallelGroup);
-    const independent = unit.dependsOn.length === 0;
-    return `- ${unit.id}: ${unit.task}; file ${unit.file}; independent: ${independent}; dependsOn: ${dependencies}; parallelGroup: ${parallelGroup}; verification focus: ${unit.verification.join(", ")}`;
-}
-function toPascalCase(value) {
-    return value
-        .replace(/[^a-zA-Z0-9]+/g, " ")
-        .trim()
-        .split(/\s+/)
-        .slice(0, 4)
-        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join("");
-}
 //# sourceMappingURL=plan.js.map