muonroi-cli 1.8.4 → 1.8.5

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

@@ -0,0 +1,50 @@
+/**
+ * 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.
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { planningRoot } from "./paths.js";
+/**
+ * Load the GSD planning config from .planning/config.json in the given cwd.
+ * Returns an empty object when no config is present.
+ */
+export function loadConfig(cwd) {
+    // planningRoot resolves `.planning/` when present, else the folded location
+    // (`.muonroi-flow/planning/`) — see paths.ts. `.planning/` still wins today.
+    const configPath = join(planningRoot(cwd), "config.json");
+    if (!existsSync(configPath))
+        return {};
+    try {
+        const raw = readFileSync(configPath, "utf8");
+        return JSON.parse(raw);
+    }
+    catch {
+        return {};
+    }
+}
+/** Resolve a dotted config key against a config object (e.g. "workflow.research"). */
+export function resolveConfigKey(dotKey, config) {
+    const parts = dotKey.split(".");
+    let current = config;
+    for (const part of parts) {
+        if (current === null || current === undefined)
+            return { found: false, value: undefined };
+        if (typeof current !== "object" || Array.isArray(current))
+            return { found: false, value: undefined };
+        current = current[part];
+    }
+    return { found: true, value: current };
+}
+/**
+ * Simple activation value resolver.
+ * If the when key is `true` → active. Absent/falsy → inactive.
+ */
+export function resolveActivationValue(when, config) {
+    const { found, value } = resolveConfigKey(when, config);
+    return found && value === true;
+}
+//# sourceMappingURL=config-loader.js.map

package/dist/src/gsd/council-context.d.ts

@@ -0,0 +1,44 @@
+import { type WorkflowState } from "./workflow-engine.js";
+/**
+ * Council context bundle — the full prior GSD surface the plan-council must
+ * see to debate a plan WITHOUT relitigating settled points or losing the
+ * user's discuss/research context. This is what makes the council verdict
+ * trustworthy enough for the verify step to rely on.
+ *
+ * Reads are tolerant: missing artifacts degrade to empty strings, never throw.
+ * Each section is char-capped to keep the debate prompt bounded.
+ */
+export interface CouncilContextBundle {
+    state: WorkflowState;
+    workflowKind: string;
+    depth: string;
+    contextMd: string;
+    researchMd: string;
+    /** Complexity assessor's rationale (ASSESSMENT.md) — the prior step's output. */
+    assessment: string;
+    priorConcerns: string[];
+    acceptanceCriteria: string[];
+    /** Total chars across all sections (telemetry). */
+    totalChars: number;
+    /** True when a prior PLAN-REVIEW.md seeded concerns (revision cycle). */
+    hadPriorConcerns: boolean;
+    /** Revision cycle index — 0 on first review, >0 on revisits. */
+    revisionCycle: number;
+}
+/** Extract `## Acceptance` / `## Criteria` bullet lines from PLAN.md. */
+export declare function extractAcceptanceCriteria(planBody: string): string[];
+/** Pull `- <concern>` lines from the Concerns section of a prior PLAN-REVIEW.md. */
+export declare function extractPriorConcerns(reviewMd: string): string[];
+/**
+ * Render the bundle as a markdown block suitable to prepend to a debate topic
+ * or perspective prompt. `revisionCycle > 0` emphasises the prior-concerns
+ * directive so the council addresses them instead of re-deriving from scratch.
+ */
+export declare function renderCouncilContextBlock(bundle: CouncilContextBundle, opts?: {
+    forPerspective?: "research" | string;
+}): string;
+export interface BuildBundleOpts {
+    depth: string;
+    revisionCycle?: number;
+}
+export declare function buildCouncilContextBundle(cwd: string, opts: BuildBundleOpts): CouncilContextBundle;

package/dist/src/gsd/council-context.js

@@ -0,0 +1,114 @@
+import { existsSync, readFileSync } from "node:fs";
+import { planningArtifact } from "./paths.js";
+import { readState, readWorkflowKind } from "./workflow-engine.js";
+function cap(text, max) {
+    const trimmed = text.trim();
+    if (trimmed.length <= max)
+        return trimmed;
+    return `${trimmed.slice(0, max)}…[truncated]`;
+}
+function readArtifact(cwd, name) {
+    const p = planningArtifact(cwd, name);
+    return existsSync(p) ? readFileSync(p, "utf8") : "";
+}
+/** Extract `## Acceptance` / `## Criteria` bullet lines from PLAN.md. */
+export function extractAcceptanceCriteria(planBody) {
+    const lines = planBody.split("\n");
+    let inSection = false;
+    const out = [];
+    for (const line of lines) {
+        const heading = line.match(/^##\s+(.+?)\s*$/i);
+        if (heading) {
+            inSection = /accept|criteria|success/i.test(heading[1] ?? "");
+            continue;
+        }
+        if (inSection) {
+            const bullet = line.match(/^\s*[-*]\s+(.+)$/);
+            if (bullet?.[1]?.trim())
+                out.push(bullet[1].trim());
+        }
+    }
+    return out;
+}
+/** Pull `- <concern>` lines from the Concerns section of a prior PLAN-REVIEW.md. */
+export function extractPriorConcerns(reviewMd) {
+    if (!reviewMd.trim())
+        return [];
+    const lines = reviewMd.split("\n");
+    let inSection = false;
+    const out = [];
+    for (const line of lines) {
+        const heading = line.match(/^##\s+(.+?)\s*$/i);
+        if (heading) {
+            inSection = /concern/i.test(heading[1] ?? "");
+            continue;
+        }
+        if (inSection) {
+            const bullet = line.match(/^\s*[-*]\s+(.+)$/);
+            if (bullet?.[1]?.trim() && !/^\(none\)$/i.test(bullet[1].trim())) {
+                out.push(bullet[1].trim());
+            }
+        }
+    }
+    return out;
+}
+/**
+ * Render the bundle as a markdown block suitable to prepend to a debate topic
+ * or perspective prompt. `revisionCycle > 0` emphasises the prior-concerns
+ * directive so the council addresses them instead of re-deriving from scratch.
+ */
+export function renderCouncilContextBlock(bundle, opts = {}) {
+    const lines = ["## GSD Context (prior synthesized state)", ""];
+    lines.push(`- Phase: ${bundle.state.phase ?? "unknown"} | Depth: ${bundle.depth} | Workflow: ${bundle.workflowKind}`, `- Plan verified so far: ${bundle.state.planVerified ? "yes" : "no"}`);
+    if (bundle.contextMd) {
+        lines.push("", "### Discuss notes (CONTEXT.md)", "", cap(bundle.contextMd, 2000));
+    }
+    // Research perspective gets the full digest to avoid re-grounding; others
+    // get a short pointer so they know research exists but don't re-litigate it.
+    if (bundle.researchMd) {
+        const digest = opts.forPerspective === "research" ? cap(bundle.researchMd, 2000) : cap(bundle.researchMd, 400);
+        lines.push("", "### Research findings (RESEARCH.md)", "", digest);
+    }
+    if (bundle.assessment) {
+        lines.push("", "### Complexity assessment", "", cap(bundle.assessment, 600));
+    }
+    if (bundle.acceptanceCriteria.length) {
+        lines.push("", "### Acceptance criteria (verify contract)", "");
+        for (const c of bundle.acceptanceCriteria.slice(0, 12))
+            lines.push(`- ${c}`);
+    }
+    if (bundle.hadPriorConcerns && bundle.priorConcerns.length) {
+        lines.push("", `### Prior council concerns (revision ${bundle.revisionCycle})`, "");
+        for (const c of bundle.priorConcerns.slice(0, 20))
+            lines.push(`- ${c}`);
+        lines.push("", "Each perspective MUST address the prior concerns above in its verdict — do not relitigate settled points.");
+    }
+    return lines.join("\n");
+}
+export function buildCouncilContextBundle(cwd, opts) {
+    const state = readState(cwd);
+    const workflowKind = readWorkflowKind(cwd) ?? "task";
+    const contextMd = readArtifact(cwd, "CONTEXT.md");
+    const researchMd = readArtifact(cwd, "RESEARCH.md");
+    const planBody = readArtifact(cwd, "PLAN.md");
+    const reviewMd = readArtifact(cwd, "PLAN-REVIEW.md");
+    const assessment = readArtifact(cwd, "ASSESSMENT.md");
+    const acceptanceCriteria = extractAcceptanceCriteria(planBody);
+    const priorConcerns = extractPriorConcerns(reviewMd);
+    const hadPriorConcerns = (opts.revisionCycle ?? 0) > 0 && priorConcerns.length > 0;
+    const totalChars = state.raw.length + contextMd.length + researchMd.length + reviewMd.length + planBody.length + assessment.length;
+    return {
+        state,
+        workflowKind,
+        depth: opts.depth,
+        contextMd,
+        researchMd,
+        assessment,
+        priorConcerns,
+        acceptanceCriteria,
+        totalChars,
+        hadPriorConcerns,
+        revisionCycle: opts.revisionCycle ?? 0,
+    };
+}
+//# sourceMappingURL=council-context.js.map

package/dist/src/gsd/ee-closure.d.ts

@@ -0,0 +1,28 @@
+export interface GsdNativeTelemetry {
+    phase: string | null;
+    depth: string | null;
+    workflowKind?: string;
+    loopPoint?: string;
+    planVerified?: boolean;
+    verifyVerdict?: string | null;
+    councilPerspectives?: number;
+    leaderModelId?: string;
+    councilContextChars?: number;
+    councilHadPriorConcerns?: boolean;
+    councilVerdictSource?: "structured" | "heuristic-fallback" | "parse-failed";
+    councilVerdictParseFailed?: boolean;
+    phaseNumber?: string;
+    shipNotes?: string[];
+}
+export declare const PLANNING_CHECKPOINT_QUERY = "Context checkpoint summary OR PLAN-VERIFY verdict OR gsd-native STATE.md .planning/ Progress DONE";
+/** Forensics-visible gsd-native interaction event (Phase 3 telemetry / Phase 5 closure). */
+export declare function logGsdNativeEvent(sessionId: string, data: GsdNativeTelemetry): void;
+export interface VerifyOutcomeOpts {
+    sessionId?: string;
+    cwd: string;
+    depth: string;
+    passed: boolean;
+    evidence?: Record<string, unknown>;
+}
+/** Fire EE phase-outcome on gsd verify:post pass/fail (best-effort, B-4 compliant). */
+export declare function fireGsdVerifyOutcome(opts: VerifyOutcomeOpts): void;

package/dist/src/gsd/ee-closure.js

@@ -0,0 +1,49 @@
+import { fireAndForgetPhaseOutcome } from "../ee/phase-outcome.js";
+import { logInteraction } from "../storage/interaction-log.js";
+import { readPlanVerifyVerdict, readState } from "./workflow-engine.js";
+export const PLANNING_CHECKPOINT_QUERY = "Context checkpoint summary OR PLAN-VERIFY verdict OR gsd-native STATE.md .planning/ Progress DONE";
+/** Forensics-visible gsd-native interaction event (Phase 3 telemetry / Phase 5 closure). */
+export function logGsdNativeEvent(sessionId, data) {
+    if (!sessionId)
+        return;
+    try {
+        logInteraction(sessionId, "pil", {
+            eventSubtype: "gsd-native",
+            data: { ...data, ts: Date.now() },
+        });
+    }
+    catch (err) {
+        console.error(`[gsd-ee-closure] logGsdNativeEvent failed: ${err.message}`);
+    }
+}
+/** Fire EE phase-outcome on gsd verify:post pass/fail (best-effort, B-4 compliant). */
+export function fireGsdVerifyOutcome(opts) {
+    const { sessionId, cwd, depth, passed, evidence } = opts;
+    const state = readState(cwd);
+    const verdict = readPlanVerifyVerdict(cwd);
+    const outcome = passed ? "pass" : "fail";
+    logGsdNativeEvent(sessionId ?? "gsd-native", {
+        phase: state.phase,
+        depth,
+        loopPoint: "verify:post",
+        planVerified: state.planVerified,
+        verifyVerdict: verdict,
+        workflowKind: typeof evidence?.workflowKind === "string" ? evidence.workflowKind : undefined,
+    });
+    if (!sessionId)
+        return;
+    fireAndForgetPhaseOutcome({
+        sessionId,
+        phaseName: `gsd:verify:${state.phase ?? "unknown"}`,
+        outcome,
+        evidence: {
+            cwd,
+            depth,
+            planVerified: state.planVerified,
+            planVerifyVerdict: verdict,
+            nativeHost: "muonroi-cli",
+            ...evidence,
+        },
+    });
+}
+//# sourceMappingURL=ee-closure.js.map

package/dist/src/gsd/flags.d.ts

@@ -0,0 +1,55 @@
+/**
+ * Native GSD workflow engine — default ON.
+ * Agent chooses when to call gsd_* tools; gates are soft except plan-review → execute.
+ * Opt out: MUONROI_GSD_NATIVE=0 (legacy playbook rubric, no gsd_* tools).
+ */
+export declare function isGsdNativeEnabled(): boolean;
+/**
+ * Leader-tier complexity assessor over the native depth slot — default ON
+ * when native GSD is on. Opt out: MUONROI_GSD_ASSESSOR=0.
+ */
+export declare function isComplexityAssessorEnabled(): boolean;
+/**
+ * Native mutation gate — default ON when native GSD is on. Delegates to the SDK's
+ * own `canExecute(cwd, depth)` at the write-mutex wrapper so mutation tools are
+ * blocked until plan-review passes at standard/heavy depth. Opt out: MUONROI_GSD_HARD_GATE=0.
+ */
+export declare function isGsdHardGateEnabled(): boolean;
+/**
+ * PIL prompt-gate full-context enrichment (conversation digest, EE recall,
+ * prior PLAN.md excerpt) — default ON when native GSD is on. Opt out:
+ * MUONROI_PIL_GATE_ENRICH=0.
+ */
+export declare function isPilGateEnrichEnabled(): boolean;
+/**
+ * Debate/council TUI two-pane redesign — scroll-lock. Default ON (baked). When
+ * ON, forced `scrollToBottom()` calls respect the user's manual scroll position
+ * (OpenTUI `_hasManualScroll`) so streaming renders don't yank the view back to
+ * the latest line while the user is reading history. A jump-to-latest pill
+ * re-pins on demand. Opt out: MUONROI_SCROLL_LOCK=0.
+ */
+export declare function isScrollLockEnabled(): boolean;
+/**
+ * Debate/council TUI two-pane redesign — right Context Rail for metadata-heavy
+ * modes (debate/council, ideal). Default ON (baked). When ON,
+ * session/leader/panel/budget metadata and info-cards move out of the scrolling
+ * transcript into a right-hand panel. Requires ≥100 terminal columns; below
+ * that the rail is hidden and metadata falls back inline. Opt out:
+ * MUONROI_CONTEXT_RAIL=0.
+ */
+export declare function isContextRailEnabled(): boolean;
+/**
+ * Debate/council TUI two-pane redesign — round-grouped transcript. Default ON
+ * (baked). When ON, debate turns are grouped by round; only the running round
+ * streams live while done rounds render an expanded summary (input, outcome,
+ * leader decision, metrics). Opt out: MUONROI_ROUND_GROUPS=0.
+ */
+export declare function isRoundGroupsEnabled(): boolean;
+/**
+ * U3 — task-aware debate panel. Default ON. When ON, the leader reads the task
+ * and selects which reachable models should debate it (via selectTaskAwarePanel)
+ * instead of the prompt-blind capability roster from resolveParticipants. Always
+ * fails open to the default roster on any provider/parse failure. Opt out:
+ * MUONROI_TASK_AWARE_PANEL=0.
+ */
+export declare function isTaskAwarePanelEnabled(): boolean;

package/dist/src/gsd/flags.js

@@ -0,0 +1,83 @@
+/**
+ * Native GSD workflow engine — default ON.
+ * Agent chooses when to call gsd_* tools; gates are soft except plan-review → execute.
+ * Opt out: MUONROI_GSD_NATIVE=0 (legacy playbook rubric, no gsd_* tools).
+ */
+export function isGsdNativeEnabled() {
+    const raw = process.env.MUONROI_GSD_NATIVE;
+    if (raw === "0" || raw?.toLowerCase() === "false")
+        return false;
+    return true;
+}
+/**
+ * Leader-tier complexity assessor over the native depth slot — default ON
+ * when native GSD is on. Opt out: MUONROI_GSD_ASSESSOR=0.
+ */
+export function isComplexityAssessorEnabled() {
+    if (!isGsdNativeEnabled())
+        return false;
+    return process.env.MUONROI_GSD_ASSESSOR !== "0";
+}
+/**
+ * Native mutation gate — default ON when native GSD is on. Delegates to the SDK's
+ * own `canExecute(cwd, depth)` at the write-mutex wrapper so mutation tools are
+ * blocked until plan-review passes at standard/heavy depth. Opt out: MUONROI_GSD_HARD_GATE=0.
+ */
+export function isGsdHardGateEnabled() {
+    if (!isGsdNativeEnabled())
+        return false;
+    return process.env.MUONROI_GSD_HARD_GATE !== "0";
+}
+/**
+ * PIL prompt-gate full-context enrichment (conversation digest, EE recall,
+ * prior PLAN.md excerpt) — default ON when native GSD is on. Opt out:
+ * MUONROI_PIL_GATE_ENRICH=0.
+ */
+export function isPilGateEnrichEnabled() {
+    return isGsdNativeEnabled() && process.env.MUONROI_PIL_GATE_ENRICH !== "0";
+}
+/**
+ * Debate/council TUI two-pane redesign — scroll-lock. Default ON (baked). When
+ * ON, forced `scrollToBottom()` calls respect the user's manual scroll position
+ * (OpenTUI `_hasManualScroll`) so streaming renders don't yank the view back to
+ * the latest line while the user is reading history. A jump-to-latest pill
+ * re-pins on demand. Opt out: MUONROI_SCROLL_LOCK=0.
+ */
+export function isScrollLockEnabled() {
+    const raw = process.env.MUONROI_SCROLL_LOCK;
+    return raw !== "0" && raw?.toLowerCase() !== "false";
+}
+/**
+ * Debate/council TUI two-pane redesign — right Context Rail for metadata-heavy
+ * modes (debate/council, ideal). Default ON (baked). When ON,
+ * session/leader/panel/budget metadata and info-cards move out of the scrolling
+ * transcript into a right-hand panel. Requires ≥100 terminal columns; below
+ * that the rail is hidden and metadata falls back inline. Opt out:
+ * MUONROI_CONTEXT_RAIL=0.
+ */
+export function isContextRailEnabled() {
+    const raw = process.env.MUONROI_CONTEXT_RAIL;
+    return raw !== "0" && raw?.toLowerCase() !== "false";
+}
+/**
+ * Debate/council TUI two-pane redesign — round-grouped transcript. Default ON
+ * (baked). When ON, debate turns are grouped by round; only the running round
+ * streams live while done rounds render an expanded summary (input, outcome,
+ * leader decision, metrics). Opt out: MUONROI_ROUND_GROUPS=0.
+ */
+export function isRoundGroupsEnabled() {
+    const raw = process.env.MUONROI_ROUND_GROUPS;
+    return raw !== "0" && raw?.toLowerCase() !== "false";
+}
+/**
+ * U3 — task-aware debate panel. Default ON. When ON, the leader reads the task
+ * and selects which reachable models should debate it (via selectTaskAwarePanel)
+ * instead of the prompt-blind capability roster from resolveParticipants. Always
+ * fails open to the default roster on any provider/parse failure. Opt out:
+ * MUONROI_TASK_AWARE_PANEL=0.
+ */
+export function isTaskAwarePanelEnabled() {
+    const raw = process.env.MUONROI_TASK_AWARE_PANEL;
+    return raw !== "0" && raw?.toLowerCase() !== "false";
+}
+//# sourceMappingURL=flags.js.map

package/dist/src/gsd/gsd-dispatch.d.ts

@@ -0,0 +1,58 @@
+export interface GsdDispatchResult<T = unknown> {
+    ok: boolean;
+    data?: T;
+    error?: string;
+    raw?: string;
+}
+export interface LoopHooksEnvelope {
+    point: string;
+    activeHooks: Array<Record<string, unknown>>;
+    rendered?: string;
+    warnings?: string[];
+}
+/** Resolve Capability Registry hooks at a loop point (native in-process). */
+export declare function dispatchLoopRenderHooks(cwd: string, point: string): GsdDispatchResult<LoopHooksEnvelope>;
+/** Milestone/phase progress JSON (native). */
+export declare function dispatchInitProgress(cwd: string): GsdDispatchResult;
+/** Bootstrap .planning/ (native — the paired ensurePlanningWorkspace writes the real config). */
+export declare function dispatchConfigEnsure(cwd: string): GsdDispatchResult;
+/** Drop cached dispatch results for a cwd. Call after ANY write to STATE.md. */
+export declare function invalidateGsdCache(cwd: string): void;
+/** state update <field> <value> — native STATE.md field replace. */
+export declare function dispatchStateUpdate(cwd: string, field: string, value: string): GsdDispatchResult;
+export interface RoadmapPhaseEntry {
+    number: string;
+    name?: string;
+    depends_on?: string | null;
+    disk_status?: string;
+}
+export interface RoadmapAnalyzeResult {
+    error?: string;
+    phases?: RoadmapPhaseEntry[];
+    phase_count?: number;
+    current_phase?: string | null;
+}
+export interface PhaseAddResult {
+    phaseNumber: string;
+    rawStdout: string;
+}
+/** phase add <description> — creates .planning/phases/<NN>-<slug>/ (native). */
+export declare function dispatchPhaseAdd(cwd: string, description: string): GsdDispatchResult<PhaseAddResult>;
+/** phase complete <N> — marks milestone phase done (native). */
+export declare function dispatchPhaseComplete(cwd: string, phaseNum: string): GsdDispatchResult;
+/** roadmap update-plan-progress <N> — sync ROADMAP checkboxes (native). */
+export declare function dispatchRoadmapPlanProgress(cwd: string, phaseNum: string): GsdDispatchResult;
+/** roadmap analyze — parse ROADMAP.md + disk status (native, read-only). */
+export declare function dispatchRoadmapAnalyze(cwd: string): GsdDispatchResult<RoadmapAnalyzeResult>;
+/** state json — frontmatter snapshot (native derivation). */
+export declare function dispatchStateJson(cwd: string): GsdDispatchResult<Record<string, unknown>>;
+/**
+ * In-process loop hook resolution — uses native modules instead of dynamic require().
+ * For tests and low-latency paths. Replaces the old loadGsdLib() approach.
+ */
+export declare function resolveLoopHooksInProcess(cwd: string, point: string): {
+    point: string;
+    activeHooks: Array<Record<string, unknown>>;
+} | null;
+/** Map muonroi task phase → gsd STATE.md body field updates. */
+export declare const PHASE_TO_GSD_STATUS: Record<string, string>;

package/dist/src/gsd/gsd-dispatch.js

@@ -0,0 +1,131 @@
+import { existsSync, statSync } from "node:fs";
+import { REGISTRY } from "./capability-registry.js";
+import { loadConfig } from "./config-loader.js";
+import { resolveLoopHooks } from "./loop-resolver.js";
+import { nativePhaseAdd, nativePhaseComplete, nativeRoadmapAnalyze, nativeRoadmapPlanProgress, } from "./native-roadmap.js";
+import { nativeConfigEnsure, nativeInitProgress, nativeStateJson, nativeStateUpdate } from "./native-state.js";
+import { planningArtifact } from "./paths.js";
+/** Resolve Capability Registry hooks at a loop point (native in-process). */
+export function dispatchLoopRenderHooks(cwd, point) {
+    const native = resolveLoopHooksInProcess(cwd, point);
+    if (!native)
+        return { ok: false, error: `loop render-hooks(${point}) failed` };
+    return { ok: true, data: { point: native.point, activeHooks: native.activeHooks } };
+}
+/** Milestone/phase progress JSON (native). */
+export function dispatchInitProgress(cwd) {
+    return readThroughCache(cwd, "init.progress", () => ({ ok: true, data: nativeInitProgress(cwd) }));
+}
+/** Bootstrap .planning/ (native — the paired ensurePlanningWorkspace writes the real config). */
+export function dispatchConfigEnsure(cwd) {
+    return { ok: true, data: nativeConfigEnsure(cwd) };
+}
+const _dispatchCache = new Map();
+function stateMtimeMs(cwd) {
+    try {
+        const p = planningArtifact(cwd, "STATE.md");
+        return existsSync(p) ? statSync(p).mtimeMs : 0;
+    }
+    catch {
+        return 0;
+    }
+}
+function readThroughCache(cwd, key, produce) {
+    const mtime = stateMtimeMs(cwd);
+    let bucket = _dispatchCache.get(cwd);
+    if (!bucket) {
+        bucket = new Map();
+        _dispatchCache.set(cwd, bucket);
+    }
+    const hit = bucket.get(key);
+    if (hit && hit.stateMtimeMs === mtime) {
+        return hit.value;
+    }
+    const value = produce();
+    // Only cache successful reads — failures usually mean .planning/ absent;
+    // caching them would mask a subsequent bootstrap.
+    if (value.ok) {
+        bucket.set(key, { stateMtimeMs: mtime, value });
+    }
+    else {
+        bucket.delete(key);
+    }
+    return value;
+}
+/** Drop cached dispatch results for a cwd. Call after ANY write to STATE.md. */
+export function invalidateGsdCache(cwd) {
+    _dispatchCache.delete(cwd);
+}
+/** state update <field> <value> — native STATE.md field replace. */
+export function dispatchStateUpdate(cwd, field, value) {
+    const result = { ok: true, data: nativeStateUpdate(cwd, field, value) };
+    // State writes mutate STATE.md → drop cached reads so the next dispatch
+    // sees fresh data.
+    invalidateGsdCache(cwd);
+    return result;
+}
+/** phase add <description> — creates .planning/phases/<NN>-<slug>/ (native). */
+export function dispatchPhaseAdd(cwd, description) {
+    const sanitized = description.trim().slice(0, 120);
+    const native = nativePhaseAdd(cwd, sanitized);
+    if ("error" in native)
+        return { ok: false, error: native.error };
+    return { ok: true, data: { phaseNumber: native.padded, rawStdout: native.padded } };
+}
+/** phase complete <N> — marks milestone phase done (native). */
+export function dispatchPhaseComplete(cwd, phaseNum) {
+    const num = phaseNum.replace(/^0+/, "") || phaseNum;
+    const r = nativePhaseComplete(cwd, num);
+    // STATE.md may have changed → drop cached reads.
+    invalidateGsdCache(cwd);
+    if (!r.ok)
+        return { ok: false, error: r.error };
+    return { ok: true, data: r };
+}
+/** roadmap update-plan-progress <N> — sync ROADMAP checkboxes (native). */
+export function dispatchRoadmapPlanProgress(cwd, phaseNum) {
+    const num = phaseNum.replace(/^0+/, "") || phaseNum;
+    const r = nativeRoadmapPlanProgress(cwd, num);
+    // "no plans" / "ROADMAP missing" are soft (ok:true, updated:false); only
+    // phase-not-found is a hard error.
+    const hardFail = !r.updated && r.reason === `Phase ${num} not found`;
+    return { ok: !hardFail, data: r, raw: r.raw };
+}
+/** roadmap analyze — parse ROADMAP.md + disk status (native, read-only). */
+export function dispatchRoadmapAnalyze(cwd) {
+    return { ok: true, data: nativeRoadmapAnalyze(cwd) };
+}
+/** state json — frontmatter snapshot (native derivation). */
+export function dispatchStateJson(cwd) {
+    return readThroughCache(cwd, "state.json", () => ({
+        ok: true,
+        data: nativeStateJson(cwd),
+    }));
+}
+/**
+ * In-process loop hook resolution — uses native modules instead of dynamic require().
+ * For tests and low-latency paths. Replaces the old loadGsdLib() approach.
+ */
+export function resolveLoopHooksInProcess(cwd, point) {
+    try {
+        const config = loadConfig(cwd);
+        const resolved = resolveLoopHooks({ point, registry: REGISTRY, config, cwd });
+        // Convert LoopHook[] to the broader array shape for backward compatibility
+        const activeHooks = resolved.activeHooks;
+        return { point: resolved.point, activeHooks };
+    }
+    catch (err) {
+        console.error(`[gsd-dispatch] resolveLoopHooksInProcess(${point}) failed: ${err.message}`);
+        return null;
+    }
+}
+/** Map muonroi task phase → gsd STATE.md body field updates. */
+export const PHASE_TO_GSD_STATUS = {
+    discuss: "Planning",
+    plan: "Planning",
+    execute: "In progress",
+    verify: "In progress",
+    review: "Phase complete",
+    debug: "In progress",
+};
+//# sourceMappingURL=gsd-dispatch.js.map

package/dist/src/gsd/gsd-runtime.d.ts

@@ -0,0 +1,22 @@
+/**
+ * gsd-runtime.ts — Native GSD runtime (replaces dynamic require() of .cjs blobs).
+ *
+ * Sprint 1: 5 in-process .cjs modules migrated to native TS.
+ * Sprint 2: the last gsd-tools subprocess calls were reimplemented natively and
+ * the `@opengsd/gsd-core` dependency was removed entirely (see gsd-dispatch.ts).
+ */
+import { type LoopHostContractEntry } from "./loop-host-contract.js";
+import { computeProgressPercent, isStateTemplateDefault, normalizeStateStatus, type StateDocumentModule, stateExtractField, stateReplaceField, stateReplaceFieldWithFallback } from "./state-document.js";
+export type { LoopHostContractEntry, StateDocumentModule };
+/**
+ * Load the loop host contract — returns the in-memory LOOP_HOST_CONTRACT.
+ */
+export declare function loadLoopHostContract(): LoopHostContractEntry[];
+/** All canonical loop points. */
+export declare function allLoopHostPoints(): string[];
+/**
+ * Load the state document module — returns native implementations wrapping
+ * the pure functions from state-document.ts.
+ */
+export declare function loadStateDocument(): StateDocumentModule;
+export { computeProgressPercent, isStateTemplateDefault, normalizeStateStatus, stateExtractField, stateReplaceField, stateReplaceFieldWithFallback, };