muonroi-cli 1.8.4 → 1.8.5

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

@@ -0,0 +1,37 @@
+/**
+ * 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 { LOOP_HOST_CONTRACT } from "./loop-host-contract.js";
+import { computeProgressPercent, isStateTemplateDefault, normalizeStateStatus, stateExtractField, stateReplaceField, stateReplaceFieldWithFallback, } from "./state-document.js";
+// Memoised contract cache
+let _loopHostContractCache = null;
+/**
+ * Load the loop host contract — returns the in-memory LOOP_HOST_CONTRACT.
+ */
+export function loadLoopHostContract() {
+    if (_loopHostContractCache)
+        return _loopHostContractCache;
+    _loopHostContractCache = LOOP_HOST_CONTRACT;
+    return _loopHostContractCache;
+}
+/** All canonical loop points. */
+export function allLoopHostPoints() {
+    return loadLoopHostContract().flatMap((e) => e.points);
+}
+/**
+ * Load the state document module — returns native implementations wrapping
+ * the pure functions from state-document.ts.
+ */
+export function loadStateDocument() {
+    return {
+        stateExtractField,
+        stateReplaceField,
+    };
+}
+// Re-export key state-document functions for convenience
+export { computeProgressPercent, isStateTemplateDefault, normalizeStateStatus, stateExtractField, stateReplaceField, stateReplaceFieldWithFallback, };
+//# sourceMappingURL=gsd-runtime.js.map

package/dist/src/gsd/host-adapter.d.ts

@@ -0,0 +1,11 @@
+import { type LoopHostContext, type LoopPointResult } from "./loop-host.js";
+export type { LoopHostContext, LoopPointResult };
+/** @deprecated Use GsdLoopHost.firePoint — thin facade for backwards compatibility. */
+export declare class GsdHostAdapter {
+    private host;
+    dispatch(point: string, ctx: LoopHostContext): Promise<boolean>;
+    registeredPoints(): string[];
+    contractPoints(): string[];
+}
+export declare function createDefaultHostAdapter(): GsdHostAdapter;
+export { GsdLoopHost, getGsdLoopHost } from "./loop-host.js";

package/dist/src/gsd/host-adapter.js

@@ -0,0 +1,29 @@
+import { loadLoopHostContract } from "./gsd-runtime.js";
+import { getGsdLoopHost } from "./loop-host.js";
+/** @deprecated Use GsdLoopHost.firePoint — thin facade for backwards compatibility. */
+export class GsdHostAdapter {
+    host = getGsdLoopHost();
+    async dispatch(point, ctx) {
+        if (point === "plan-review:post") {
+            await this.host.firePoint(point, ctx);
+            return true;
+        }
+        const contract = this.host.canonicalPoints();
+        if (!contract.includes(point) && point !== "plan-review:post") {
+            return false;
+        }
+        await this.host.firePoint(point, ctx);
+        return true;
+    }
+    registeredPoints() {
+        return [...this.host.canonicalPoints(), "plan-review:post"];
+    }
+    contractPoints() {
+        return loadLoopHostContract().flatMap((e) => e.points);
+    }
+}
+export function createDefaultHostAdapter() {
+    return new GsdHostAdapter();
+}
+export { GsdLoopHost, getGsdLoopHost } from "./loop-host.js";
+//# sourceMappingURL=host-adapter.js.map

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

@@ -1 +1,24 @@
-export { detectGsdPhase, GSD_PHASES, type GsdPhase, isGsdPhase } from "./types.js";
+export { type CapabilityRegistry, debateErrorStub, type LoopHook, type LoopPointEntry, REGISTRY, } from "./capability-registry.js";
+export { type AssessInput, type AssessResult, assessComplexity, shouldAssess } from "./complexity-assessor.js";
+export { buildPlanningConfig, ensurePlanningWorkspace } from "./config-bridge.js";
+export { loadConfig, type PlanningConfig, resolveConfigKey } from "./config-loader.js";
+export { fireGsdVerifyOutcome, logGsdNativeEvent, PLANNING_CHECKPOINT_QUERY } from "./ee-closure.js";
+export { isComplexityAssessorEnabled, isGsdHardGateEnabled, isGsdNativeEnabled } from "./flags.js";
+export { dispatchInitProgress, dispatchLoopRenderHooks, dispatchPhaseAdd, dispatchPhaseComplete, dispatchRoadmapAnalyze, dispatchRoadmapPlanProgress, dispatchStateUpdate, type PhaseAddResult, type RoadmapAnalyzeResult, } from "./gsd-dispatch.js";
+export { allLoopHostPoints, loadLoopHostContract, loadStateDocument } from "./gsd-runtime.js";
+export { createDefaultHostAdapter, GsdHostAdapter, GsdLoopHost, getGsdLoopHost } from "./host-adapter.js";
+export { getAllCanonicalPoints, LOOP_HOST_CONTRACT, type LoopHostContractEntry } from "./loop-host-contract.js";
+export { type ResolvedLoopHooks, renderLoopHooksEnvelope, resolveLoopHooks } from "./loop-resolver.js";
+export { evaluateMutationGate, type MutationGateDecision } from "./mutation-gate.js";
+export { orderPhasesForExecution, syncPhasePlanToRoadmap, topologicalPhaseOrder } from "./phase-dag.js";
+export { ensureTaskRoadmap, syncTaskPhaseOnPlan, syncTaskPhaseOnVerifyPass, } from "./phase-sync.js";
+export { type PlanCouncilResult, runPlanCouncil } from "./plan-council.js";
+export { buildProjectMd, buildRoadmapFromPhasePlan, ensureProductPlanningWorkspace, syncRoadmapFromPhasePlan, } from "./product-workspace.js";
+export { runTaskShip } from "./ship-bridge.js";
+export { computeProgressPercent, isStateTemplateDefault, KNOWN_STATUS_PATTERNS, KNOWN_TEMPLATE_DEFAULTS, normalizeStateStatus, stateExtractField, stateReplaceField, stateReplaceFieldWithFallback, } from "./state-document.js";
+export { detectGsdPhase, GSD_PHASES, type GsdPhase, isGsdPhase, type WorkflowKind } from "./types.js";
+export { buildVerifyContextBundle, type VerifyContextBundle } from "./verify-context.js";
+export { runVerifyCouncil, type VerifyCouncilResult } from "./verify-council.js";
+export { type VerifyPerspective, verifyPerspectivesForDepth } from "./verify-council-prompts.js";
+export { advancePhase, buildGsdStatusPayload, canExecute, canShip, currentPhase, readPlanVerifyVerdict, readProgress, readState, readWorkflowKind, syncWorkflowContext, } from "./workflow-engine.js";
+export { GSD_WORKFLOW_TOOL_NAMES, registerGsdWorkflowTools } from "./workflow-tools.js";

package/dist/src/gsd/index.js

@@ -1,2 +1,29 @@
+// Native modules (replaced .cjs require path)
+export { debateErrorStub, REGISTRY, } from "./capability-registry.js";
+export { assessComplexity, shouldAssess } from "./complexity-assessor.js";
+export { buildPlanningConfig, ensurePlanningWorkspace } from "./config-bridge.js";
+export { loadConfig, resolveConfigKey } from "./config-loader.js";
+export { fireGsdVerifyOutcome, logGsdNativeEvent, PLANNING_CHECKPOINT_QUERY } from "./ee-closure.js";
+export { isComplexityAssessorEnabled, isGsdHardGateEnabled, isGsdNativeEnabled } from "./flags.js";
+// GSD dispatch (fully native — @opengsd/gsd-core subprocess removed in Part B step 2)
+export { dispatchInitProgress, dispatchLoopRenderHooks, dispatchPhaseAdd, dispatchPhaseComplete, dispatchRoadmapAnalyze, dispatchRoadmapPlanProgress, dispatchStateUpdate, } from "./gsd-dispatch.js";
+// GSD runtime (native module wrappers)
+export { allLoopHostPoints, loadLoopHostContract, loadStateDocument } from "./gsd-runtime.js";
+export { createDefaultHostAdapter, GsdHostAdapter, GsdLoopHost, getGsdLoopHost } from "./host-adapter.js";
+export { getAllCanonicalPoints, LOOP_HOST_CONTRACT } from "./loop-host-contract.js";
+export { renderLoopHooksEnvelope, resolveLoopHooks } from "./loop-resolver.js";
+export { evaluateMutationGate } from "./mutation-gate.js";
+export { orderPhasesForExecution, syncPhasePlanToRoadmap, topologicalPhaseOrder } from "./phase-dag.js";
+export { ensureTaskRoadmap, syncTaskPhaseOnPlan, syncTaskPhaseOnVerifyPass, } from "./phase-sync.js";
+export { runPlanCouncil } from "./plan-council.js";
+export { buildProjectMd, buildRoadmapFromPhasePlan, ensureProductPlanningWorkspace, syncRoadmapFromPhasePlan, } from "./product-workspace.js";
+export { runTaskShip } from "./ship-bridge.js";
+// State-document functions
+export { computeProgressPercent, isStateTemplateDefault, KNOWN_STATUS_PATTERNS, KNOWN_TEMPLATE_DEFAULTS, normalizeStateStatus, stateExtractField, stateReplaceField, stateReplaceFieldWithFallback, } from "./state-document.js";
 export { detectGsdPhase, GSD_PHASES, isGsdPhase } from "./types.js";
+export { buildVerifyContextBundle } from "./verify-context.js";
+export { runVerifyCouncil } from "./verify-council.js";
+export { verifyPerspectivesForDepth } from "./verify-council-prompts.js";
+export { advancePhase, buildGsdStatusPayload, canExecute, canShip, currentPhase, readPlanVerifyVerdict, readProgress, readState, readWorkflowKind, syncWorkflowContext, } from "./workflow-engine.js";
+export { GSD_WORKFLOW_TOOL_NAMES, registerGsdWorkflowTools } from "./workflow-tools.js";
 //# sourceMappingURL=index.js.map

package/dist/src/gsd/loop-host-contract.d.ts

@@ -0,0 +1,21 @@
+/**
+ * loop-host-contract.ts — Native replacement for gsd-core/bin/lib/loop-host-contract.cjs
+ *
+ * ADR-894 §3 — Loop Host Contract, generated from workflow markers.
+ * 12 points: discuss:pre/post, plan:pre/post, execute:pre/wave:pre/wave:post/post,
+ * verify:pre/post, ship:pre/post. Per-step agentRoles and coreArtifacts.
+ */
+export interface LoopHostContractEntry {
+    step: string;
+    points: string[];
+    agentRoles: string[];
+    coreArtifacts: {
+        produces: string[];
+        consumes: string[];
+    };
+}
+export declare const LOOP_HOST_CONTRACT: LoopHostContractEntry[];
+/**
+ * All canonical loop points derived from LOOP_HOST_CONTRACT.
+ */
+export declare function getAllCanonicalPoints(): string[];

package/dist/src/gsd/loop-host-contract.js

@@ -0,0 +1,39 @@
+export const LOOP_HOST_CONTRACT = [
+    {
+        step: "discuss",
+        points: ["discuss:pre", "discuss:post"],
+        agentRoles: ["orchestrator"],
+        coreArtifacts: { produces: ["CONTEXT.md"], consumes: [] },
+    },
+    {
+        step: "plan",
+        points: ["plan:pre", "plan:post"],
+        agentRoles: ["researcher", "planner", "checker"],
+        coreArtifacts: { produces: ["PLAN.md"], consumes: ["CONTEXT.md"] },
+    },
+    {
+        step: "execute",
+        points: ["execute:pre", "execute:wave:pre", "execute:wave:post", "execute:post"],
+        agentRoles: ["executor", "verifier"],
+        coreArtifacts: { produces: ["SUMMARY.md"], consumes: ["PLAN.md"] },
+    },
+    {
+        step: "verify",
+        points: ["verify:pre", "verify:post"],
+        agentRoles: ["orchestrator"],
+        coreArtifacts: { produces: ["UAT.md"], consumes: ["SUMMARY.md"] },
+    },
+    {
+        step: "ship",
+        points: ["ship:pre", "ship:post"],
+        agentRoles: ["orchestrator"],
+        coreArtifacts: { produces: [], consumes: ["UAT.md"] },
+    },
+];
+/**
+ * All canonical loop points derived from LOOP_HOST_CONTRACT.
+ */
+export function getAllCanonicalPoints() {
+    return LOOP_HOST_CONTRACT.flatMap((e) => e.points);
+}
+//# sourceMappingURL=loop-host-contract.js.map

package/dist/src/gsd/loop-host.d.ts

@@ -0,0 +1,69 @@
+import type { TaskRequest, ToolResult } from "../types/index.js";
+import { type LoopHooksEnvelope } from "./gsd-dispatch.js";
+import { type RunPerspectiveFn } from "./plan-council.js";
+import type { GsdPhase } from "./types.js";
+export interface LoopHostContext {
+    cwd: string;
+    sessionModelId: string;
+    depth: string;
+    phase?: GsdPhase | null;
+    sessionId?: string;
+    runPerspectiveFn?: RunPerspectiveFn;
+    revisionCycle?: number;
+    verifyPassed?: boolean;
+    verifyEvidence?: Record<string, unknown>;
+    planBody?: string;
+    planTitle?: string;
+    shipNotes?: string[];
+    commitMessage?: string;
+    runDebate?: (topic: string) => Promise<string>;
+}
+export interface LoopPointResult {
+    point: string;
+    gsdHooks?: LoopHooksEnvelope;
+    overlayRan: boolean;
+    overlayError?: string;
+}
+type OverlayHandler = (ctx: LoopHostContext) => Promise<void> | void;
+/**
+ * Full Loop Host — fires gsd-core loop render-hooks then muonroi overlay handlers.
+ * gsd-core owns capability registry + hook resolution; muonroi owns plan-council + execute gates.
+ */
+export declare class GsdLoopHost {
+    private overlays;
+    private readonly hostProfile;
+    constructor();
+    registerOverlay(point: string, handler: OverlayHandler): void;
+    contractSteps(): import("./loop-host-contract.js").LoopHostContractEntry[];
+    canonicalPoints(): string[];
+    /** Bootstrap .planning/ via gsd-tools + muonroi config bridge. */
+    ensureHost(cwd: string, sessionModelId: string): void;
+    getHostProfile(): {
+        embeddingMode: "imperative";
+        commandSurface: "slash-programmatic";
+        hookBus: "host";
+        stateIO: "filesystem";
+        runtime: "bun";
+        native_host: string;
+    };
+    /**
+     * Fire one loop point: gsd-core hooks first (observability + gate metadata),
+     * then muonroi overlay (plan-council, phase advance).
+     */
+    firePoint(point: string, ctx: LoopHostContext): Promise<LoopPointResult>;
+    /** Map tool lifecycle → loop points. */
+    onDiscussComplete(ctx: LoopHostContext): Promise<LoopPointResult>;
+    onPlanWritten(ctx: LoopHostContext): Promise<LoopPointResult>;
+    /** plan:post (council) + plan-review:post (execute gate). */
+    onPlanReviewComplete(ctx: LoopHostContext): Promise<LoopPointResult>;
+    onExecuteStart(ctx: LoopHostContext): Promise<LoopPointResult>;
+    onExecuteComplete(ctx: LoopHostContext): Promise<LoopPointResult>;
+    onVerifyComplete(ctx: LoopHostContext): Promise<LoopPointResult>;
+    onShipComplete(ctx: LoopHostContext): Promise<LoopPointResult>;
+    private registerDefaultOverlays;
+    private advanceTaskPhase;
+}
+export declare function getGsdLoopHost(): GsdLoopHost;
+export declare function taskToRunPerspectiveFn(runTask: (request: TaskRequest, abortSignal?: AbortSignal) => Promise<ToolResult>, sessionModelId: string): RunPerspectiveFn;
+export declare function loopHostContext(cwd: string, sessionModelId: string, depth: string, opts?: Pick<LoopHostContext, "runPerspectiveFn" | "revisionCycle" | "phase" | "sessionId" | "verifyPassed" | "verifyEvidence" | "planBody" | "planTitle" | "shipNotes" | "commitMessage" | "runDebate">): LoopHostContext;
+export {};

package/dist/src/gsd/loop-host.js

@@ -0,0 +1,245 @@
+import { existsSync, readFileSync } from "node:fs";
+import { ensurePlanningWorkspace } from "./config-bridge.js";
+import { fireGsdVerifyOutcome, logGsdNativeEvent } from "./ee-closure.js";
+import { dispatchConfigEnsure, dispatchLoopRenderHooks, dispatchStateUpdate, PHASE_TO_GSD_STATUS, } from "./gsd-dispatch.js";
+import { allLoopHostPoints, loadLoopHostContract } from "./gsd-runtime.js";
+import { buildGsdPerspectiveTaskRequest } from "./model-tier.js";
+import { planningArtifact } from "./paths.js";
+import { extractPlanTitle, mirrorVerifyMdToPhaseDir, syncTaskPhaseOnPlan, syncTaskPhaseOnVerifyPass, } from "./phase-sync.js";
+import { runPlanCouncil } from "./plan-council.js";
+import { runTaskShip } from "./ship-bridge.js";
+import { readState, readWorkflowKind, setStateField } from "./workflow-engine.js";
+/**
+ * Full Loop Host — fires gsd-core loop render-hooks then muonroi overlay handlers.
+ * gsd-core owns capability registry + hook resolution; muonroi owns plan-council + execute gates.
+ */
+export class GsdLoopHost {
+    overlays = new Map();
+    hostProfile = {
+        embeddingMode: "imperative",
+        commandSurface: "slash-programmatic",
+        hookBus: "host",
+        stateIO: "filesystem",
+        runtime: "bun",
+        native_host: "muonroi-cli",
+    };
+    constructor() {
+        this.registerDefaultOverlays();
+    }
+    registerOverlay(point, handler) {
+        this.overlays.set(point, handler);
+    }
+    contractSteps() {
+        return loadLoopHostContract();
+    }
+    canonicalPoints() {
+        return allLoopHostPoints();
+    }
+    /** Bootstrap .planning/ via gsd-tools + muonroi config bridge. */
+    ensureHost(cwd, sessionModelId) {
+        dispatchConfigEnsure(cwd);
+        ensurePlanningWorkspace(cwd, sessionModelId);
+    }
+    getHostProfile() {
+        return { ...this.hostProfile };
+    }
+    /**
+     * Fire one loop point: gsd-core hooks first (observability + gate metadata),
+     * then muonroi overlay (plan-council, phase advance).
+     */
+    async firePoint(point, ctx) {
+        this.ensureHost(ctx.cwd, ctx.sessionModelId);
+        const canonical = this.canonicalPoints();
+        let gsdHooks;
+        if (canonical.includes(point)) {
+            const gsdResult = dispatchLoopRenderHooks(ctx.cwd, point);
+            gsdHooks = gsdResult.ok ? gsdResult.data : undefined;
+        }
+        if (gsdHooks?.activeHooks?.some((h) => h.blocking === true && h.kind === "gate")) {
+            console.error(`[gsd-loop-host] blocking gate at ${point}: ${JSON.stringify(gsdHooks.activeHooks.filter((h) => h.blocking))}`);
+        }
+        let overlayRan = false;
+        let overlayError;
+        const overlay = this.overlays.get(point);
+        if (overlay) {
+            overlayRan = true;
+            try {
+                await overlay(ctx);
+            }
+            catch (err) {
+                overlayError = err.message;
+                console.error(`[gsd-loop-host] overlay ${point} failed: ${overlayError}`);
+            }
+        }
+        return { point, gsdHooks, overlayRan, overlayError };
+    }
+    /** Map tool lifecycle → loop points. */
+    async onDiscussComplete(ctx) {
+        return this.firePoint("discuss:post", ctx);
+    }
+    async onPlanWritten(ctx) {
+        return this.firePoint("plan:pre", ctx);
+    }
+    /** plan:post (council) + plan-review:post (execute gate). */
+    async onPlanReviewComplete(ctx) {
+        await this.firePoint("plan:post", ctx);
+        return this.firePoint("plan-review:post", ctx);
+    }
+    async onExecuteStart(ctx) {
+        return this.firePoint("execute:pre", ctx);
+    }
+    async onExecuteComplete(ctx) {
+        return this.firePoint("execute:post", ctx);
+    }
+    async onVerifyComplete(ctx) {
+        await this.firePoint("verify:pre", ctx);
+        return this.firePoint("verify:post", ctx);
+    }
+    async onShipComplete(ctx) {
+        await this.firePoint("ship:pre", ctx);
+        return this.firePoint("ship:post", ctx);
+    }
+    registerDefaultOverlays() {
+        this.registerOverlay("discuss:post", (ctx) => {
+            this.advanceTaskPhase(ctx, "plan");
+        });
+        this.registerOverlay("plan:pre", (ctx) => {
+            if (readWorkflowKind(ctx.cwd) === "product")
+                return;
+            const planPath = planningArtifact(ctx.cwd, "PLAN.md");
+            try {
+                if (!existsSync(planPath))
+                    return;
+                const body = ctx.planBody ?? readFileSync(planPath, "utf8");
+                const title = ctx.planTitle ?? extractPlanTitle(body);
+                syncTaskPhaseOnPlan(ctx.cwd, {
+                    planTitle: title,
+                    planBody: body,
+                    sessionId: ctx.sessionId,
+                });
+            }
+            catch (err) {
+                console.error(`[gsd-loop-host] plan:pre phase-sync failed: ${err.message}`);
+            }
+        });
+        this.registerOverlay("plan:post", async (ctx) => {
+            const council = await runPlanCouncil({
+                cwd: ctx.cwd,
+                sessionModelId: ctx.sessionModelId,
+                depth: ctx.depth,
+                runPerspectiveFn: ctx.runPerspectiveFn,
+                revisionCycle: ctx.revisionCycle,
+                runDebate: ctx.runDebate,
+            });
+            logGsdNativeEvent(ctx.sessionId ?? "gsd-native", {
+                phase: ctx.phase ?? readState(ctx.cwd).phase,
+                depth: ctx.depth,
+                loopPoint: "plan:post",
+                planVerified: council.verdict === "pass",
+                councilPerspectives: council.perspectives.length,
+                leaderModelId: council.leaderModelId,
+                councilContextChars: council.contextBundleChars,
+                councilHadPriorConcerns: council.hadPriorConcerns,
+                councilVerdictSource: council.verdictSource,
+                councilVerdictParseFailed: council.verdictParseFailed,
+            });
+        });
+        this.registerOverlay("plan-review:post", (ctx) => {
+            const state = readState(ctx.cwd);
+            if (state.planVerified) {
+                this.advanceTaskPhase(ctx, "execute");
+            }
+        });
+        this.registerOverlay("execute:pre", (ctx) => {
+            dispatchStateUpdate(ctx.cwd, "Status", "In progress");
+        });
+        this.registerOverlay("execute:post", (ctx) => {
+            this.advanceTaskPhase(ctx, "verify");
+        });
+        this.registerOverlay("verify:pre", (_ctx) => {
+            /* Tests/self-verify run in gsd_verify tool body. */
+        });
+        this.registerOverlay("verify:post", (ctx) => {
+            const passed = ctx.verifyPassed === true;
+            fireGsdVerifyOutcome({
+                sessionId: ctx.sessionId,
+                cwd: ctx.cwd,
+                depth: ctx.depth,
+                passed,
+                evidence: ctx.verifyEvidence,
+            });
+            if (!passed) {
+                this.advanceTaskPhase(ctx, "debug");
+                dispatchStateUpdate(ctx.cwd, "Status", "In progress");
+                return;
+            }
+            if (readWorkflowKind(ctx.cwd) !== "product") {
+                const evidence = typeof ctx.verifyEvidence?.evidence === "string" ? ctx.verifyEvidence.evidence : undefined;
+                const sync = syncTaskPhaseOnVerifyPass(ctx.cwd, {
+                    evidence,
+                    sessionId: ctx.sessionId,
+                });
+                const phaseDir = sync.phaseDirName;
+                if (phaseDir)
+                    mirrorVerifyMdToPhaseDir(ctx.cwd, phaseDir);
+            }
+            this.advanceTaskPhase(ctx, "review");
+            dispatchStateUpdate(ctx.cwd, "Status", PHASE_TO_GSD_STATUS.review ?? "Phase complete");
+        });
+        this.registerOverlay("ship:pre", (ctx) => {
+            dispatchStateUpdate(ctx.cwd, "Status", "Phase complete");
+        });
+        this.registerOverlay("ship:post", (ctx) => {
+            const result = runTaskShip({
+                cwd: ctx.cwd,
+                notes: ctx.shipNotes,
+                commitMessage: ctx.commitMessage,
+            });
+            logGsdNativeEvent(ctx.sessionId ?? "gsd-native", {
+                phase: "review",
+                depth: ctx.depth,
+                loopPoint: "ship:post",
+                shipNotes: result.notes,
+            });
+        });
+    }
+    advanceTaskPhase(ctx, phase) {
+        setStateField(ctx.cwd, "Phase", phase);
+        setStateField(ctx.cwd, "Depth", ctx.depth);
+        const status = PHASE_TO_GSD_STATUS[phase];
+        if (status) {
+            dispatchStateUpdate(ctx.cwd, "Status", status);
+        }
+    }
+}
+let _defaultHost = null;
+export function getGsdLoopHost() {
+    if (!_defaultHost)
+        _defaultHost = new GsdLoopHost();
+    return _defaultHost;
+}
+export function taskToRunPerspectiveFn(runTask, sessionModelId) {
+    return async (prompt, perspective) => {
+        const result = await runTask(buildGsdPerspectiveTaskRequest(prompt, perspective, sessionModelId));
+        return result.output ?? "";
+    };
+}
+export function loopHostContext(cwd, sessionModelId, depth, opts) {
+    return {
+        cwd,
+        sessionModelId,
+        depth,
+        phase: opts?.phase ?? readState(cwd).phase,
+        sessionId: opts?.sessionId,
+        runPerspectiveFn: opts?.runPerspectiveFn,
+        revisionCycle: opts?.revisionCycle,
+        verifyPassed: opts?.verifyPassed,
+        verifyEvidence: opts?.verifyEvidence,
+        planBody: opts?.planBody,
+        planTitle: opts?.planTitle,
+        shipNotes: opts?.shipNotes,
+        commitMessage: opts?.commitMessage,
+        runDebate: opts?.runDebate,
+    };
+}
+//# sourceMappingURL=loop-host.js.map

package/dist/src/gsd/loop-resolver.d.ts

@@ -0,0 +1,36 @@
+/**
+ * loop-resolver.ts — Native replacement for gsd-core/bin/lib/loop-resolver.cjs
+ *
+ * ADR-857 phase 3c registry-consuming query.
+ * Given a loop point (one of the 12 canonical points from loop-host-contract.ts),
+ * filters the frozen Capability Registry by config activation and returns
+ * the active hooks as a JSON envelope.
+ */
+import type { CapabilityRegistry, LoopHook } from "./capability-registry.js";
+export interface ResolvedLoopHooks {
+    point: string;
+    activeHooks: LoopHook[];
+}
+/**
+ * Pure resolver: given a point, registry, and config, returns the active hooks.
+ *
+ * Throws if `point` is not one of the 12 canonical points.
+ * Never throws for malformed registry/hook entries — skips and continues.
+ *
+ * Activation: a hook with no `when` is always active. With `when` (dotted key),
+ * resolved against `config`; active iff truthy. Inactive hooks are filtered out.
+ */
+export declare function resolveLoopHooks(input: {
+    point: string;
+    registry: CapabilityRegistry;
+    config: Record<string, unknown>;
+    cwd?: string;
+}): ResolvedLoopHooks;
+/**
+ * Render resolved hooks as a simple envelope for backward compatibility
+ * with the existing GsdDispatchResult shape.
+ */
+export declare function renderLoopHooksEnvelope(resolved: ResolvedLoopHooks): {
+    point: string;
+    activeHooks: LoopHook[];
+};

package/dist/src/gsd/loop-resolver.js

@@ -0,0 +1,79 @@
+import { resolveConfigKey } from "./config-loader.js";
+import { getAllCanonicalPoints } from "./loop-host-contract.js";
+/**
+ * Pure resolver: given a point, registry, and config, returns the active hooks.
+ *
+ * Throws if `point` is not one of the 12 canonical points.
+ * Never throws for malformed registry/hook entries — skips and continues.
+ *
+ * Activation: a hook with no `when` is always active. With `when` (dotted key),
+ * resolved against `config`; active iff truthy. Inactive hooks are filtered out.
+ */
+export function resolveLoopHooks(input) {
+    const { point, registry, config } = input;
+    // Validate point against canonical points
+    const canonicalPoints = getAllCanonicalPoints();
+    if (!canonicalPoints.includes(point)) {
+        throw new Error(`Invalid loop point: "${point}". Valid points: ${canonicalPoints.join(", ")}`);
+    }
+    // Guard: registry missing byLoopPoint
+    const byLoopPoint = registry.byLoopPoint;
+    if (!byLoopPoint || typeof byLoopPoint !== "object") {
+        return { point, activeHooks: [] };
+    }
+    // Guard: point missing in registry
+    const entry = byLoopPoint[point];
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) {
+        return { point, activeHooks: [] };
+    }
+    const activeHooks = [];
+    // Helper: check activation using config key resolver
+    function isActive(hook) {
+        const when = hook.when;
+        if (when === undefined || when === null)
+            return true;
+        if (typeof when !== "string" || when.length === 0)
+            return false;
+        const { found, value } = resolveConfigKey(when, config);
+        return found && value === true;
+    }
+    // Process steps
+    const steps = Array.isArray(entry.steps) ? entry.steps : [];
+    for (const hook of steps) {
+        if (!hook || typeof hook !== "object")
+            continue;
+        if (!isActive(hook))
+            continue;
+        activeHooks.push(hook);
+    }
+    // Process contributions
+    const contributions = Array.isArray(entry.contributions) ? entry.contributions : [];
+    for (const hook of contributions) {
+        if (!hook || typeof hook !== "object")
+            continue;
+        if (!isActive(hook))
+            continue;
+        activeHooks.push(hook);
+    }
+    // Process gates
+    const gates = Array.isArray(entry.gates) ? entry.gates : [];
+    for (const hook of gates) {
+        if (!hook || typeof hook !== "object")
+            continue;
+        if (!isActive(hook))
+            continue;
+        activeHooks.push(hook);
+    }
+    return { point, activeHooks };
+}
+/**
+ * Render resolved hooks as a simple envelope for backward compatibility
+ * with the existing GsdDispatchResult shape.
+ */
+export function renderLoopHooksEnvelope(resolved) {
+    return {
+        point: resolved.point,
+        activeHooks: resolved.activeHooks,
+    };
+}
+//# sourceMappingURL=loop-resolver.js.map

package/dist/src/gsd/model-tier.d.ts

@@ -0,0 +1,13 @@
+import type { BuiltinSubagentId, TaskRequest } from "../types/index.js";
+import type { PlanPerspective, PlanPerspectiveId } from "./plan-council-prompts.js";
+/**
+ * GSD-only premium resolver — always picks the highest-tier model on the
+ * session provider for plan-council / verify gates. Unlike
+ * resolveLeaderModelDetailed, this intentionally promotes within-provider
+ * for critical GSD stages.
+ */
+export declare function resolveGsdPremiumModel(sessionModelId: string): string;
+/** Research perspectives ground against the codebase; others validate rigorously. */
+export declare function resolveGsdPerspectiveAgent(id: PlanPerspectiveId): BuiltinSubagentId;
+export declare function buildGsdPerspectiveTaskRequest(prompt: string, perspective: PlanPerspective, sessionModelId: string, descriptionPrefix?: string): TaskRequest;
+export declare function tierOfModel(modelId: string): "fast" | "balanced" | "premium" | undefined;