@wowok/agent-mcp 2.5.1 → 2.5.3

package/dist/tools/handlers/project.js

@@ -1,8 +1,16 @@
-import { queryProjects, queryProjectObjects, queryShareableObjects, queryDependencies, queryReferencedBy, queryPrePublishCheck, queryCrossProjectReferences, queryGraphStats, saveGraph, loadGraph, } from "../../project/index.js";
+import { queryProjects, queryProjectObjects, queryShareableObjects, queryDependencies, queryReferencedBy, queryPrePublishCheck, queryCrossProjectReferences, queryGraphStats, saveGraph, loadGraph, updateStageCache, getProjectStatus, } from "../../project/index.js";
 import { analyzeBusinessIntent } from "../../project/business-puzzle.js";
 import { aggregateProjectRisks } from "../../project/risk-aggregator.js";
-import { generateDeploymentDoc, validateDeploymentDoc, } from "../../project/deployment-doc.js";
+import { generateDeploymentDoc, generateDeploymentDocSet, validateDeploymentDoc, estimateDeploymentGas, } from "../../project/deployment-doc.js";
 import { traceSubsteps } from "../../project/substep-trace.js";
+import * as ProjectStore from "../../project/project-store.js";
+import { migrateProject } from "../../project/migration.js";
+import { validateStageGate } from "../../project/stage-gate.js";
+import { rollbackStageWithPolicy, evaluateRollbackPolicy, queryReversibility, getReversibilityForType, REVERSIBILITY_MATRIX, } from "../../project/rollback-policy.js";
+import { assembleContext } from "../../project/context-assembly.js";
+import { loadImprovementQueue, updateProposalReviewStatus, applyConfigOverride, produceSourcePatch, getFlywheelConfigSummary, } from "../../loop-engineering/improve.js";
+import { clearOverrideCache } from "../../knowledge/overrides-loader.js";
+import { refreshKnowledgeOverrides } from "../../knowledge/index.js";
 import { strictParse } from "../../schema/index.js";
 import { ProjectOperationInputSchema } from "../../schema/project/index.js";
 import { injectEvolutionContext } from "../../knowledge/flywheel-loop.js";
@@ -63,6 +71,22 @@ function requireSubsteps(v) {
         substeps: v.substeps,
     };
 }
+function appendGateAudit(prefix, version, stage, gate) {
+    try {
+        ProjectStore.appendAudit(prefix, version, {
+            timestamp: new Date().toISOString(),
+            event: "gate_validation",
+            stage,
+            reason: gate.passed
+                ? `stage ${stage} gate passed (${gate.checks.filter((c) => c.status === "PASS").length}/${gate.checks.length} checks)`
+                : `stage ${stage} gate BLOCKED: ${gate.blocking_issues.join("; ")}`,
+            affected_files: ["stage.json"],
+            user_confirmed: gate.passed,
+        });
+    }
+    catch {
+    }
+}
 async function handleAnalyzeIntent(validated) {
     const { prefix, version } = requireProject(validated);
     const userIntent = requireUserIntent(validated);
@@ -87,16 +111,30 @@ async function handleAnalyzeIntent(validated) {
     catch {
         experienceFeedback = undefined;
     }
+    updateStageCache(prefix, version, {
+        stage: 2,
+        puzzles: result.puzzles,
+        business_intent: userIntent,
+        industry,
+    });
+    const gate2 = validateStageGate({
+        stage: 2, prefix, version,
+        puzzles: result.puzzles,
+        puzzles_completeness: result.overall_completeness,
+    });
+    appendGateAudit(prefix, version, 2, gate2);
     return {
         action: "analyze_intent",
         intent_parsed: result.intent_parsed,
         puzzles: result.puzzles,
         overall_completeness: result.overall_completeness,
         next_step: result.next_step,
+        recommended_creation_order: result.recommended_creation_order,
         next_action: result.overall_completeness === "complete" ? "aggregate_risks" : "none",
         warnings: result.warnings,
         evolution_context: evolutionContext,
         experience_feedback: experienceFeedback,
+        gate_validation: gate2,
     };
 }
 async function handleAggregateRisks(validated) {
@@ -112,6 +150,17 @@ async function handleAggregateRisks(validated) {
     });
     const hasCritical = result.severity_summary.CRITICAL > 0;
     const unconfirmedHigh = result.findings.filter((r) => r.severity === "HIGH").length;
+    updateStageCache(prefix, version, {
+        stage: 3,
+        risk_status: result.status,
+        risk_can_proceed: !hasCritical,
+    });
+    const gate3 = validateStageGate({
+        stage: 3, prefix, version,
+        risk_status: result.status,
+        risk_can_proceed: !hasCritical,
+    });
+    appendGateAudit(prefix, version, 3, gate3);
     return {
         action: "aggregate_risks",
         namespace: result.namespace,
@@ -119,6 +168,7 @@ async function handleAggregateRisks(validated) {
         severity_summary: result.severity_summary,
         status: result.status,
         pending_confirmations: result.pending_confirmations,
+        fix_suggestions_grouped: result.fix_suggestions_grouped,
         calibrated_at: result.calibrated_at,
         warnings: result.warnings,
         can_proceed: !hasCritical,
@@ -128,6 +178,7 @@ async function handleAggregateRisks(validated) {
             : unconfirmedHigh > 0
                 ? `Review ${unconfirmedHigh} HIGH risk(s). You may proceed at your own risk.`
                 : "All risks reviewed. You may proceed.",
+        gate_validation: gate3,
     };
 }
 async function handleGenerateDeploymentDoc(validated) {
@@ -165,6 +216,40 @@ async function handleGenerateDeploymentDoc(validated) {
     const warningCount = validationResult
         ? validationResult.checks.filter((c) => c.status === "WARN").length
         : 0;
+    const gasEstimate = estimateDeploymentGas({ objects: required.objects });
+    let docSetResult;
+    try {
+        const persisted = generateDeploymentDocSet(prefix, version, docInput);
+        docSetResult = {
+            all_files: persisted.all_files,
+            all_stages_passed: persisted.all_stages_passed,
+        };
+    }
+    catch {
+        docSetResult = undefined;
+    }
+    updateStageCache(prefix, version, {
+        stage: 4,
+        doc_generated: true,
+        doc_error_count: errorCount,
+    });
+    const gasBudgetInput = validated.gas_budget
+        ? {
+            network: validated.gas_budget.network,
+            already_spent_gas: validated.gas_budget.already_spent_gas ?? 0,
+            estimated_rerun_gas: validated.gas_budget.estimated_rerun_gas ?? gasEstimate.total_gas_mist,
+            warning: validated.gas_budget.warning,
+        }
+        : undefined;
+    const gate4 = validateStageGate({
+        stage: 4, prefix, version,
+        doc_error_count: errorCount,
+        objects: required.objects,
+        edges: required.edges,
+        risk_status: validated.risk_status,
+        gas_budget: gasBudgetInput,
+    });
+    appendGateAudit(prefix, version, 4, gate4);
     return {
         action: "generate_deployment_doc",
         markdown,
@@ -176,6 +261,8 @@ async function handleGenerateDeploymentDoc(validated) {
             step_count: required.steps.length,
         },
         validation: validationResult,
+        estimated_gas: gasEstimate,
+        persisted: docSetResult,
         can_proceed: errorCount === 0,
         next_action: errorCount === 0 ? "trace_substeps" : "fix_doc_errors",
         user_action_required: errorCount > 0
@@ -183,6 +270,7 @@ async function handleGenerateDeploymentDoc(validated) {
             : warningCount > 0
                 ? `${warningCount} D-warning(s) found. You may proceed at your own risk.`
                 : "Deployment document ready. You may proceed to stage 5.",
+        gate_validation: gate4,
     };
 }
 async function handleTraceSubsteps(validated) {
@@ -196,6 +284,23 @@ async function handleTraceSubsteps(validated) {
     });
     const hasFailedSubstep = substeps.some((s) => s.status === "FAILED");
     const canProceed = result.coherent && !hasFailedSubstep;
+    updateStageCache(prefix, version, {
+        stage: 5,
+        trace_coherent: result.coherent,
+        trace_can_proceed: canProceed,
+    });
+    const stage5GasBudget = {
+        network: validated.gas_budget?.network ?? network,
+        already_spent_gas: validated.gas_budget?.already_spent_gas ?? 0,
+        estimated_rerun_gas: validated.gas_budget?.estimated_rerun_gas ?? 0,
+        warning: validated.gas_budget?.warning,
+    };
+    const gate5 = validateStageGate({
+        stage: 5, prefix, version,
+        trace_coherent: result.coherent,
+        gas_budget: stage5GasBudget,
+    });
+    appendGateAudit(prefix, version, 5, gate5);
     const issueParts = [];
     if (result.dangling_inputs.length > 0) {
         issueParts.push(`${result.dangling_inputs.length} dangling inputs`);
@@ -230,6 +335,619 @@ async function handleTraceSubsteps(validated) {
         user_action_required: issueParts.length > 0
             ? `Fix: ${issueParts.join(", ")}`
             : "All substeps passed. Deployment complete.",
+        gate_validation: gate5,
+    };
+}
+async function handleLoadProject(validated) {
+    if (!validated.project || !validated.version) {
+        const localProjects = ProjectStore.listLocalProjects();
+        const chainProjects = await queryProjects();
+        const chainSet = new Set(chainProjects.map((p) => p.prefix));
+        const items = localProjects.map((lp) => ({
+            prefix: lp.prefix,
+            version: lp.version,
+            dir_name: lp.dir_name,
+            initialized: lp.initialized,
+            archived: lp.archived,
+            needs_migration: lp.needs_migration,
+            forked_from: lp.forked_from,
+            chain_exists: chainSet.has(lp.prefix),
+            sync_status: !lp.initialized
+                ? "uninitialized"
+                : lp.archived
+                    ? "archived"
+                    : chainSet.has(lp.prefix)
+                        ? "synced"
+                        : "local_only",
+        }));
+        return { action: "load_project", items, total: items.length };
+    }
+    const { prefix, version } = requireProject(validated);
+    const exists = ProjectStore.projectExists(prefix, version);
+    if (!exists) {
+        return {
+            action: "load_project",
+            project: prefix,
+            version,
+            local_exists: false,
+            message: "project not found locally; call analyze_intent to initialize",
+        };
+    }
+    let migrationResult;
+    try {
+        const manifest = ProjectStore.loadManifest(prefix, version);
+        if (manifest.schema_version !== ProjectStore.CURRENT_SCHEMA_VERSION) {
+            migrationResult = migrateProject(prefix, version);
+        }
+    }
+    catch {
+    }
+    const manifest = ProjectStore.loadManifest(prefix, version);
+    const stageState = ProjectStore.loadStageState(prefix, version);
+    const syncStatus = ProjectStore.getLocalSyncStatus(prefix, version);
+    return {
+        action: "load_project",
+        project: prefix,
+        version,
+        local_exists: true,
+        manifest,
+        stage_state: stageState,
+        sync_status: syncStatus,
+        migration: migrationResult,
+    };
+}
+async function handleForkProject(validated) {
+    const { prefix: srcPrefix, version: srcVersion } = requireProject(validated);
+    if (!validated.fork_to_version) {
+        throw new Error("'fork_to_version' is required for fork_project (e.g. 'v2')");
+    }
+    if (!ProjectStore.projectExists(srcPrefix, srcVersion)) {
+        throw new Error(`source project not found: ${srcPrefix}_${srcVersion}`);
+    }
+    const result = ProjectStore.forkProject(srcPrefix, srcVersion, {
+        newVersion: validated.fork_to_version,
+        newPrefix: validated.fork_to_prefix ?? srcPrefix,
+    });
+    return {
+        action: "fork_project",
+        new_prefix: result.new_prefix,
+        new_version: result.new_version,
+        new_path: result.new_path,
+        forked_from: result.forked_from,
+        copied_files: result.copied_files,
+        copied_file_count: result.copied_files.length,
+        warning: "forked project must re-create its own objects (project isolation §3.0); " +
+            "chain addresses in copied files are for audit reference only",
+        next_action: "analyze_intent",
+    };
+}
+async function handleExportProject(validated) {
+    const { prefix, version } = requireProject(validated);
+    if (!ProjectStore.projectExists(prefix, version)) {
+        throw new Error(`project not found: ${prefix}_${version}`);
+    }
+    const files = ProjectStore.listProjectFiles(prefix, version);
+    const exportedFiles = files.map((f) => ({
+        path: f.path,
+        size: f.size,
+        kind: f.kind,
+        content: ProjectStore.readProjectFile(prefix, version, f.path) ?? "",
+    }));
+    return {
+        action: "export_project",
+        project: prefix,
+        version,
+        files: exportedFiles,
+        total_files: exportedFiles.length,
+    };
+}
+async function handleGetProjectFiles(validated) {
+    const { prefix, version } = requireProject(validated);
+    if (!ProjectStore.projectExists(prefix, version)) {
+        throw new Error(`project not found: ${prefix}_${version}`);
+    }
+    const files = ProjectStore.listProjectFiles(prefix, version);
+    return {
+        action: "get_project_files",
+        project: prefix,
+        version,
+        files: files.map((f) => ({
+            path: f.path,
+            size: f.size,
+            kind: f.kind,
+            mtime: f.mtime,
+        })),
+        total_files: files.length,
+    };
+}
+const STAGE_DIR_NAMES = {
+    1: "namespace",
+    2: "puzzle",
+    3: "risk",
+    4: "steps",
+    5: "substeps",
+};
+function requireTargetStage(v) {
+    if (v.target_stage === undefined || v.target_stage === null) {
+        throw new Error("'target_stage' (1-5) is required for this action");
+    }
+    const s = v.target_stage;
+    if (s < 1 || s > 5 || !Number.isInteger(s)) {
+        throw new Error("'target_stage' must be an integer 1-5");
+    }
+    return s;
+}
+function stageDirPath(stage) {
+    return `deployment/0${stage}-${STAGE_DIR_NAMES[stage]}`;
+}
+function requireDeploymentDocExists(prefix, version) {
+    if (!ProjectStore.projectExists(prefix, version)) {
+        throw new Error(`project not found: ${prefix}_${version}`);
+    }
+    const readme = ProjectStore.readProjectFile(prefix, version, "deployment/README.md");
+    if (readme === undefined) {
+        throw new Error(`deployment doc not found for ${prefix}_${version}. Call 'generate_deployment_doc' first.`);
+    }
+}
+async function handleValidateStageUnit(validated) {
+    const { prefix, version } = requireProject(validated);
+    const stage = requireTargetStage(validated);
+    requireDeploymentDocExists(prefix, version);
+    const dir = stageDirPath(stage);
+    const files = ["README.md", "assessment.json", "risk-policy.json", "verification.json", "content.md"];
+    const missing = [];
+    for (const f of files) {
+        const rel = `${dir}/${f}`;
+        if (ProjectStore.readProjectFile(prefix, version, rel) === undefined) {
+            missing.push(rel);
+        }
+    }
+    const checks = [];
+    const blocking = [];
+    if (missing.length === 0) {
+        checks.push({ check_id: "SU-01", status: "pass", message: `All 5 stage unit files present in ${dir}/` });
+    }
+    else {
+        checks.push({ check_id: "SU-01", status: "fail", message: `${missing.length} file(s) missing: ${missing.join(", ")}` });
+        blocking.push(`Missing files: ${missing.join(", ")}`);
+    }
+    const assessment = ProjectStore.loadProjectFile(prefix, version, `${dir}/assessment.json`);
+    const riskPolicy = ProjectStore.loadProjectFile(prefix, version, `${dir}/risk-policy.json`);
+    const verification = ProjectStore.loadProjectFile(prefix, version, `${dir}/verification.json`);
+    if (assessment) {
+        const ok = assessment.stage === stage;
+        checks.push({ check_id: "SU-02", status: ok ? "pass" : "fail", message: ok ? `assessment.json stage=${stage} matches` : `assessment.json stage=${assessment.stage} != target ${stage}` });
+        if (!ok)
+            blocking.push("assessment.json stage mismatch");
+    }
+    if (riskPolicy) {
+        const ok = riskPolicy.stage === stage;
+        checks.push({ check_id: "SU-03", status: ok ? "pass" : "fail", message: ok ? `risk-policy.json stage=${stage} matches` : `risk-policy.json stage=${riskPolicy.stage} != target ${stage}` });
+        if (!ok)
+            blocking.push("risk-policy.json stage mismatch");
+    }
+    if (verification) {
+        const ok = verification.stage === stage;
+        checks.push({ check_id: "SU-04", status: ok ? "pass" : "fail", message: ok ? `verification.json stage=${stage} matches` : `verification.json stage=${verification.stage} != target ${stage}` });
+        if (!ok)
+            blocking.push("verification.json stage mismatch");
+        if (ok) {
+            const passed = verification.stage_passed === true;
+            const hasBlocking = (verification.blocking_issues?.length ?? 0) > 0;
+            const consistent = passed !== hasBlocking;
+            checks.push({
+                check_id: "SU-05",
+                status: consistent ? "pass" : "warn",
+                message: consistent
+                    ? `stage_passed=${passed} consistent with blocking_issues (count=${verification.blocking_issues?.length ?? 0})`
+                    : `stage_passed=${passed} but blocking_issues count=${verification.blocking_issues?.length ?? 0} — possible inconsistency`,
+            });
+        }
+    }
+    return {
+        action: "validate_stage_unit",
+        project: prefix,
+        version,
+        stage,
+        valid: blocking.length === 0,
+        missing_files: missing,
+        checks,
+        blocking_issues: blocking,
+        stage_passed: verification?.stage_passed,
+    };
+}
+async function handleGetStageAssessment(validated) {
+    const { prefix, version } = requireProject(validated);
+    const stage = requireTargetStage(validated);
+    requireDeploymentDocExists(prefix, version);
+    const assessment = ProjectStore.loadProjectFile(prefix, version, `${stageDirPath(stage)}/assessment.json`);
+    return {
+        action: "get_stage_assessment",
+        project: prefix,
+        version,
+        stage,
+        found: assessment !== undefined,
+        assessment: assessment ?? undefined,
+    };
+}
+async function handleGetStageRiskPolicy(validated) {
+    const { prefix, version } = requireProject(validated);
+    const stage = requireTargetStage(validated);
+    requireDeploymentDocExists(prefix, version);
+    const riskPolicy = ProjectStore.loadProjectFile(prefix, version, `${stageDirPath(stage)}/risk-policy.json`);
+    return {
+        action: "get_stage_risk_policy",
+        project: prefix,
+        version,
+        stage,
+        found: riskPolicy !== undefined,
+        risk_policy: riskPolicy ?? undefined,
+    };
+}
+async function handleGetDocRelations(validated) {
+    const { prefix, version } = requireProject(validated);
+    requireDeploymentDocExists(prefix, version);
+    const relations = ProjectStore.loadProjectFile(prefix, version, "deployment/relations.json");
+    return {
+        action: "get_doc_relations",
+        project: prefix,
+        version,
+        found: relations !== undefined,
+        relations: relations ?? undefined,
+    };
+}
+async function handleUpdateDeploymentDoc(validated) {
+    const { prefix, version } = requireProject(validated);
+    const required = requireDeploymentInputs(validated);
+    requireDeploymentDocExists(prefix, version);
+    const docInput = {
+        project_prefix: prefix,
+        version: version,
+        business_intent: required.business_intent,
+        industry: validated.industry ?? "general",
+        author: validated.author,
+        objects: required.objects,
+        edges: required.edges,
+        steps: required.steps,
+        scenarios: validated.scenarios,
+        risk_status: validated.risk_status,
+        risk_critical_count: validated.risk_critical_count,
+        risk_high_count: validated.risk_high_count,
+    };
+    const persisted = generateDeploymentDocSet(prefix, version, docInput);
+    const stagesAffected = persisted.relations.stage_units.map((su) => su.stage);
+    return {
+        action: "update_deployment_doc",
+        project: prefix,
+        version,
+        updated: true,
+        updated_files: persisted.all_files,
+        updated_file_count: persisted.all_files.length,
+        all_stages_passed: persisted.all_stages_passed,
+        impact_summary: {
+            stages_affected: stagesAffected,
+            relations_rebuilt: true,
+        },
+        next_action: "validate_validation_chain",
+    };
+}
+async function handleValidateValidationChain(validated) {
+    const { prefix, version } = requireProject(validated);
+    requireDeploymentDocExists(prefix, version);
+    const relations = ProjectStore.loadProjectFile(prefix, version, "deployment/relations.json");
+    const derivationChecks = [];
+    const propagationChecks = [];
+    const crossStageChecks = [];
+    const impactMapChecks = [];
+    const blocking = [];
+    const warnings = [];
+    if (!relations) {
+        return {
+            action: "validate_validation_chain",
+            project: prefix, version,
+            valid: false,
+            derivation_checks: [{ check_id: "VC-00", status: "fail", message: "relations.json not found" }],
+            propagation_checks: [], cross_stage_checks: [], impact_map_checks: [],
+            blocking_issues: ["relations.json not found"], warnings: [],
+        };
+    }
+    const invariantIds = new Set((relations.project_invariants ?? []).map((i) => i.invariant_id));
+    const derivations = relations.derivations ?? [];
+    const stageUnits = relations.stage_units ?? [];
+    if (derivations.length === 0) {
+        derivationChecks.push({ check_id: "VC-D01", status: "warn", message: "No derivations defined in relations.json" });
+        warnings.push("No derivations defined");
+    }
+    else {
+        const orphanDerivations = derivations.filter((d) => d.source_type === "project_invariant" && !invariantIds.has(d.source_id));
+        if (orphanDerivations.length === 0) {
+            derivationChecks.push({ check_id: "VC-D01", status: "pass", message: `All ${derivations.length} derivation(s) reference valid project invariants` });
+        }
+        else {
+            derivationChecks.push({ check_id: "VC-D01", status: "fail", message: `${orphanDerivations.length} derivation(s) reference unknown invariant: ${orphanDerivations.map((d) => d.source_id).join(", ")}` });
+            blocking.push(`Orphan derivations: ${orphanDerivations.length}`);
+        }
+    }
+    const stagesWithDerivations = new Set(derivations.map((d) => d.target_stage));
+    const stagesWithoutDerivations = stageUnits.filter((su) => !stagesWithDerivations.has(su.stage));
+    if (stagesWithoutDerivations.length === 0) {
+        derivationChecks.push({ check_id: "VC-D02", status: "pass", message: "All stage units have derivations" });
+    }
+    else {
+        derivationChecks.push({ check_id: "VC-D02", status: "warn", message: `Stage(s) without derivations: ${stagesWithoutDerivations.map((su) => su.stage).join(", ")}` });
+        warnings.push(`Stages without derivations: ${stagesWithoutDerivations.map((su) => su.stage).join(", ")}`);
+    }
+    const validStages = new Set(stageUnits.map((su) => su.stage));
+    const rules = relations.propagation_rules ?? [];
+    const invalidRules = rules.filter((r) => !validStages.has(r.trigger.stage));
+    if (rules.length === 0) {
+        propagationChecks.push({ check_id: "VC-P01", status: "warn", message: "No propagation rules defined" });
+        warnings.push("No propagation rules defined");
+    }
+    else if (invalidRules.length === 0) {
+        propagationChecks.push({ check_id: "VC-P01", status: "pass", message: `All ${rules.length} propagation rule(s) reference valid stages` });
+    }
+    else {
+        propagationChecks.push({ check_id: "VC-P01", status: "fail", message: `${invalidRules.length} rule(s) reference invalid stage: ${invalidRules.map((r) => r.rule_id).join(", ")}` });
+        blocking.push(`Invalid propagation rules: ${invalidRules.length}`);
+    }
+    for (const su of stageUnits) {
+        const vPath = `${stageDirPath(su.stage)}/verification.json`;
+        const v = ProjectStore.loadProjectFile(prefix, version, vPath);
+        if (!v) {
+            crossStageChecks.push({ check_id: `VC-C${su.stage}`, status: "warn", message: `Stage ${su.stage} verification.json missing` });
+            warnings.push(`Stage ${su.stage} verification.json missing`);
+        }
+        else if (v.stage_passed === true) {
+            crossStageChecks.push({ check_id: `VC-C${su.stage}`, status: "pass", message: `Stage ${su.stage} verification passed` });
+        }
+        else {
+            crossStageChecks.push({ check_id: `VC-C${su.stage}`, status: "fail", message: `Stage ${su.stage} verification NOT passed (blocking_issues: ${v.blocking_issues?.length ?? 0})` });
+            blocking.push(`Stage ${su.stage} verification failed`);
+        }
+    }
+    const impactMap = relations.impact_map ?? {};
+    const impactValues = new Set(Object.values(impactMap).flat());
+    const stagesNotInImpactMap = stageUnits.filter((su) => !impactValues.has(`stage_${su.stage}`) && !impactValues.has(String(su.stage)));
+    if (stageUnits.length === 0) {
+        impactMapChecks.push({ check_id: "VC-I01", status: "warn", message: "No stage units defined" });
+    }
+    else if (stagesNotInImpactMap.length === 0) {
+        impactMapChecks.push({ check_id: "VC-I01", status: "pass", message: "All stage units appear in impact map" });
+    }
+    else {
+        impactMapChecks.push({ check_id: "VC-I01", status: "warn", message: `Stage(s) not in impact map: ${stagesNotInImpactMap.map((su) => su.stage).join(", ")}` });
+        warnings.push(`Stages not in impact map: ${stagesNotInImpactMap.map((su) => su.stage).join(", ")}`);
+    }
+    return {
+        action: "validate_validation_chain",
+        project: prefix,
+        version,
+        valid: blocking.length === 0,
+        derivation_checks: derivationChecks,
+        propagation_checks: propagationChecks,
+        cross_stage_checks: crossStageChecks,
+        impact_map_checks: impactMapChecks,
+        blocking_issues: blocking,
+        warnings,
+    };
+}
+async function handleApplyImprovement(validated) {
+    if (!validated.proposal_id) {
+        throw new Error("'proposal_id' is required for apply_improvement");
+    }
+    if (!validated.review_status) {
+        throw new Error("'review_status' (approved|rejected|applied) is required for apply_improvement");
+    }
+    const proposalId = validated.proposal_id;
+    const newStatus = validated.review_status;
+    const all = loadImprovementQueue();
+    const proposal = all.find((p) => p.proposal_id === proposalId);
+    if (!proposal) {
+        throw new Error(`Proposal not found in queue: ${proposalId}`);
+    }
+    const previousStatus = proposal.review_status;
+    if (newStatus === "rejected") {
+        updateProposalReviewStatus(proposalId, "rejected");
+        return {
+            action: "apply_improvement",
+            proposal_id: proposalId,
+            previous_status: previousStatus,
+            new_status: "rejected",
+            applied: false,
+            apply_mode: proposal.apply_mode,
+            message: `Proposal ${proposalId} rejected.`,
+            next_action: "get_improvement_queue",
+        };
+    }
+    if (newStatus === "approved") {
+        let overrideFile;
+        let patchFile;
+        let applied = false;
+        if (proposal.apply_mode === "config_override") {
+            try {
+                overrideFile = applyConfigOverride(proposal);
+                clearOverrideCache();
+                refreshKnowledgeOverrides();
+                applied = true;
+            }
+            catch (e) {
+                throw new Error(`Failed to apply config_override for ${proposalId}: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        else {
+            try {
+                patchFile = produceSourcePatch(proposal);
+                applied = true;
+            }
+            catch (e) {
+                throw new Error(`Failed to produce source patch for ${proposalId}: ${e instanceof Error ? e.message : String(e)}`);
+            }
+        }
+        updateProposalReviewStatus(proposalId, "applied");
+        return {
+            action: "apply_improvement",
+            proposal_id: proposalId,
+            previous_status: previousStatus,
+            new_status: "applied",
+            applied,
+            apply_mode: proposal.apply_mode,
+            override_file: overrideFile,
+            patch_file: patchFile,
+            message: proposal.apply_mode === "config_override"
+                ? `Proposal applied as config_override. Override written to ${overrideFile}. Takes effect on next action call.`
+                : `Proposal applied as source_patch. Patch file written to ${patchFile}. Requires manual merge into MCP source + republish.`,
+            next_action: "get_improvement_queue",
+        };
+    }
+    updateProposalReviewStatus(proposalId, "applied");
+    return {
+        action: "apply_improvement",
+        proposal_id: proposalId,
+        previous_status: previousStatus,
+        new_status: "applied",
+        applied: false,
+        apply_mode: proposal.apply_mode,
+        message: `Proposal ${proposalId} marked as applied (external application).`,
+        next_action: "get_flywheel_config",
+    };
+}
+async function handleGetImprovementQueue(validated) {
+    const filter = {};
+    if (validated.queue_filter_status)
+        filter.status = validated.queue_filter_status;
+    if (validated.queue_filter_type)
+        filter.type = validated.queue_filter_type;
+    if (validated.queue_filter_priority)
+        filter.priority = validated.queue_filter_priority;
+    const all = loadImprovementQueue();
+    const filtered = filter.status || filter.type || filter.priority
+        ? loadImprovementQueue(filter)
+        : all;
+    const pendingCount = all.filter((p) => p.review_status === "pending").length;
+    const summary = `${all.length} total proposals (${pendingCount} pending). Showing ${filtered.length}.`;
+    const proposals = filtered.map((p) => ({
+        proposal_id: p.proposal_id,
+        source_diagnosis_id: p.source_diagnosis_id,
+        type: p.type,
+        priority: p.priority,
+        automation: p.automation,
+        apply_mode: p.apply_mode,
+        override_category: p.override_category,
+        title: p.title,
+        description: p.description,
+        target: p.target,
+        review_status: p.review_status,
+        ab_test_recommended: p.ab_test_recommended,
+        persisted_at: p.persisted_at,
+        reviewed_at: p.reviewed_at,
+    }));
+    return {
+        action: "get_improvement_queue",
+        total: all.length,
+        filtered_count: filtered.length,
+        proposals,
+        summary,
+    };
+}
+async function handleGetFlywheelConfig() {
+    const summary = getFlywheelConfigSummary();
+    let reflowStatus;
+    if (summary.pending_count > 0) {
+        reflowStatus = "active";
+    }
+    else if (summary.approved_count > 0) {
+        reflowStatus = "blocked";
+    }
+    else {
+        reflowStatus = "idle";
+    }
+    const recentProposals = summary.recent_proposals.map((p) => ({
+        proposal_id: p.proposal_id,
+        type: p.type,
+        priority: p.priority,
+        review_status: p.review_status,
+        title: p.title,
+    }));
+    return {
+        action: "get_flywheel_config",
+        queue_path: summary.queue_path,
+        overrides_dir: summary.overrides_dir,
+        patches_dir: summary.patches_dir,
+        total_proposals: summary.total_proposals,
+        pending_count: summary.pending_count,
+        approved_count: summary.approved_count,
+        applied_count: summary.applied_count,
+        rejected_count: summary.rejected_count,
+        override_files: summary.override_files,
+        recent_proposals: recentProposals,
+        reflow_status: reflowStatus,
+    };
+}
+async function handleRollbackStage(validated) {
+    const { prefix, version } = requireProject(validated);
+    if (!validated.target_stage) {
+        throw new Error("'target_stage' is required for rollback_stage (the stage to rollback to, 1-4)");
+    }
+    const targetStage = validated.target_stage;
+    const dryRun = validated.dry_run ?? false;
+    if (dryRun) {
+        const policy = evaluateRollbackPolicy(prefix, version, targetStage);
+        return {
+            action: "rollback_stage",
+            success: false,
+            dry_run: true,
+            target_stage: targetStage,
+            previous_stage: policy.current_stage,
+            allowed: policy.allowed,
+            block_reason: policy.block_reason,
+            files_to_clean: policy.files_to_clean,
+            files_cleaned: [],
+            warnings: policy.warnings,
+            iteration_strategy: policy.iteration_strategy,
+            message: policy.allowed
+                ? `Dry run: rollback to stage ${targetStage} is allowed. ${policy.files_to_clean.length} file(s) would be deleted.`
+                : `Dry run: rollback blocked — ${policy.block_reason}`,
+        };
+    }
+    const result = rollbackStageWithPolicy(prefix, version, targetStage);
+    return {
+        action: "rollback_stage",
+        success: result.success,
+        dry_run: false,
+        target_stage: result.target_stage,
+        previous_stage: result.previous_stage,
+        allowed: result.success,
+        block_reason: result.success ? undefined : result.message,
+        files_to_clean: result.files_to_clean,
+        files_cleaned: result.files_cleaned,
+        warnings: result.warnings,
+        iteration_strategy: result.iteration_strategy,
+        message: result.message,
+    };
+}
+async function handleGetReversibility(validated) {
+    const objectType = validated.query_object_type;
+    const lifecycleState = validated.query_lifecycle_state;
+    let entries;
+    if (objectType && lifecycleState) {
+        const entry = queryReversibility(objectType, lifecycleState);
+        entries = entry ? [entry] : [];
+    }
+    else if (objectType) {
+        entries = getReversibilityForType(objectType);
+    }
+    else {
+        entries = REVERSIBILITY_MATRIX;
+    }
+    return {
+        action: "get_reversibility",
+        query: {
+            object_type: objectType,
+            lifecycle_state: lifecycleState,
+        },
+        entries,
+        total: entries.length,
     };
 }
 export async function handleProjectOperation(args) {
@@ -287,6 +1005,74 @@ export async function handleProjectOperation(args) {
         case "trace_substeps":
             result = await handleTraceSubsteps(validated);
             break;
+        case "get_project_status": {
+            const { prefix: gpPrefix, version: gpVersion } = requireProject(validated);
+            const status = getProjectStatus(gpPrefix, gpVersion);
+            result = {
+                action: "get_project_status",
+                project: gpPrefix,
+                version: gpVersion,
+                stage: status.stage,
+                stage_name: status.stage_name,
+                stage_description: status.stage_description,
+                next_action: status.next_action,
+                can_proceed: status.can_proceed,
+                last_updated: status.details?.updated_at,
+                risk_status: status.details?.risk_status,
+                risk_can_proceed: status.details?.risk_can_proceed,
+                doc_generated: status.details?.doc_generated,
+                trace_coherent: status.details?.trace_coherent,
+            };
+            break;
+        }
+        case "load_project":
+            result = await handleLoadProject(validated);
+            break;
+        case "fork_project":
+            result = await handleForkProject(validated);
+            break;
+        case "export_project":
+            result = await handleExportProject(validated);
+            break;
+        case "get_project_files":
+            result = await handleGetProjectFiles(validated);
+            break;
+        case "validate_stage_unit":
+            result = await handleValidateStageUnit(validated);
+            break;
+        case "get_stage_assessment":
+            result = await handleGetStageAssessment(validated);
+            break;
+        case "get_stage_risk_policy":
+            result = await handleGetStageRiskPolicy(validated);
+            break;
+        case "get_doc_relations":
+            result = await handleGetDocRelations(validated);
+            break;
+        case "update_deployment_doc":
+            result = await handleUpdateDeploymentDoc(validated);
+            break;
+        case "validate_validation_chain":
+            result = await handleValidateValidationChain(validated);
+            break;
+        case "apply_improvement":
+            result = await handleApplyImprovement(validated);
+            break;
+        case "get_improvement_queue":
+            result = await handleGetImprovementQueue(validated);
+            break;
+        case "get_flywheel_config":
+            result = await handleGetFlywheelConfig();
+            break;
+        case "rollback_stage":
+            result = await handleRollbackStage(validated);
+            break;
+        case "get_reversibility":
+            result = await handleGetReversibility(validated);
+            break;
+        case "assemble_context":
+            result = await assembleContext(validated);
+            break;
         default:
             throw new Error(`Unknown project_operation action: ${String(action)}`);
     }