@wowok/agent-mcp 2.4.1 → 2.5.0

package/dist/knowledge/machine-context.js

@@ -0,0 +1,812 @@
+import { MACHINE_LEDGER_VERSION, MACHINE_SCENES_COUNT, findScene, inferSceneFromFlow, } from "./machine-ledger.js";
+import { MAX_NODE_COUNT, MAX_NODE_PAIR_COUNT, MAX_FORWARD_COUNT, } from "./onchain-constants.js";
+import { MACHINE_TEMPLATES, MACHINE_TEMPLATES_VERSION, getAllTemplates, getTemplatesByScene, suggestTemplateForIntent, } from "./machine-templates.js";
+import { SEMANTIC_TO_MACHINE_RULES, MACHINE_CONSTRAINT_RULES, MACHINE_TRANSLATION_VERSION, matchSemanticPattern, } from "./machine-translation.js";
+import { MACHINE_RISK_RULES, MACHINE_RISK_VERSION, assessMachineRisks, } from "./machine-risk.js";
+import { analyzeTopology, formatTopologySummary, MACHINE_TOPOLOGY_VERSION, } from "./machine-topology.js";
+import { initPuzzleFromIntent, initPuzzleFromTemplate, checkPuzzleCompleteness, MACHINE_PUZZLE_VERSION, } from "./machine-puzzle.js";
+import { PUBLISH_CHECKLIST, CONFIRMATION_QUESTIONS, MACHINE_CONFIRM_VERSION, progressiveCheck, } from "./machine-confirm.js";
+import { GUARD_SCENES, } from "./guard-ledger.js";
+export const MACHINE_CONTEXT_VERSION = "1.0.0";
+export const MACHINE_VERIFICATION_NOTES = [
+    {
+        topic: "bReplace",
+        judgment: "YES",
+        verified_semantic: "bReplace acts at the pairs-list level of an ALREADY-EXISTING node, " +
+            "NOT at the whole-Machine level. bReplace=false merges new pairs into the " +
+            "existing node's pairs list; bReplace=true replaces that node's pairs list entirely.",
+        code_reference: "d:\\wowok\\agent\\mcp\\src\\tools\\machine.ts (node ops)",
+        affected_modes: ["initial_design", "mid_design_review", "pre_publish_check"],
+    },
+    {
+        topic: "um",
+        judgment: "PARTIAL",
+        verified_semantic: "um is a Messenger Contact object reference (off-chain session metadata). " +
+            "It does NOT participate in any on-chain flow logic; omitting it has zero on-chain impact.",
+        code_reference: "machine.move (no um field in on-chain Machine)",
+        affected_modes: ["initial_design", "mid_design_review"],
+    },
+    {
+        topic: "consensus_repositories",
+        judgment: "PARTIAL",
+        verified_semantic: "consensus_repositories is a declarative-only field. It is NOT consumed by any " +
+            "on-chain flow logic — it is a hint for off-chain tooling and human auditors.",
+        code_reference: "machine.move (no consensus_repositories field)",
+        affected_modes: ["initial_design", "mid_design_review"],
+    },
+    {
+        topic: "namedOperator_assignment",
+        judgment: "PARTIAL",
+        verified_semantic: "Move progress::new does NOT accept namedOperator parameter. The MCP/SDK layer " +
+            "translates the API parameter into a separate namedOperator_add transaction " +
+            "(requires permission index 221). At runtime, Forward checks namedOperator membership.",
+        code_reference: "progress.move (progress::new signature) + agent\\mcp\\src\\tools\\progress.ts (namedOperator_add)",
+        affected_modes: ["initial_design", "mid_design_review", "pre_publish_check"],
+    },
+    {
+        topic: "cross_machine_dependency",
+        judgment: "PARTIAL",
+        verified_semantic: "Cross-Machine dependency is INDIRECT: Machine A's Forward Guard queries Machine B's " +
+            "Progress via convert_witness (TypeOrderProgress=100/103). Machine B must be published " +
+            "before Progress can be created (progress::new -> assert_published).",
+        code_reference: "progress.move (progress::new, assert_published) + guard.move (convert_witness)",
+        affected_modes: ["cross_machine", "pre_publish_check"],
+    },
+];
+export function getMachineKnowledgeSnapshot() {
+    const verifiedYes = MACHINE_VERIFICATION_NOTES.filter((n) => n.judgment === "YES").length;
+    const verifiedPartial = MACHINE_VERIFICATION_NOTES.filter((n) => n.judgment === "PARTIAL").length;
+    const verifiedNo = MACHINE_VERIFICATION_NOTES.filter((n) => n.judgment === "NO").length;
+    return {
+        version: MACHINE_CONTEXT_VERSION,
+        modules: {
+            ledger: MACHINE_LEDGER_VERSION,
+            templates: MACHINE_TEMPLATES_VERSION,
+            translation: MACHINE_TRANSLATION_VERSION,
+            risk: MACHINE_RISK_VERSION,
+            topology: MACHINE_TOPOLOGY_VERSION,
+            puzzle: MACHINE_PUZZLE_VERSION,
+            confirm: MACHINE_CONFIRM_VERSION,
+        },
+        counts: {
+            scenes: MACHINE_SCENES_COUNT,
+            templates: MACHINE_TEMPLATES.length,
+            patterns: SEMANTIC_TO_MACHINE_RULES.length,
+            constraints: MACHINE_CONSTRAINT_RULES.length,
+            risk_rules: MACHINE_RISK_RULES.length,
+            puzzle_dimensions: 8,
+            publish_checklist_items: PUBLISH_CHECKLIST.length,
+            confirmation_questions: CONFIRMATION_QUESTIONS.length,
+            verification_notes: MACHINE_VERIFICATION_NOTES.length,
+        },
+        verification_summary: {
+            total_topics: MACHINE_VERIFICATION_NOTES.length,
+            verified_yes: verifiedYes,
+            verified_partial: verifiedPartial,
+            verified_no: verifiedNo,
+            topics: MACHINE_VERIFICATION_NOTES,
+        },
+        guard_bridge: {
+            available: true,
+            guard_scenes_count: GUARD_SCENES.length,
+        },
+        on_chain_limits: {
+            max_node_count: 100,
+            max_node_pair_count: 40,
+            max_forward_count: 20,
+        },
+    };
+}
+export function injectMachineContext(intent, mode, options = {}) {
+    const maxTemplates = options.max_templates ?? 3;
+    const maxConstraints = options.max_constraints ?? 10;
+    const maxRisks = options.max_risks ?? 10;
+    const includeNotes = options.include_verification_notes ?? true;
+    const includeGuardBridge = options.include_guard_bridge ?? mode === "guard_integration";
+    const matchedScene = inferSceneFromFlow(intent);
+    let suggestedTemplates = [];
+    if (matchedScene) {
+        suggestedTemplates = getTemplatesByScene(matchedScene.id).slice(0, maxTemplates);
+    }
+    if (suggestedTemplates.length === 0) {
+        const intentSuggestion = suggestTemplateForIntent(intent);
+        if (intentSuggestion) {
+            suggestedTemplates = [intentSuggestion].slice(0, maxTemplates);
+        }
+    }
+    if (suggestedTemplates.length === 0) {
+        suggestedTemplates = getAllTemplates().slice(0, maxTemplates);
+    }
+    let relevantPatterns = [...SEMANTIC_TO_MACHINE_RULES];
+    if (options.filter_execution_mode) {
+        const modeToId = {
+            "Sequential": "P-M-SEQ",
+            "Parallel AND": "P-M-AND",
+            "Parallel OR": "P-M-OR",
+            "Weighted Voting": "P-M-VOTE",
+            "Hybrid": "P-M-HYBRID",
+        };
+        const expectedId = modeToId[options.filter_execution_mode];
+        if (expectedId) {
+            relevantPatterns = relevantPatterns.filter((p) => p.id === expectedId);
+        }
+    }
+    if (options.filter_topology) {
+        const topoToId = {
+            "Linear": "P-M-LINEAR",
+            "ForkMerge": "P-M-FORKMERGE",
+            "Competing": "P-M-COMPETING",
+        };
+        const expectedId = topoToId[options.filter_topology];
+        if (expectedId) {
+            relevantPatterns = relevantPatterns.filter((p) => p.id === expectedId);
+        }
+    }
+    relevantPatterns = filterPatternsByMode(relevantPatterns, mode);
+    let relevantConstraints = filterConstraintsByMode(MACHINE_CONSTRAINT_RULES, mode);
+    relevantConstraints = relevantConstraints.slice(0, maxConstraints);
+    let relevantRisks = filterRisksByMode(MACHINE_RISK_RULES, mode);
+    relevantRisks = relevantRisks.slice(0, maxRisks);
+    let puzzleState;
+    let puzzleCompleteness;
+    if (options.existing_puzzle) {
+        puzzleState = options.existing_puzzle;
+        puzzleCompleteness = checkPuzzleCompleteness(options.existing_puzzle);
+    }
+    else if (mode === "initial_design" || mode === "intent_match") {
+        puzzleState = initPuzzleFromIntent(intent);
+        puzzleCompleteness = checkPuzzleCompleteness(puzzleState);
+    }
+    let topologyAnalysis;
+    if (options.existing_machine_json) {
+        topologyAnalysis = analyzeTopology(options.existing_machine_json.nodes, options.existing_machine_json.pairs);
+    }
+    let riskAssessment;
+    if (options.existing_machine_json && options.project_context) {
+        const machineForRisk = {
+            nodes: options.existing_machine_json.nodes,
+            pairs: options.existing_machine_json.pairs,
+        };
+        riskAssessment = assessMachineRisks(machineForRisk, options.project_context);
+    }
+    let progressiveCheckResult;
+    if (mode === "pre_publish_check" && options.existing_machine_json) {
+        const machineForConfirm = {
+            nodes: options.existing_machine_json.nodes,
+            pairs: options.existing_machine_json.pairs,
+            template_id: options.existing_machine_json.template_id,
+            scene_id: options.existing_machine_json.scene_id,
+        };
+        progressiveCheckResult = progressiveCheck(machineForConfirm, "R5");
+    }
+    let guardBridge;
+    if (includeGuardBridge && matchedScene) {
+        guardBridge = buildGuardBridge(matchedScene);
+    }
+    let verificationNotes = [];
+    if (includeNotes) {
+        verificationNotes = MACHINE_VERIFICATION_NOTES.filter((n) => n.affected_modes.includes(mode));
+    }
+    const promptHints = buildPromptHints({
+        mode,
+        matched_scene: matchedScene,
+        suggested_templates: suggestedTemplates,
+        relevant_patterns: relevantPatterns,
+        relevant_constraints: relevantConstraints,
+        relevant_risks: relevantRisks,
+        puzzle_state: puzzleState,
+        puzzle_completeness: puzzleCompleteness,
+        topology_analysis: topologyAnalysis,
+        risk_assessment: riskAssessment,
+        progressive_check_result: progressiveCheckResult,
+        guard_bridge: guardBridge,
+        verification_notes: verificationNotes,
+    });
+    const recommendedNextAction = recommendNextAction(mode, {
+        matched_scene: matchedScene,
+        suggested_templates: suggestedTemplates,
+        puzzle_completeness: puzzleCompleteness,
+        risk_assessment: riskAssessment,
+        progressive_check_result: progressiveCheckResult,
+    });
+    return {
+        mode,
+        version: MACHINE_CONTEXT_VERSION,
+        matched_scene: matchedScene ?? undefined,
+        suggested_templates: suggestedTemplates,
+        relevant_patterns: relevantPatterns,
+        relevant_constraints: relevantConstraints,
+        relevant_risks: relevantRisks,
+        puzzle_state: puzzleState,
+        puzzle_completeness: puzzleCompleteness,
+        topology_analysis: topologyAnalysis,
+        risk_assessment: riskAssessment,
+        progressive_check_result: progressiveCheckResult,
+        guard_bridge: guardBridge,
+        prompt_hints: promptHints,
+        verification_notes: verificationNotes,
+        recommended_next_action: recommendedNextAction,
+    };
+}
+export function suggestWorkflow(intent) {
+    const matchedScene = inferSceneFromFlow(intent);
+    const confidence = matchedScene ? 0.8 : 0.3;
+    const suggestedTemplates = [];
+    if (matchedScene) {
+        const sceneTemplates = getTemplatesByScene(matchedScene.id);
+        for (const t of sceneTemplates.slice(0, 3)) {
+            suggestedTemplates.push({
+                template: t,
+                rationale: `Template for scene "${matchedScene.name}"`,
+            });
+        }
+    }
+    if (suggestedTemplates.length === 0) {
+        const t = suggestTemplateForIntent(intent);
+        if (t) {
+            suggestedTemplates.push({
+                template: t,
+                rationale: "Intent keyword match",
+            });
+        }
+    }
+    if (suggestedTemplates.length === 0) {
+        const all = getAllTemplates();
+        if (all.length > 0) {
+            suggestedTemplates.push({
+                template: all[0],
+                rationale: "Default (no specific match)",
+            });
+        }
+    }
+    let initialPuzzle;
+    if (suggestedTemplates.length > 0) {
+        const fromTemplate = initPuzzleFromTemplate(suggestedTemplates[0].template.id);
+        initialPuzzle = fromTemplate ?? initPuzzleFromIntent(intent);
+    }
+    else {
+        initialPuzzle = initPuzzleFromIntent(intent);
+    }
+    const matchedPattern = matchSemanticPattern(intent);
+    const recommendedPattern = matchedPattern ?? null;
+    let recommendedTopology = null;
+    if (matchedScene && matchedScene.recommended_topology.length > 0) {
+        recommendedTopology = matchedScene.recommended_topology[0];
+    }
+    const completeness = checkPuzzleCompleteness(initialPuzzle);
+    const nextStep = completeness.next_step;
+    return {
+        matched_scene: matchedScene ?? null,
+        confidence,
+        suggested_templates: suggestedTemplates,
+        initial_puzzle: initialPuzzle,
+        recommended_pattern: recommendedPattern,
+        recommended_topology: recommendedTopology,
+        next_step: nextStep,
+    };
+}
+export function buildPromptFromContext(bundle) {
+    const lines = [];
+    lines.push(`# Machine Design Context (mode: ${bundle.mode})`);
+    lines.push("");
+    lines.push("> Context injected by machine-context.ts. Reflects verified on-chain behavior.");
+    lines.push("");
+    if (bundle.matched_scene) {
+        lines.push("## Matched Scene");
+        lines.push("");
+        lines.push(`- **ID**: ${bundle.matched_scene.id}`);
+        lines.push(`- **Name**: ${bundle.matched_scene.name}`);
+        lines.push(`- **Scenario**: ${bundle.matched_scene.scenario}`);
+        lines.push(`- **Industry**: ${bundle.matched_scene.industry.join(", ")}`);
+        lines.push(`- **Recommended patterns**: ${bundle.matched_scene.recommended_patterns.join(", ")}`);
+        lines.push(`- **Recommended topology**: ${bundle.matched_scene.recommended_topology.join(", ")}`);
+        lines.push("");
+    }
+    if (bundle.suggested_templates.length > 0) {
+        lines.push("## Suggested Templates");
+        lines.push("");
+        for (const t of bundle.suggested_templates) {
+            lines.push(`### ${t.id}: ${t.name}`);
+            lines.push("");
+            lines.push(`- **Scene**: ${t.scene_id}`);
+            lines.push(`- **Description**: ${t.description}`);
+            if (t.parameters.length > 0) {
+                lines.push(`- **Parameters**:`);
+                for (const p of t.parameters) {
+                    lines.push(`  - \`${p.name}\` (${p.type}): ${p.description}`);
+                }
+            }
+            lines.push("");
+        }
+    }
+    if (bundle.relevant_patterns.length > 0) {
+        lines.push("## Relevant Patterns");
+        lines.push("");
+        for (const p of bundle.relevant_patterns) {
+            lines.push(`### ${p.id}: ${p.pattern_name}`);
+            lines.push("");
+            lines.push(`- **Category**: ${p.category}`);
+            lines.push(`- **Intent**: ${p.semantic_intent}`);
+            if (p.match_keywords.length > 0) {
+                lines.push(`- **Keywords**: ${p.match_keywords.join(", ")}`);
+            }
+            lines.push("");
+        }
+    }
+    if (bundle.relevant_constraints.length > 0) {
+        lines.push("## Relevant Constraints");
+        lines.push("");
+        for (const c of bundle.relevant_constraints) {
+            lines.push(`- **${c.id}** (${c.category}, ${c.on_chain_enforced ? "on-chain" : "off-chain"}): ${c.description}`);
+        }
+        lines.push("");
+    }
+    if (bundle.relevant_risks.length > 0) {
+        lines.push("## Relevant Risks");
+        lines.push("");
+        for (const r of bundle.relevant_risks) {
+            lines.push(`- **${r.id}** [${r.severity}] ${r.name}: ${r.description}`);
+            lines.push(`  - Fix: ${r.recommendation}`);
+        }
+        lines.push("");
+    }
+    if (bundle.puzzle_state && bundle.puzzle_completeness) {
+        lines.push("## Puzzle State");
+        lines.push("");
+        lines.push(`- **Complete**: ${bundle.puzzle_completeness.complete}`);
+        lines.push(`- **Next step**: ${bundle.puzzle_completeness.next_step}`);
+        lines.push("");
+        lines.push("### Per-dimension completeness:");
+        for (const d of bundle.puzzle_completeness.dimensions) {
+            const mark = d.complete ? "✓" : "✗";
+            lines.push(`  - ${mark} ${d.dimension}`);
+            if (!d.complete && d.missing_fields.length > 0) {
+                lines.push(`    - Missing: ${d.missing_fields.join(", ")}`);
+            }
+        }
+        lines.push("");
+    }
+    if (bundle.topology_analysis) {
+        lines.push("## Topology Analysis");
+        lines.push("");
+        lines.push("```");
+        lines.push(formatTopologySummary(bundle.topology_analysis));
+        lines.push("```");
+        lines.push("");
+    }
+    if (bundle.risk_assessment) {
+        lines.push("## Risk Assessment");
+        lines.push("");
+        lines.push(`- **Overall level**: ${bundle.risk_assessment.overall_level}`);
+        lines.push(`- **Recommendation**: ${bundle.risk_assessment.recommendation}`);
+        lines.push(`- **Summary**: ${JSON.stringify(bundle.risk_assessment.summary)}`);
+        if (bundle.risk_assessment.detected_risks.length > 0) {
+            lines.push("");
+            lines.push("### Detected risks:");
+            for (const r of bundle.risk_assessment.detected_risks) {
+                lines.push(`- [${r.severity}] ${r.name}: ${r.detail}`);
+            }
+        }
+        lines.push("");
+    }
+    if (bundle.progressive_check_result) {
+        const r = bundle.progressive_check_result;
+        lines.push("## Progressive Checklist Result (R5)");
+        lines.push("");
+        lines.push(`- **Passed**: ${r.passed}`);
+        if (r.checked_items.length > 0) {
+            lines.push("");
+            lines.push("### Checked items:");
+            for (const item of r.checked_items) {
+                lines.push(`  - [${item.status}] ${item.id}: ${item.description}`);
+                if (item.detail) {
+                    lines.push(`    - ${item.detail}`);
+                }
+            }
+        }
+        lines.push("");
+    }
+    if (bundle.guard_bridge) {
+        lines.push("## Guard Bridge");
+        lines.push("");
+        lines.push(`Machine scene \`${bundle.guard_bridge.machine_scene_id}\` relates to:`);
+        lines.push("");
+        for (const m of bundle.guard_bridge.forward_guard_mapping) {
+            lines.push(`- Forward "${m.forward_purpose}" → Guard scene \`${m.guard_scene_id}\` (${m.guard_scene_name})`);
+        }
+        lines.push("");
+    }
+    if (bundle.prompt_hints.length > 0) {
+        lines.push("## Prompt Hints");
+        lines.push("");
+        for (const h of bundle.prompt_hints) {
+            lines.push(`- ${h}`);
+        }
+        lines.push("");
+    }
+    if (bundle.verification_notes.length > 0) {
+        lines.push("## Verification Notes (06 §14)");
+        lines.push("");
+        lines.push("> These notes reflect code-level verification of on-chain behavior.");
+        for (const n of bundle.verification_notes) {
+            lines.push("");
+            lines.push(`- **${n.topic}** (${n.judgment}): ${n.verified_semantic}`);
+            lines.push(`  - Code reference: \`${n.code_reference}\``);
+        }
+        lines.push("");
+    }
+    lines.push("## Recommended Next Action");
+    lines.push("");
+    lines.push(bundle.recommended_next_action);
+    lines.push("");
+    return lines.join("\n");
+}
+export function getRelatedGuardScenes(machineSceneId) {
+    const machineScene = findScene(machineSceneId);
+    if (!machineScene) {
+        return [];
+    }
+    const relatedGuardSceneIds = new Set();
+    for (const req of machineScene.guard_requirements) {
+        relatedGuardSceneIds.add(req.scene);
+    }
+    return GUARD_SCENES.filter((g) => relatedGuardSceneIds.has(g.id));
+}
+export function getVerificationNotes(mode) {
+    if (!mode) {
+        return MACHINE_VERIFICATION_NOTES;
+    }
+    return MACHINE_VERIFICATION_NOTES.filter((n) => n.affected_modes.includes(mode));
+}
+export function identifyCrossMachineDependency(machineAId, machineJson, guardResolutions, publishedMachineIds) {
+    const deps = [];
+    for (const pair of machineJson.pairs) {
+        const pairId = `${pair.prev_node}->${pair.next_node}`;
+        for (const forward of pair.forwards) {
+            if (!forward.guard)
+                continue;
+            const resolution = guardResolutions.get(forward.guard);
+            if (!resolution)
+                continue;
+            deps.push({
+                machine_a_id: machineAId,
+                machine_b_id: resolution.upstream_machine_id,
+                machine_b_published: publishedMachineIds
+                    ? publishedMachineIds.has(resolution.upstream_machine_id)
+                    : false,
+                dependency: {
+                    machine_a_forward: `${pairId}:${forward.name}`,
+                    machine_b_node: resolution.upstream_node_name,
+                },
+                guard_query: resolution.guard_query_description,
+            });
+        }
+    }
+    return deps;
+}
+export function detectCrossMachineCycle(allDependencies) {
+    const adj = new Map();
+    for (const dep of allDependencies) {
+        if (!adj.has(dep.machine_a_id))
+            adj.set(dep.machine_a_id, new Set());
+        adj.get(dep.machine_a_id).add(dep.machine_b_id);
+        if (!adj.has(dep.machine_b_id))
+            adj.set(dep.machine_b_id, new Set());
+    }
+    const cycles = [];
+    const WHITE = 0, GRAY = 1, BLACK = 2;
+    const color = new Map();
+    for (const node of adj.keys())
+        color.set(node, WHITE);
+    const stack = [];
+    const dfs = (node) => {
+        color.set(node, GRAY);
+        stack.push(node);
+        const neighbors = adj.get(node) ?? new Set();
+        for (const next of neighbors) {
+            const nextColor = color.get(next) ?? WHITE;
+            if (nextColor === GRAY) {
+                const cycleStart = stack.indexOf(next);
+                const cycle = stack.slice(cycleStart).concat([next]);
+                cycles.push(cycle);
+            }
+            else if (nextColor === WHITE) {
+                dfs(next);
+            }
+        }
+        stack.pop();
+        color.set(node, BLACK);
+    };
+    for (const node of adj.keys()) {
+        if (color.get(node) === WHITE) {
+            dfs(node);
+        }
+    }
+    return cycles;
+}
+export function aggregateProjectDependencies(machines, publishedMachineIds) {
+    const all = [];
+    for (const m of machines) {
+        const deps = identifyCrossMachineDependency(m.machine_id, m.machine_json, m.guard_resolutions, publishedMachineIds);
+        all.push(...deps);
+    }
+    return all;
+}
+function filterPatternsByMode(patterns, mode) {
+    switch (mode) {
+        case "cross_machine":
+            return patterns.filter((p) => p.id === "P-M-CROSS-MACHINE");
+        case "allocation_integration":
+            return patterns.filter((p) => p.id === "P-M-ALLOCATION-INTEGRATED");
+        case "guard_integration":
+            return patterns.filter((p) => p.match_keywords.some((k) => ["guard", "validation"].some((term) => k.toLowerCase().includes(term.toLowerCase()))) ||
+                p.semantic_intent.toLowerCase().includes("guard"));
+        case "post_publish_runtime":
+            return patterns.filter((p) => p.category === "execution" &&
+                ["and", "or", "vote", "hybrid"].some((term) => p.pattern_name.toLowerCase().includes(term)));
+        default:
+            return patterns;
+    }
+}
+function filterConstraintsByMode(constraints, mode) {
+    switch (mode) {
+        case "initial_design":
+        case "intent_match":
+            return constraints.filter((c) => c.category === "creation");
+        case "mid_design_review":
+            return constraints.filter((c) => ["creation", "structure", "node_operation"].includes(c.category));
+        case "pre_publish_check":
+            return constraints.filter((c) => ["publish", "structure", "node_operation"].includes(c.category));
+        case "post_publish_runtime":
+            return constraints.filter((c) => c.category === "runtime");
+        case "cross_machine":
+            return constraints.filter((c) => ["structure", "publish"].includes(c.category));
+        case "guard_integration":
+            return constraints.filter((c) => c.description.toLowerCase().includes("guard") ||
+                c.description.toLowerCase().includes("forward"));
+        case "allocation_integration":
+            return constraints.filter((c) => c.description.toLowerCase().includes("allocator") ||
+                c.description.toLowerCase().includes("terminal") ||
+                c.description.toLowerCase().includes("allocation"));
+        default:
+            return constraints;
+    }
+}
+function filterRisksByMode(risks, mode) {
+    switch (mode) {
+        case "initial_design":
+        case "intent_match":
+            return risks.filter((r) => ["structural", "permission"].includes(r.category));
+        case "mid_design_review":
+            return risks.filter((r) => ["structural", "guard_integration", "permission"].includes(r.category));
+        case "pre_publish_check":
+            return risks
+                .slice()
+                .sort((a, b) => severityRank(b.severity) - severityRank(a.severity));
+        case "post_publish_runtime":
+            return risks.filter((r) => r.category === "environment");
+        case "cross_machine":
+            return risks.filter((r) => r.category === "guard_integration");
+        case "guard_integration":
+            return risks.filter((r) => r.category === "guard_integration");
+        case "allocation_integration":
+            return risks.filter((r) => r.description.toLowerCase().includes("allocator") ||
+                r.description.toLowerCase().includes("allocation") ||
+                r.description.toLowerCase().includes("terminal"));
+        default:
+            return risks;
+    }
+}
+function severityRank(s) {
+    switch (s) {
+        case "critical": return 5;
+        case "high": return 4;
+        case "medium": return 3;
+        case "low": return 2;
+    }
+}
+function buildGuardBridge(machineScene) {
+    const guardSceneIds = new Set();
+    const forwardGuardMapping = [];
+    for (const req of machineScene.guard_requirements) {
+        guardSceneIds.add(req.scene);
+        const guardScene = GUARD_SCENES.find((g) => g.id === req.scene);
+        forwardGuardMapping.push({
+            forward_purpose: req.purpose,
+            guard_scene_id: req.scene,
+            guard_scene_name: guardScene?.name || req.scene,
+        });
+    }
+    const guardScenes = GUARD_SCENES.filter((g) => guardSceneIds.has(g.id));
+    return {
+        machine_scene_id: machineScene.id,
+        guard_scenes: guardScenes,
+        forward_guard_mapping: forwardGuardMapping,
+    };
+}
+function buildPromptHints(ctx) {
+    const hints = [];
+    switch (ctx.mode) {
+        case "initial_design":
+        case "intent_match":
+            hints.push("Start by confirming the matched scene and selecting a template.");
+            if (ctx.matched_scene) {
+                hints.push(`Scene "${ctx.matched_scene.name}" recommends patterns: ${ctx.matched_scene.recommended_patterns.join(", ")}.`);
+            }
+            if (ctx.suggested_templates.length > 0) {
+                hints.push(`Top template suggestion: ${ctx.suggested_templates[0].id} (${ctx.suggested_templates[0].name}).`);
+            }
+            break;
+        case "mid_design_review":
+            if (ctx.puzzle_completeness) {
+                if (ctx.puzzle_completeness.complete) {
+                    hints.push("Puzzle is complete. Proceed to pre-publish check.");
+                }
+                else {
+                    hints.push(`Puzzle incomplete. Next step: ${ctx.puzzle_completeness.next_step}`);
+                }
+            }
+            if (ctx.topology_analysis) {
+                if (ctx.topology_analysis.has_cycles) {
+                    hints.push("⚠ Cycle detected in topology — must fix before publish.");
+                }
+                if (ctx.topology_analysis.orphaned_nodes.length > 0) {
+                    hints.push(`⚠ Orphaned nodes: ${ctx.topology_analysis.orphaned_nodes.join(", ")}`);
+                }
+            }
+            break;
+        case "pre_publish_check":
+            if (ctx.risk_assessment) {
+                if (ctx.risk_assessment.overall_level === "critical") {
+                    hints.push("⛔ CRITICAL risk detected — DO NOT publish until resolved.");
+                }
+                else if (ctx.risk_assessment.overall_level === "high") {
+                    hints.push("⚠ HIGH risk — fix before publish or override with explicit reason.");
+                }
+                hints.push(`Risk recommendation: ${ctx.risk_assessment.recommendation}`);
+            }
+            if (ctx.progressive_check_result) {
+                if (!ctx.progressive_check_result.passed) {
+                    const failed = ctx.progressive_check_result.checked_items
+                        .filter((i) => i.status !== "pass")
+                        .map((i) => i.id);
+                    hints.push(`⛔ Pre-publish checklist FAILED on: ${failed.join(", ") || "see details"}`);
+                }
+                else {
+                    hints.push("✓ Pre-publish checklist (R5) passed.");
+                }
+            }
+            hints.push("Run full confirmPublish() with user confirmation before any on-chain publish transaction.");
+            break;
+        case "post_publish_runtime":
+            hints.push("Machine is already published — nodes cannot be modified.");
+            hints.push("Only progress advancement (Forward execution) is possible.");
+            if (ctx.topology_analysis) {
+                hints.push(`Current topology: ${ctx.topology_analysis.within_limits ? "within on-chain limits" : "EXCEEDS limits"}`);
+            }
+            break;
+        case "cross_machine":
+            hints.push("Cross-Machine dependency is INDIRECT: Machine A queries Machine B's Progress via convert_witness.");
+            hints.push("Machine B MUST be published before Progress::new can create a Progress for it (assert_published).");
+            hints.push("Use convert_witness TypeOrderProgress (100) or TypeOrderProgressSession (103) in Guard queries.");
+            break;
+        case "guard_integration":
+            if (ctx.guard_bridge) {
+                hints.push(`This scene integrates with ${ctx.guard_bridge.guard_scenes.length} Guard scene(s).`);
+                for (const m of ctx.guard_bridge.forward_guard_mapping) {
+                    hints.push(`  - Forward "${m.forward_purpose}" → Guard scene: ${m.guard_scene_name}`);
+                }
+            }
+            hints.push("Forward.guard cannot be modified after Machine publish (immutable).");
+            hints.push("Use machine_forward_guard scene from guard-ledger.ts for Guard design.");
+            break;
+        case "allocation_integration":
+            hints.push("Terminal nodes map to Service order_allocators.");
+            hints.push("order_allocators is order-sensitive (first-match-wins).");
+            hints.push("Each Allocator requires a UNIQUE Guard object (no two allocators may share the same Guard).");
+            hints.push("order_allocators CANNOT be modified after Service publish (immutable).");
+            break;
+    }
+    for (const n of ctx.verification_notes) {
+        hints.push(`[Verified ${n.judgment}] ${n.topic}: ${n.verified_semantic}`);
+    }
+    hints.push(`On-chain limits: MAX_NODE_COUNT=${MAX_NODE_COUNT}, MAX_NODE_PAIR_COUNT=${MAX_NODE_PAIR_COUNT}, MAX_FORWARD_COUNT=${MAX_FORWARD_COUNT}.`);
+    return hints;
+}
+function recommendNextAction(mode, ctx) {
+    switch (mode) {
+        case "initial_design":
+        case "intent_match": {
+            if (!ctx.matched_scene) {
+                return "Ask the user to clarify the business scenario — no scene matched.";
+            }
+            if (ctx.suggested_templates.length === 0) {
+                return `Scene "${ctx.matched_scene.name}" matched but no template available — design Machine manually using the scene's recommended patterns.`;
+            }
+            return `Present template "${ctx.suggested_templates[0].id}" to user. After user confirms, fill parameters and initialize puzzle.`;
+        }
+        case "mid_design_review": {
+            if (!ctx.puzzle_completeness) {
+                return "Initialize puzzle state and re-run injection with existing_puzzle option.";
+            }
+            if (ctx.puzzle_completeness.complete) {
+                return "Puzzle complete. Proceed to pre_publish_check mode.";
+            }
+            return `Complete missing puzzle dimensions: ${ctx.puzzle_completeness.next_step}`;
+        }
+        case "pre_publish_check": {
+            if (ctx.progressive_check_result && !ctx.progressive_check_result.passed) {
+                const failedIds = ctx.progressive_check_result.failed_items
+                    .map((i) => i.id)
+                    .join(", ");
+                return `⛔ Pre-publish checklist FAILED on: ${failedIds || "see checklist result"}. Fix these items before proceeding.`;
+            }
+            if (ctx.risk_assessment) {
+                if (ctx.risk_assessment.overall_level === "critical") {
+                    return "⛔ CRITICAL risk — DO NOT publish. Fix risks first.";
+                }
+                if (ctx.risk_assessment.overall_level === "high") {
+                    return "⚠ HIGH risk — fix risks OR obtain explicit user override with reason.";
+                }
+            }
+            return "All checks passed. Present confirmation text to user and obtain explicit approval before publish transaction.";
+        }
+        case "post_publish_runtime":
+            return "Machine is published. Use onchain_operations to execute Forward advancements. Monitor Progress state via query tool.";
+        case "cross_machine":
+            return "Design Machine A's Forward.guard to query Machine B's Progress via convert_witness=100. Ensure Machine B is published first.";
+        case "guard_integration":
+            return "For each Forward.guard binding, design the Guard using the related Guard scene. Use guard-ledger + guard-templates + guard-puzzle modules.";
+        case "allocation_integration":
+            return "Map each terminal node to an Allocator in Service.order_allocators. Each Allocator needs a unique Guard object. Configure sharing.who (prefer Entity over Signer).";
+        default:
+            return "Proceed with current task.";
+    }
+}
+export const CONTEXT_PRESETS = {
+    newUserIntent: (intent) => injectMachineContext(intent, "intent_match", {
+        max_templates: 2,
+        max_constraints: 5,
+        max_risks: 3,
+        include_verification_notes: false,
+        include_guard_bridge: false,
+    }),
+    midDesignReview: (intent, puzzle) => injectMachineContext(intent, "mid_design_review", {
+        max_templates: 1,
+        max_constraints: 15,
+        max_risks: 10,
+        include_verification_notes: true,
+        include_guard_bridge: false,
+        existing_puzzle: puzzle,
+    }),
+    prePublishFull: (intent, machineJson, projectContext) => injectMachineContext(intent, "pre_publish_check", {
+        max_templates: 0,
+        max_constraints: 20,
+        max_risks: 39,
+        include_verification_notes: true,
+        include_guard_bridge: true,
+        existing_machine_json: machineJson,
+        project_context: projectContext,
+    }),
+    crossMachine: (intent) => injectMachineContext(intent, "cross_machine", {
+        max_templates: 2,
+        max_constraints: 10,
+        max_risks: 8,
+        include_verification_notes: true,
+        include_guard_bridge: true,
+    }),
+    guardIntegration: (intent) => injectMachineContext(intent, "guard_integration", {
+        max_templates: 1,
+        max_constraints: 10,
+        max_risks: 8,
+        include_verification_notes: true,
+        include_guard_bridge: true,
+    }),
+    allocationIntegration: (intent) => injectMachineContext(intent, "allocation_integration", {
+        max_templates: 1,
+        max_constraints: 8,
+        max_risks: 8,
+        include_verification_notes: false,
+        include_guard_bridge: false,
+    }),
+};