muonroi-cli 1.8.4 → 1.9.0

package/dist/src/gsd/capability-registry.js

@@ -0,0 +1,337 @@
+/**
+ * capability-registry.ts — Native vendored byLoopPoint data from gsd-core
+ *
+ * ADR-894 §5 — role-partitioned Capability Registry.
+ * Contains the byLoopPoint data used by the loop resolver.
+ * This is the frozen first-party registry used as the fallback default.
+ */
+const byLoopPoint = {
+    "discuss:pre": {
+        steps: [],
+        contributions: [
+            {
+                capId: "mempalace",
+                kind: "contribution",
+                point: "discuss:pre",
+                into: "orchestrator",
+                fragment: {
+                    path: "fragments/recall-discuss.md",
+                    inline: `<!--\n  MemPalace capability — contribution fragment.\n  Rendered into the discuss:pre orchestrator prompt when \`mempalace.recall_on_discuss\` is true.\n  Contributes DATA (recall instructions), not control flow. onError: skip — never blocks discussion.\n-->\n### Memory recall (MemPalace)\n\n...contribution content elided for brevity...`,
+                },
+                produces: [],
+                consumes: [],
+                when: "mempalace.enabled",
+                onError: "skip",
+            },
+        ],
+        gates: [],
+    },
+    "discuss:post": {
+        steps: [
+            {
+                capId: "mempalace",
+                kind: "step",
+                point: "discuss:post",
+                ref: { skill: "mempalace-capture" },
+                produces: [],
+                consumes: ["CONTEXT.md"],
+                when: "mempalace.enabled",
+                onError: "skip",
+            },
+        ],
+        contributions: [],
+        gates: [],
+    },
+    "plan:pre": {
+        steps: [
+            {
+                capId: "ai-integration",
+                kind: "step",
+                point: "plan:pre",
+                ref: { skill: "ai-integration-phase" },
+                produces: ["AI-SPEC.md"],
+                consumes: ["CONTEXT.md"],
+                when: "workflow.ai_integration_phase",
+                onError: "skip",
+            },
+            {
+                capId: "intel",
+                kind: "step",
+                point: "plan:pre",
+                ref: { command: "intel api-surface" },
+                produces: [".planning/intel/API-SURFACE.md"],
+                consumes: [],
+                when: "intel.enabled",
+                onError: "skip",
+            },
+            {
+                capId: "mempalace",
+                kind: "step",
+                point: "plan:pre",
+                ref: { skill: "mempalace-recall" },
+                produces: ["MEMORY-RECALL.md"],
+                consumes: ["CONTEXT.md"],
+                when: "mempalace.enabled",
+                onError: "skip",
+            },
+            {
+                capId: "research",
+                kind: "step",
+                point: "plan:pre",
+                ref: { agent: "gsd-phase-researcher" },
+                produces: ["RESEARCH.md"],
+                consumes: ["CONTEXT.md"],
+                when: "workflow.research",
+                onError: "skip",
+            },
+            {
+                capId: "ui",
+                kind: "step",
+                point: "plan:pre",
+                ref: { skill: "ui-phase" },
+                produces: ["UI-SPEC.md"],
+                consumes: ["CONTEXT.md"],
+                when: "workflow.ui_phase",
+                onError: "skip",
+            },
+            {
+                capId: "pattern-mapper",
+                kind: "step",
+                point: "plan:pre",
+                ref: { agent: "gsd-pattern-mapper" },
+                produces: ["PATTERNS.md"],
+                consumes: ["RESEARCH.md"],
+                when: "workflow.pattern_mapper",
+                onError: "skip",
+            },
+            {
+                capId: "schema-gate",
+                kind: "step",
+                point: "plan:pre",
+                ref: { skill: "schema-gate" },
+                produces: [],
+                consumes: ["CONTEXT.md"],
+                when: "workflow.schema_gate",
+                onError: "halt",
+            },
+        ],
+        contributions: [
+            {
+                capId: "assumption-delta",
+                kind: "contribution",
+                point: "plan:pre",
+                into: "planner",
+                fragment: { path: "fragments/plan-pre.md" },
+                produces: [],
+                consumes: ["CONTEXT.md"],
+                when: "workflow.assumption_delta",
+                onError: "skip",
+            },
+        ],
+        gates: [],
+    },
+    "plan:post": {
+        steps: [
+            {
+                capId: "nyquist",
+                kind: "step",
+                point: "plan:post",
+                ref: { skill: "validate-phase" },
+                produces: ["VALIDATION.md"],
+                consumes: ["PLAN.md"],
+                when: "workflow.nyquist_validation",
+                onError: "halt",
+            },
+        ],
+        contributions: [],
+        gates: [],
+    },
+    "execute:pre": {
+        steps: [],
+        contributions: [],
+        gates: [],
+    },
+    "execute:wave:pre": {
+        steps: [],
+        contributions: [],
+        gates: [],
+    },
+    "execute:wave:post": {
+        steps: [],
+        contributions: [
+            {
+                capId: "mempalace",
+                kind: "contribution",
+                point: "execute:wave:post",
+                into: "verifier",
+                fragment: { path: "fragments/capture-problems.md" },
+                produces: [],
+                consumes: [],
+                when: "mempalace.enabled",
+                onError: "skip",
+            },
+        ],
+        gates: [
+            {
+                capId: "drift",
+                kind: "gate",
+                point: "execute:wave:post",
+                check: { query: "verify.schema-drift" },
+                when: "workflow.schema_drift_gate",
+                blocking: true,
+                onError: "skip",
+            },
+            {
+                capId: "drift",
+                kind: "gate",
+                point: "execute:wave:post",
+                check: { query: "verify.codebase-drift" },
+                when: "workflow.schema_drift_gate",
+                blocking: false,
+                onError: "skip",
+            },
+            {
+                capId: "ui",
+                kind: "gate",
+                point: "execute:wave:post",
+                check: { query: "ui.safety-gate" },
+                when: "workflow.ui_safety_gate",
+                blocking: true,
+                onError: "halt",
+            },
+        ],
+    },
+    "execute:post": {
+        steps: [
+            {
+                capId: "code-review",
+                kind: "step",
+                point: "execute:post",
+                ref: { skill: "code-review" },
+                produces: ["REVIEW.md"],
+                consumes: ["SUMMARY.md"],
+                when: "workflow.code_review",
+                onError: "skip",
+            },
+        ],
+        contributions: [],
+        gates: [
+            {
+                capId: "tdd",
+                kind: "gate",
+                point: "execute:post",
+                check: { query: "tdd.review-checkpoint" },
+                when: "workflow.tdd_mode",
+                blocking: false,
+                onError: "skip",
+            },
+        ],
+    },
+    "verify:pre": {
+        steps: [],
+        contributions: [],
+        gates: [],
+    },
+    "verify:post": {
+        steps: [
+            {
+                capId: "mempalace",
+                kind: "step",
+                point: "verify:post",
+                ref: { skill: "mempalace-capture" },
+                produces: [],
+                consumes: ["SUMMARY.md"],
+                when: "mempalace.enabled",
+                onError: "skip",
+            },
+            {
+                capId: "nyquist",
+                kind: "step",
+                point: "verify:post",
+                ref: { skill: "validate-phase" },
+                produces: ["VALIDATION.md"],
+                consumes: ["SUMMARY.md"],
+                when: "workflow.nyquist_validation",
+                onError: "halt",
+            },
+            {
+                capId: "security",
+                kind: "step",
+                point: "verify:post",
+                ref: { skill: "secure-phase" },
+                produces: ["SECURITY.md"],
+                consumes: ["SUMMARY.md"],
+                when: "workflow.security_enforcement",
+                onError: "halt",
+            },
+            {
+                capId: "ui",
+                kind: "step",
+                point: "verify:post",
+                ref: { skill: "ui-review" },
+                produces: ["UI-REVIEW.md"],
+                consumes: ["UI-SPEC.md"],
+                when: "workflow.ui_review",
+                onError: "skip",
+            },
+        ],
+        contributions: [],
+        gates: [],
+    },
+    "ship:pre": {
+        steps: [],
+        contributions: [],
+        gates: [
+            {
+                capId: "security",
+                kind: "gate",
+                point: "ship:pre",
+                check: {
+                    predicate: {
+                        kind: "artifact-frontmatter-equals",
+                        artifact: "SECURITY.md",
+                        field: "threats_open",
+                        equals: 0,
+                    },
+                },
+                when: "workflow.security_enforcement",
+                blocking: true,
+                onError: "halt",
+            },
+        ],
+    },
+    "ship:post": {
+        steps: [
+            {
+                capId: "mempalace",
+                kind: "step",
+                point: "ship:post",
+                ref: { agent: "gsd-mempalace-curator" },
+                produces: [],
+                consumes: ["UAT.md"],
+                when: "mempalace.enabled",
+                onError: "skip",
+            },
+        ],
+        contributions: [],
+        gates: [],
+    },
+};
+export const REGISTRY = {
+    byLoopPoint,
+};
+/**
+ * debate:error — stubbed per Test-First Registry Specialist's strengthening.
+ * Handler is unwired in sprint 1. Drop recovery deferred to sprint 2.
+ * The fixture is assertable so the registry contract test catches both
+ * wrong-model dispatch AND missing error channel.
+ */
+export const debateErrorStub = {
+    kind: "debate:error",
+    onError: "halt",
+    blocking: true,
+};
+Object.freeze(debateErrorStub);
+Object.freeze(REGISTRY);
+Object.freeze(REGISTRY.byLoopPoint);
+//# sourceMappingURL=capability-registry.js.map

package/dist/src/gsd/complexity-assessor.d.ts

@@ -0,0 +1,39 @@
+export interface AssessInput {
+    cwd: string;
+    raw: string;
+    priorDepth: "quick" | "standard" | "heavy";
+    confidence: number;
+    conversationDigest?: string;
+    eeContext?: string;
+    bundle?: import("./pil-gate-context.js").GateContextBundle;
+    sessionModelId: string;
+    runAssessor?: (prompt: string) => Promise<string>;
+}
+export interface AssessResult {
+    depth: "quick" | "standard" | "heavy";
+    autoCouncil: boolean;
+    rationale: string;
+    assessed: boolean;
+    source: "assessor" | "prefilter-skip" | "parse-failed-fallback";
+    assessmentPath?: string;
+    quality?: {
+        verdict: "adequate" | "enriched" | "needs-user";
+        missing: string[];
+        noiseRisk: "low" | "med" | "high";
+    };
+    enrichedPrompt: string;
+}
+/**
+ * Run the leader-tier assessor only when the fast layer1 call is uncertain or
+ * the task is non-trivial. `hasPriorContext` = there is a recent-conversation
+ * digest (a continuation turn); such turns raise the skip bar so a
+ * context-dependent follow-up mis-scored as `quick` still gets the
+ * context-aware leader check rather than silently skipping it.
+ */
+export declare function shouldAssess(priorDepth: string, confidence: number, hasPriorContext?: boolean): boolean;
+/**
+ * Enrich the native depth decision. Pre-filter short-circuits trivial turns (no LLM cost);
+ * otherwise a leader-tier call reasons over the task + context and returns a structured
+ * verdict that OVERRIDES pilCtx.modelDepthTier. Never throws — degrades to priorDepth.
+ */
+export declare function assessComplexity(input: AssessInput): Promise<AssessResult>;

package/dist/src/gsd/complexity-assessor.js

@@ -0,0 +1,152 @@
+import { writeFileSync } from "node:fs";
+import { resolvePlanCouncilLeader } from "../council/leader.js";
+import { ASSESSMENT_OUTPUT_CONTRACT, extractComplexityVerdict } from "./assessment-schema.js";
+import { ensurePlanningWorkspace } from "./config-bridge.js";
+import { planningArtifact } from "./paths.js";
+const CONFIDENCE_FLOOR = 0.7;
+/**
+ * Continuation turns get a HIGHER confidence bar before a `quick` verdict is
+ * trusted enough to skip the leader check. A terse follow-up ("làm tiếp", "từ
+ * các phần đó ...") can point at heavy prior work yet read as trivially simple
+ * in isolation, so the fast classifier's `quick` is less reliable here even
+ * with the recent-conversation digest now fed to it (defense in depth). Default
+ * 0.85; env MUONROI_GSD_CONTINUATION_CONF_FLOOR overrides (clamped to
+ * [CONFIDENCE_FLOOR, 1]). Set it to CONFIDENCE_FLOOR to disable the extra bar.
+ */
+function continuationConfidenceFloor() {
+    const raw = Number.parseFloat(process.env.MUONROI_GSD_CONTINUATION_CONF_FLOOR ?? "");
+    if (!Number.isFinite(raw))
+        return 0.85;
+    return Math.min(1, Math.max(CONFIDENCE_FLOOR, raw));
+}
+/**
+ * Run the leader-tier assessor only when the fast layer1 call is uncertain or
+ * the task is non-trivial. `hasPriorContext` = there is a recent-conversation
+ * digest (a continuation turn); such turns raise the skip bar so a
+ * context-dependent follow-up mis-scored as `quick` still gets the
+ * context-aware leader check rather than silently skipping it.
+ */
+export function shouldAssess(priorDepth, confidence, hasPriorContext = false) {
+    if (priorDepth === "standard" || priorDepth === "heavy")
+        return true;
+    const floor = hasPriorContext ? continuationConfidenceFloor() : CONFIDENCE_FLOOR;
+    return confidence < floor; // low-confidence quick → double-check
+}
+function buildAssessorPrompt(input) {
+    const digest = input.bundle?.conversationDigest || input.conversationDigest || "";
+    const ee = input.bundle?.eeContext || input.eeContext || "";
+    const plan = input.bundle?.priorPlan || "";
+    return [
+        "You are the complexity assessor — the highest-tier router for an autonomous coding agent.",
+        "Judge how much rigor this task needs, whether it warrants multi-perspective debate, and enrich an under-specified prompt.",
+        "Be decisive: over-tiering wastes time, under-tiering ships unreviewed risk, over-enriching adds noise.",
+        "",
+        `Fast classifier's first-pass depth: ${input.priorDepth} (confidence ${input.confidence.toFixed(2)}).`,
+        digest ? `\nRecent conversation:\n${digest}` : "",
+        ee ? `\nPrior experience (EE recall):\n${ee}` : "",
+        plan ? `\nPrior plan (this task):\n${plan}` : "",
+        "",
+        "### Task",
+        input.raw,
+        ASSESSMENT_OUTPUT_CONTRACT,
+    ].join("\n");
+}
+function writeAssessment(cwd, r, leaderModelId) {
+    ensurePlanningWorkspace(cwd, leaderModelId);
+    const path = planningArtifact(cwd, "ASSESSMENT.md");
+    writeFileSync(path, [
+        "# ASSESSMENT",
+        "",
+        `depth: ${r.depth}`,
+        `autoCouncil: ${r.autoCouncil}`,
+        `leader: \`${leaderModelId}\``,
+        "",
+        "## Rationale",
+        "",
+        r.rationale || "(none)",
+    ].join("\n"), "utf8");
+    return path;
+}
+/**
+ * Enrich the native depth decision. Pre-filter short-circuits trivial turns (no LLM cost);
+ * otherwise a leader-tier call reasons over the task + context and returns a structured
+ * verdict that OVERRIDES pilCtx.modelDepthTier. Never throws — degrades to priorDepth.
+ */
+export async function assessComplexity(input) {
+    const hasPriorContext = !!(input.bundle?.conversationDigest || input.conversationDigest || "").trim();
+    if (!shouldAssess(input.priorDepth, input.confidence, hasPriorContext)) {
+        return {
+            depth: input.priorDepth,
+            autoCouncil: false,
+            rationale: "",
+            assessed: false,
+            source: "prefilter-skip",
+            enrichedPrompt: "",
+        };
+    }
+    if (!input.runAssessor) {
+        // No runner (offline/test path without a fixture) — keep priorDepth, do not fabricate.
+        return {
+            depth: input.priorDepth,
+            autoCouncil: false,
+            rationale: "",
+            assessed: false,
+            source: "prefilter-skip",
+            enrichedPrompt: "",
+        };
+    }
+    let raw = "";
+    try {
+        raw = await input.runAssessor(buildAssessorPrompt(input));
+    }
+    catch (err) {
+        console.error(`[gsd] complexity assessor call failed, keeping priorDepth: ${err.message}`);
+        return {
+            depth: input.priorDepth,
+            autoCouncil: false,
+            rationale: "",
+            assessed: false,
+            source: "parse-failed-fallback",
+            enrichedPrompt: "",
+        };
+    }
+    const verdict = extractComplexityVerdict(raw);
+    if (!verdict) {
+        console.error("[gsd] complexity assessor emitted no structured verdict — keeping priorDepth");
+        return {
+            depth: input.priorDepth,
+            autoCouncil: false,
+            rationale: "",
+            assessed: false,
+            source: "parse-failed-fallback",
+            enrichedPrompt: "",
+        };
+    }
+    try {
+        const leader = await resolvePlanCouncilLeader(input.sessionModelId);
+        const path = writeAssessment(input.cwd, verdict, leader.modelId);
+        const brief = (verdict.enrichedPrompt ?? "").slice(0, 1500);
+        return {
+            depth: verdict.depth,
+            autoCouncil: verdict.autoCouncil,
+            rationale: verdict.rationale,
+            assessed: true,
+            source: "assessor",
+            assessmentPath: path,
+            quality: verdict.quality,
+            enrichedPrompt: brief,
+        };
+    }
+    catch (err) {
+        console.error(`[gsd] complexity assessor finalize failed, keeping priorDepth: ${err.message}`);
+        return {
+            depth: input.priorDepth,
+            autoCouncil: false,
+            rationale: "",
+            assessed: false,
+            source: "parse-failed-fallback",
+            enrichedPrompt: "",
+        };
+    }
+}
+//# sourceMappingURL=complexity-assessor.js.map

package/dist/src/gsd/config-bridge.d.ts

@@ -0,0 +1,7 @@
+export interface PlanningConfig {
+    models: Record<string, string>;
+    commit_docs?: boolean;
+}
+export declare function buildPlanningConfig(sessionModelId: string): PlanningConfig;
+export declare function ensurePlanningWorkspace(cwd: string, sessionModelId: string): string;
+export declare function readPlanningConfig(cwd: string): PlanningConfig | null;

package/dist/src/gsd/config-bridge.js

@@ -0,0 +1,114 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { getModelByTier, getModelInfo } from "../models/registry.js";
+import { detectProviderForModel } from "../providers/runtime.js";
+import { getRoleModels } from "../utils/settings.js";
+import { resolveGsdPremiumModel } from "./model-tier.js";
+import { planningArtifact, planningRoot } from "./paths.js";
+const ROLE_TO_GSD_KEY = {
+    leader: "leader",
+    implement: "executor",
+    verify: "verifier",
+    research: "researcher",
+};
+function resolveModelIdForRole(role, sessionModelId) {
+    const configured = getRoleModels()[role];
+    if (configured) {
+        try {
+            detectProviderForModel(configured);
+            if (getModelInfo(configured))
+                return configured;
+        }
+        catch {
+            /* fall through */
+        }
+    }
+    let providerId;
+    try {
+        providerId = detectProviderForModel(sessionModelId);
+    }
+    catch {
+        if (role === "leader")
+            return sessionModelId;
+        return undefined;
+    }
+    if (role === "leader" || role === "verify" || role === "research") {
+        try {
+            return resolveGsdPremiumModel(sessionModelId);
+        }
+        catch {
+            if (role === "leader")
+                return sessionModelId;
+            return undefined;
+        }
+    }
+    if (role === "implement") {
+        return getModelByTier("balanced", providerId)?.id ?? resolveGsdPremiumModel(sessionModelId);
+    }
+    return undefined;
+}
+export function buildPlanningConfig(sessionModelId) {
+    const models = {};
+    for (const [role, gsdKey] of Object.entries(ROLE_TO_GSD_KEY)) {
+        const id = resolveModelIdForRole(role, sessionModelId);
+        if (id)
+            models[gsdKey] = id;
+    }
+    return {
+        models,
+        commit_docs: false,
+    };
+}
+/** gsd-core compatible STATE.md (templates/state.md) with muonroi task-level extensions. */
+const DEFAULT_STATE_MD = `---
+gsd_state_version: '1.0'
+status: planning
+progress:
+  total_phases: 0
+  completed_phases: 0
+  total_plans: 0
+  completed_plans: 0
+  percent: 0
+---
+
+# Project State
+
+## Current Position
+
+Phase: discuss of 0 (task)
+Plan: 0 of 0
+Status: Ready to plan
+Last activity: — native host bootstrap
+
+| Field | Value |
+| --- | --- |
+| Phase | discuss |
+| Depth | standard |
+| Plan Verified | no |
+| Workflow Kind | task |
+`;
+export function ensurePlanningWorkspace(cwd, sessionModelId) {
+    const root = planningRoot(cwd);
+    mkdirSync(root, { recursive: true });
+    const configPath = planningArtifact(cwd, "config.json");
+    if (!existsSync(configPath)) {
+        writeFileSync(configPath, `${JSON.stringify(buildPlanningConfig(sessionModelId), null, 2)}\n`, "utf8");
+    }
+    const statePath = planningArtifact(cwd, "STATE.md");
+    if (!existsSync(statePath)) {
+        writeFileSync(statePath, DEFAULT_STATE_MD, "utf8");
+    }
+    return root;
+}
+export function readPlanningConfig(cwd) {
+    const configPath = planningArtifact(cwd, "config.json");
+    if (!existsSync(configPath))
+        return null;
+    try {
+        return JSON.parse(readFileSync(configPath, "utf8"));
+    }
+    catch (err) {
+        console.error(`[gsd] failed to parse ${configPath}: ${err.message}`);
+        return null;
+    }
+}
+//# sourceMappingURL=config-bridge.js.map

package/dist/src/gsd/config-loader.d.ts

@@ -0,0 +1,27 @@
+/**
+ * config-loader.ts — Native replacement for gsd-core/bin/lib/config-loader.cjs
+ *
+ * Simplified config loading for the muonroi-cli native GSD workflow.
+ * Reads .planning/config.json from the project directory and returns
+ * a normalized config object.
+ */
+export interface PlanningConfig {
+    model_profile?: string;
+    planning?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+/**
+ * Load the GSD planning config from .planning/config.json in the given cwd.
+ * Returns an empty object when no config is present.
+ */
+export declare function loadConfig(cwd: string): PlanningConfig;
+/** Resolve a dotted config key against a config object (e.g. "workflow.research"). */
+export declare function resolveConfigKey(dotKey: string, config: Record<string, unknown>): {
+    found: boolean;
+    value: unknown;
+};
+/**
+ * Simple activation value resolver.
+ * If the when key is `true` → active. Absent/falsy → inactive.
+ */
+export declare function resolveActivationValue(when: string, config: Record<string, unknown>): boolean;