@wowok/agent-mcp 2.5.4 → 2.6.0

package/dist/tools/handlers/project.js

@@ -1,1078 +1,88 @@
-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, 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 { generateDeploymentDocFromProject } from "../../project/deployment-bridge.js";
+import { LocalProject } from "@wowok/wowok";
+import { handleListProjects, handleCreateProject, handleCreateProjectFromOnchain, handleUpdateProject, handleGetProjectDetail, handleAddObject, handleRemoveObject, handleUpdateObject, handleCreateVersion, handleBuildGraph, handleGetGraph, handleEvaluateProject, handleSaveEvaluation, handleCompareProjects, handleRefreshObjects, handleGetObjectDiff, handleDeleteProject, } from "../../project/handlers.js";
 import { strictParse } from "../../schema/index.js";
 import { ProjectOperationInputSchema } from "../../schema/project/index.js";
-import { injectEvolutionContext } from "../../knowledge/flywheel-loop.js";
-import { getExperienceFeedback } from "../../experience/index.js";
-function requireProject(v) {
-    if (!v.project) {
-        throw new Error("'project' (prefix) is required for this action");
-    }
-    if (!v.version) {
-        throw new Error("'version' is required for this action (e.g. 'v1')");
-    }
-    return { prefix: v.project, version: v.version };
-}
-function requireUserIntent(v) {
-    if (!v.user_intent) {
-        throw new Error("'user_intent' is required for analyze_intent");
-    }
-    return v.user_intent;
-}
-function requirePuzzles(v) {
-    if (!v.puzzles || Object.keys(v.puzzles).length === 0) {
-        throw new Error("'puzzles' is required for this action (obtain from analyze_intent)");
-    }
-    return v.puzzles;
-}
-function requireDeploymentInputs(v) {
-    if (!v.business_intent) {
-        throw new Error("'business_intent' is required for generate_deployment_doc");
-    }
-    if (!v.objects || v.objects.length === 0) {
-        throw new Error("'objects' is required for generate_deployment_doc");
-    }
-    if (!v.edges) {
-        throw new Error("'edges' is required for generate_deployment_doc");
-    }
-    if (!v.steps) {
-        throw new Error("'steps' is required for generate_deployment_doc");
-    }
-    return {
-        business_intent: v.business_intent,
-        objects: v.objects,
-        edges: v.edges,
-        steps: v.steps,
-    };
-}
-function requireSubsteps(v) {
-    if (!v.network) {
-        throw new Error("'network' is required for trace_substeps");
-    }
-    if (v.network !== "testnet" && v.network !== "mainnet") {
-        throw new Error("'network' must be 'testnet' or 'mainnet'");
-    }
-    if (!v.substeps || v.substeps.length === 0) {
-        throw new Error("'substeps' is required for trace_substeps");
-    }
-    return {
-        network: v.network,
-        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);
-    const result = analyzeBusinessIntent({
-        user_intent: userIntent,
-        project_name: `${prefix}_${version}`,
-        industry: validated.industry,
-        target_objects: validated.target_objects,
-    });
-    const industry = validated.industry ?? "general";
-    let evolutionContext;
-    let experienceFeedback;
-    try {
-        evolutionContext = injectEvolutionContext(undefined, industry);
-    }
-    catch {
-        evolutionContext = undefined;
-    }
-    try {
-        experienceFeedback = getExperienceFeedback("analyze_intent", { user_intent: userIntent, industry, target_objects: validated.target_objects }, `project:analyze_intent`);
-    }
-    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) {
-    const { prefix, version } = requireProject(validated);
-    const puzzles = requirePuzzles(validated);
-    const result = aggregateProjectRisks({
-        project_prefix: prefix,
-        version: version,
-        industry: validated.industry,
-        puzzles,
-        severity_threshold: validated.severity_threshold,
-        user_confirmed_high_risks: validated.user_confirmed_high_risks,
-    });
-    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,
-        findings: result.findings,
-        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,
-        next_action: hasCritical ? "fix_risks" : "generate_deployment_doc",
-        user_action_required: hasCritical
-            ? `Fix ${result.severity_summary.CRITICAL} CRITICAL risk(s) before proceeding`
-            : 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) {
-    const { prefix, version } = requireProject(validated);
-    const required = requireDeploymentInputs(validated);
-    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 markdown = generateDeploymentDoc(docInput);
-    const generatedAt = new Date().toISOString();
-    const shouldRunScanner = validated.run_scanner !== false;
-    let validationResult;
-    if (shouldRunScanner) {
-        const validation = validateDeploymentDoc(docInput);
-        validationResult = {
-            valid: validation.valid,
-            checks: validation.checks,
-            errors: validation.errors,
-        };
-    }
-    const errorCount = validationResult
-        ? validationResult.checks.filter((c) => c.status === "FAIL").length
-        : 0;
-    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,
-        meta: {
-            project_prefix: prefix,
-            version: version,
-            generated_at: generatedAt,
-            object_count: required.objects.length,
-            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
-            ? `Fix ${errorCount} D-error(s) before deploying`
-            : 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) {
-    const { prefix, version } = requireProject(validated);
-    const { network, substeps } = requireSubsteps(validated);
-    const result = traceSubsteps({
-        project_prefix: prefix,
-        version: version,
-        network: network,
-        substeps,
-    });
-    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`);
-    }
-    if (result.circular_refs.length > 0) {
-        issueParts.push(`${result.circular_refs.length} circular refs`);
-    }
-    if (result.missing_outputs.length > 0) {
-        issueParts.push(`${result.missing_outputs.length} missing outputs`);
-    }
-    if (result.cross_step_breaks.length > 0) {
-        issueParts.push(`${result.cross_step_breaks.length} cross-step breaks`);
-    }
-    if (hasFailedSubstep) {
-        const failedCount = substeps.filter((s) => s.status === "FAILED").length;
-        issueParts.push(`${failedCount} failed substep(s)`);
-    }
-    return {
-        action: "trace_substeps",
-        namespace: result.namespace,
-        network: result.network,
-        coherent: result.coherent,
-        dangling_inputs: result.dangling_inputs,
-        circular_refs: result.circular_refs,
-        missing_outputs: result.missing_outputs,
-        cross_step_breaks: result.cross_step_breaks,
-        step_details: result.step_details,
-        topological_order: result.topological_order,
-        d10_check: result.d10_check,
-        can_proceed: canProceed,
-        next_action: canProceed ? "deploy" : "fix_substeps",
-        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) {
     const validated = strictParse(ProjectOperationInputSchema, args, "project_operation input");
     const { action } = validated;
     let result;
     switch (action) {
         case "list_projects":
-            result = { action: "list_projects", items: await queryProjects() };
-            break;
-        case "list_objects":
-            if (!validated.project)
-                throw new Error("'project' param is required for list_objects");
-            result = { action: "list_objects", items: await queryProjectObjects(validated.project) };
+            result = await handleListProjects(validated);
             break;
-        case "shareable":
-            result = { action: "shareable", items: await queryShareableObjects() };
+        case "create_project":
+            result = await handleCreateProject(validated);
             break;
-        case "dependencies":
-            if (!validated.object)
-                throw new Error("'object' param is required for dependencies");
-            result = { action: "dependencies", items: queryDependencies(validated.object) };
+        case "create_project_from_onchain":
+            result = await handleCreateProjectFromOnchain(validated);
             break;
-        case "referenced_by":
-            if (!validated.object)
-                throw new Error("'object' param is required for referenced_by");
-            result = { action: "referenced_by", items: queryReferencedBy(validated.object) };
+        case "update_project":
+            result = await handleUpdateProject(validated);
             break;
-        case "pre_publish_check":
-            if (!validated.object)
-                throw new Error("'object' param is required for pre_publish_check");
-            result = { action: "pre_publish_check", warnings: queryPrePublishCheck(validated.object) };
+        case "get_project_detail":
+            result = await handleGetProjectDetail(validated);
             break;
-        case "cross_project_refs":
-            result = { action: "cross_project_refs", items: queryCrossProjectReferences() };
+        case "add_object":
+            result = await handleAddObject(validated);
             break;
-        case "graph_stats":
-            result = { action: "graph_stats", stats: queryGraphStats() };
+        case "remove_object":
+            result = await handleRemoveObject(validated);
             break;
-        case "save_graph":
-            result = { action: "save_graph", saved: true, path: saveGraph() };
+        case "update_object":
+            result = await handleUpdateObject(validated);
             break;
-        case "load_graph":
-            result = { action: "load_graph", loaded: loadGraph() };
+        case "create_version":
+            result = await handleCreateVersion(validated);
             break;
-        case "analyze_intent":
-            result = await handleAnalyzeIntent(validated);
+        case "build_graph":
+            result = await handleBuildGraph(validated);
             break;
-        case "aggregate_risks":
-            result = await handleAggregateRisks(validated);
+        case "get_graph":
+            result = await handleGetGraph(validated);
             break;
-        case "generate_deployment_doc":
-            result = await handleGenerateDeploymentDoc(validated);
+        case "evaluate_project":
+            result = await handleEvaluateProject(validated);
             break;
-        case "trace_substeps":
-            result = await handleTraceSubsteps(validated);
+        case "save_evaluation":
+            result = await handleSaveEvaluation(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);
+        case "compare_projects":
+            result = await handleCompareProjects(validated);
             break;
-        case "update_deployment_doc":
-            result = await handleUpdateDeploymentDoc(validated);
+        case "refresh_objects":
+            result = await handleRefreshObjects(validated);
             break;
-        case "validate_validation_chain":
-            result = await handleValidateValidationChain(validated);
+        case "get_object_diff":
+            result = await handleGetObjectDiff(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);
+        case "delete_project":
+            result = await handleDeleteProject(validated);
             break;
         case "assemble_context":
             result = await assembleContext(validated);
             break;
+        case "generate_deployment_doc": {
+            const { project_id, network, save = true } = validated;
+            if (!project_id) {
+                throw new Error("'project_id' is required for generate_deployment_doc");
+            }
+            if (!network) {
+                throw new Error("'network' is required for generate_deployment_doc");
+            }
+            const genResult = await generateDeploymentDocFromProject(project_id, network);
+            if (save) {
+                await LocalProject.Instance().saveDocument(project_id, network, genResult.markdown);
+            }
+            result = {
+                action: "generate_deployment_doc",
+                markdown: genResult.markdown,
+                validation: genResult.validation,
+                saved: save,
+            };
+            break;
+        }
         default:
             throw new Error(`Unknown project_operation action: ${String(action)}`);
     }