muonroi-cli 1.8.4 → 1.9.0

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

@@ -0,0 +1,283 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { resolvePlanCouncilLeader } from "../council/leader.js";
+import { buildCouncilContextBundle } from "./council-context.js";
+import { getPlanReviewDebateRetries } from "./flags.js";
+import { buildGsdPerspectiveTaskRequest } from "./model-tier.js";
+import { planningArtifact } from "./paths.js";
+import { buildDebateTopic, buildPerspectivePrompt, perspectivesForDepth, } from "./plan-council-prompts.js";
+import { extractStructuredVerdict } from "./verdict-schema.js";
+import { advancePhase, setStateField } from "./workflow-engine.js";
+function readPlanBody(cwd) {
+    const path = planningArtifact(cwd, "PLAN.md");
+    if (!existsSync(path))
+        return "";
+    return readFileSync(path, "utf8");
+}
+function heuristicReview(planBody, perspective) {
+    const concerns = [];
+    const evidence = [];
+    const lower = planBody.toLowerCase();
+    const hasStructure = /\d+\.|step|acceptance|criteria|verify/i.test(planBody);
+    if (planBody.trim().length < 80 && !hasStructure) {
+        concerns.push("Plan is too short — lacks concrete steps.");
+    }
+    if (!hasStructure) {
+        concerns.push("Missing numbered steps or acceptance criteria.");
+    }
+    if (perspective.id === "security" && /rm\s+-rf|chmod\s+777|eval\(/i.test(planBody)) {
+        concerns.push("Plan mentions dangerous shell patterns.");
+        evidence.push("security: dangerous command pattern detected in plan text");
+    }
+    if (perspective.id === "research" && !/file:|src\/|\.ts|\.tsx/i.test(planBody)) {
+        concerns.push("No codebase file references — plan may be ungrounded.");
+    }
+    if (perspective.id === "skeptic" && /rewrite|refactor entire|migrate all/i.test(lower)) {
+        concerns.push("Scope may be larger than necessary (YAGNI risk).");
+    }
+    const verdict = concerns.length >= 3 ? "block" : concerns.length >= 1 ? "revise" : "approve";
+    return { id: perspective.id, role: perspective.role, verdict, concerns, evidence, source: "heuristic-fallback" };
+}
+function fromStructured(perspective, parsed, raw) {
+    return {
+        id: perspective.id,
+        role: perspective.role,
+        verdict: parsed.verdict,
+        concerns: parsed.concerns.map(String),
+        evidence: parsed.evidence.map(String),
+        source: "structured",
+        raw,
+    };
+}
+async function runPerspective(planBody, perspective, runFn, bundle) {
+    // No runner — heuristic path (test scaffolding / offline runs).
+    if (!runFn) {
+        return heuristicReview(planBody, perspective);
+    }
+    try {
+        const raw = await runFn(buildPerspectivePrompt(perspective, planBody, bundle), perspective);
+        const parsed = extractStructuredVerdict(raw);
+        if (!parsed) {
+            // Tolerant parse failed — DO NOT silently approve. Fall back to heuristic
+            // so the perspective still contributes a verdict, and flag the source so
+            // telemetry can detect prompt-compliance regressions.
+            console.error(`[gsd] plan-council perspective ${perspective.id} emitted no structured verdict — using heuristic fallback`);
+            const fallback = heuristicReview(planBody, perspective);
+            return { ...fallback, source: "heuristic-fallback", raw };
+        }
+        return fromStructured(perspective, parsed, raw);
+    }
+    catch (err) {
+        console.error(`[gsd] plan-council perspective ${perspective.id} failed: ${err.message}`);
+        return heuristicReview(planBody, perspective);
+    }
+}
+function mergeVerdict(results) {
+    if (results.some((r) => r.verdict === "block"))
+        return "block";
+    if (results.some((r) => r.verdict === "revise"))
+        return "revise";
+    return "pass";
+}
+function formatPlanReview(results, leaderModelId, cycle) {
+    const sections = results.map((r) => {
+        const concerns = r.concerns.length ? r.concerns.map((c) => `- ${c}`).join("\n") : "- (none)";
+        const evidence = r.evidence.length ? r.evidence.map((e) => `- ${e}`).join("\n") : "- (none)";
+        return `## ${r.role} (${r.id})\n\n**Verdict:** ${r.verdict} (source: ${r.source})\n\n**Concerns:**\n${concerns}\n\n**Evidence:**\n${evidence}\n`;
+    });
+    return ["# PLAN-REVIEW", "", `Leader: \`${leaderModelId}\``, `Revision cycle: ${cycle}`, "", ...sections].join("\n");
+}
+function formatPlanVerify(verdict, results, opts) {
+    const allConcerns = results.flatMap((r) => r.concerns);
+    return [
+        "# PLAN-VERIFY",
+        "",
+        `verdict: ${verdict}`,
+        `revisionRequired: ${verdict === "revise" || verdict === "block" ? "yes" : "no"}`,
+        `verdictSource: ${opts.source}`,
+        `verdictParseFailed: ${opts.parseFailed ? "yes" : "no"}`,
+        "",
+        "## Summary",
+        verdict === "pass"
+            ? "All perspectives approved — execute gate unlocked."
+            : `Council raised ${allConcerns.length} concern(s) — ${verdict === "block" ? "blocked" : "revision required"}.`,
+        "",
+        "## Concerns",
+        allConcerns.length ? allConcerns.map((c) => `- ${c}`).join("\n") : "- (none)",
+    ].join("\n");
+}
+function applyVerdict(cwd, verdict) {
+    if (verdict === "pass") {
+        setStateField(cwd, "Plan Verified", "yes");
+        advancePhase(cwd, "execute");
+    }
+    else {
+        setStateField(cwd, "Plan Verified", "no");
+        if (verdict === "revise") {
+            advancePhase(cwd, "plan");
+        }
+    }
+}
+export async function runPlanCouncil(opts) {
+    const { cwd, sessionModelId, depth, runPerspectiveFn, revisionCycle = 0 } = opts;
+    const perspectives = perspectivesForDepth(depth);
+    if (perspectives.length === 0) {
+        return { skipped: true, perspectives: [], verdict: "pass", revisionRequired: false };
+    }
+    const planBody = readPlanBody(cwd);
+    if (!planBody.trim()) {
+        return {
+            skipped: false,
+            perspectives: [],
+            verdict: "block",
+            revisionRequired: true,
+            verdictSource: "heuristic-fallback",
+        };
+    }
+    // ---------- Debate path (production wiring: runCouncilV2 synthesis) ----------
+    if (opts.runDebate) {
+        const leader = await resolvePlanCouncilLeader(sessionModelId);
+        const bundle = buildCouncilContextBundle(cwd, { depth, revisionCycle });
+        const topic = buildDebateTopic(planBody, bundle);
+        // The council debate returns an EMPTY synthesis on any of its fail-open
+        // paths (provider unreachable, sub-phase catch, user/watchdog abort) — a
+        // silent null we must NOT collapse into a permanent forced-`revise`. Retry
+        // the debate on empty (covers transient aborts), then fall back to the
+        // perspective path so an autonomous /ideal run never bricks with 0 code.
+        const maxRetries = getPlanReviewDebateRetries();
+        let synthesis = "";
+        let lastDebateError;
+        for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+            try {
+                synthesis = (await opts.runDebate(topic)) ?? "";
+            }
+            catch (err) {
+                lastDebateError = err.message;
+                console.error(`[gsd] plan-review debate threw (attempt ${attempt + 1}/${maxRetries + 1}): ${lastDebateError}`);
+                synthesis = "";
+            }
+            if (synthesis.trim())
+                break;
+            if (attempt < maxRetries) {
+                console.error(`[gsd] plan-review debate returned empty synthesis ` +
+                    `(attempt ${attempt + 1}/${maxRetries + 1}) — provider unreachable / aborted / ` +
+                    `sub-phase fail-open; retrying`);
+            }
+        }
+        // Persistent empty synthesis after retries — this is a DEBATE FAILURE, not
+        // a plan defect. Do NOT write a misleading "leader did not emit a verdict"
+        // forced-revise (which would brick the run). Log the real reason
+        // (No-Silent-Catch) and fall through to the perspective path below, which
+        // produces a genuine verdict from parallel sub-agent reviewers (heuristic
+        // last resort) so the loop can proceed.
+        if (!synthesis.trim()) {
+            console.error(`[gsd] plan-review debate produced no synthesis after ${maxRetries + 1} attempt(s)` +
+                `${lastDebateError ? ` (last error: ${lastDebateError})` : ""} — ` +
+                `falling back to perspective review`);
+        }
+        else {
+            const parsed = extractStructuredVerdict(synthesis);
+            const parseFailed = parsed === null;
+            // Model-first: if we could not extract structured verdict, DO NOT regex
+            // the prose. Force a conservative revise so the loop iterates and the
+            // leader gets another chance to emit valid JSON (the prior-concerns
+            // directive re-states the contract).
+            // Map "approve" → "pass" so the merged verdict matches the union the rest
+            // of the pipeline expects (applyVerdict keys the gate on `=== "pass"`).
+            const rawVerdict = parseFailed ? "revise" : parsed.verdict;
+            const verdict = rawVerdict === "approve" ? "pass" : rawVerdict;
+            const source = parseFailed ? "parse-failed" : "structured";
+            const concerns = parsed?.concerns.map(String) ?? [
+                "Council leader did not emit a structured verdict block — forcing revision.",
+            ];
+            const evidence = parsed?.evidence.map(String) ?? [];
+            const rationale = parsed?.rationale ?? "";
+            const planReviewPath = planningArtifact(cwd, "PLAN-REVIEW.md");
+            const planVerifyPath = planningArtifact(cwd, "PLAN-VERIFY.md");
+            const reviewContent = [
+                "# PLAN-REVIEW",
+                "",
+                `Leader: \`${leader.modelId}\``,
+                `Revision cycle: ${revisionCycle}`,
+                `Verdict source: ${source}${parseFailed ? " (parse failed — forced revise)" : ""}`,
+                "",
+                "## Council Debate Synthesis",
+                "",
+                synthesis.trim() || "No synthesis generated.",
+                rationale ? `\n**Rationale:** ${rationale}` : "",
+                "",
+                "## Merged Concerns",
+                "",
+                concerns.length ? concerns.map((c) => `- ${c}`).join("\n") : "- (none)",
+            ].join("\n");
+            const verifyContent = [
+                "# PLAN-VERIFY",
+                "",
+                `verdict: ${verdict}`,
+                `revisionRequired: ${verdict === "revise" || verdict === "block" ? "yes" : "no"}`,
+                `verdictSource: ${source}`,
+                `verdictParseFailed: ${parseFailed ? "yes" : "no"}`,
+                "",
+                "## Summary",
+                verdict === "pass"
+                    ? "Council leader approved via structured verdict."
+                    : parseFailed
+                        ? "Structured verdict missing — forced revision so the leader re-emits valid JSON."
+                        : `Council requested ${verdict}.`,
+                "",
+                "## Concerns",
+                concerns.length ? concerns.map((c) => `- ${c}`).join("\n") : "- (none)",
+            ].join("\n");
+            writeFileSync(planReviewPath, reviewContent, "utf8");
+            writeFileSync(planVerifyPath, verifyContent, "utf8");
+            applyVerdict(cwd, verdict);
+            return {
+                skipped: false,
+                perspectives: [],
+                planReviewPath,
+                planVerifyPath,
+                verdict,
+                leaderModelId: leader.modelId,
+                revisionRequired: verdict === "revise" || verdict === "block",
+                contextBundleChars: bundle.totalChars,
+                hadPriorConcerns: bundle.hadPriorConcerns,
+                verdictSource: source,
+                verdictParseFailed: parseFailed,
+            };
+        }
+    }
+    // ---------- Perspective path (parallel sub-agents) ----------
+    const leader = await resolvePlanCouncilLeader(sessionModelId);
+    const bundle = buildCouncilContextBundle(cwd, { depth, revisionCycle });
+    // Perspectives are independent — run in parallel, preserve declared order.
+    const settled = await Promise.all(perspectives.map((p) => runPerspective(planBody, p, runPerspectiveFn, bundle)));
+    const results = settled;
+    const verdict = mergeVerdict(results);
+    const anyParseFailed = results.some((r) => r.source === "heuristic-fallback");
+    const source = anyParseFailed ? "heuristic-fallback" : "structured";
+    const planReviewPath = planningArtifact(cwd, "PLAN-REVIEW.md");
+    const planVerifyPath = planningArtifact(cwd, "PLAN-VERIFY.md");
+    writeFileSync(planReviewPath, formatPlanReview(results, leader.modelId, revisionCycle), "utf8");
+    writeFileSync(planVerifyPath, formatPlanVerify(verdict, results, { source, parseFailed: false }), "utf8");
+    applyVerdict(cwd, verdict);
+    return {
+        skipped: false,
+        perspectives: results,
+        planReviewPath,
+        planVerifyPath,
+        verdict,
+        leaderModelId: leader.modelId,
+        revisionRequired: verdict === "revise" || verdict === "block",
+        contextBundleChars: bundle.totalChars,
+        hadPriorConcerns: bundle.hadPriorConcerns,
+        verdictSource: source,
+        verdictParseFailed: false,
+    };
+}
+/** Adapter: wrap orchestrator runTask as perspective runner. */
+export function taskToPerspectiveRunner(runTask, sessionModelId) {
+    return async (prompt, perspective) => {
+        const result = await runTask(buildGsdPerspectiveTaskRequest(prompt, perspective, sessionModelId));
+        return result.output ?? "";
+    };
+}
+//# sourceMappingURL=plan-council.js.map

package/dist/src/gsd/plan-gate-vocabulary.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Single source of truth for the GSD plan-gate's EVALUATION AXES.
+ *
+ * The plan gate has two prompt paths — the interactive full-council debate
+ * (`buildDebateTopic`) and the headless/offline perspective review
+ * (`buildPerspectivePrompt` over `PLAN_PERSPECTIVES`). Both must judge a plan
+ * against the SAME criteria, or the two gates drift: a plan the debate would
+ * revise could pass headless (or vice-versa). The verdict *schema* is already
+ * shared (`PlanCouncilVerdictSchema` + `VERDICT_OUTPUT_CONTRACT`); this module
+ * closes the remaining gap by making the review CRITERIA a single constant both
+ * builders derive from. A parity test locks it: drop or rename an axis and the
+ * mismatch surfaces immediately.
+ *
+ * Council decision 2026-07-11 (multi-provider, research-grounded): unify the
+ * gate's criteria vocabulary + verdict contract behind one source; keep both
+ * paths (interactive debate + headless fallback) but stop them from diverging.
+ */
+export type PlanGateDimensionId = "correctness" | "structure" | "safety" | "grounding" | "feasibility";
+export interface PlanGateDimension {
+    id: PlanGateDimensionId;
+    /** Short human label used in rendered prompt axes. */
+    label: string;
+    /** What a reviewer checks for this axis (drives both the debate topic and the perspective mandates). */
+    probe: string;
+}
+/**
+ * The canonical axes every plan is judged against — the union of what the
+ * interactive debate ("complete, correct, safe, optimal") and the headless
+ * perspectives (architect / skeptic / research / security / implementer)
+ * historically evaluated, deduplicated into one list.
+ */
+export declare const PLAN_GATE_DIMENSIONS: readonly PlanGateDimension[];
+/** Fast lookup by id. */
+export declare const PLAN_GATE_DIMENSION_BY_ID: Readonly<Record<PlanGateDimensionId, PlanGateDimension>>;
+/**
+ * Render the axes as a bullet list for a prompt. Both the debate topic and the
+ * perspective prompt append this so a plan is judged against identical criteria
+ * regardless of which gate path runs.
+ */
+export declare function renderGateAxes(): string;

package/dist/src/gsd/plan-gate-vocabulary.js

@@ -0,0 +1,64 @@
+/**
+ * Single source of truth for the GSD plan-gate's EVALUATION AXES.
+ *
+ * The plan gate has two prompt paths — the interactive full-council debate
+ * (`buildDebateTopic`) and the headless/offline perspective review
+ * (`buildPerspectivePrompt` over `PLAN_PERSPECTIVES`). Both must judge a plan
+ * against the SAME criteria, or the two gates drift: a plan the debate would
+ * revise could pass headless (or vice-versa). The verdict *schema* is already
+ * shared (`PlanCouncilVerdictSchema` + `VERDICT_OUTPUT_CONTRACT`); this module
+ * closes the remaining gap by making the review CRITERIA a single constant both
+ * builders derive from. A parity test locks it: drop or rename an axis and the
+ * mismatch surfaces immediately.
+ *
+ * Council decision 2026-07-11 (multi-provider, research-grounded): unify the
+ * gate's criteria vocabulary + verdict contract behind one source; keep both
+ * paths (interactive debate + headless fallback) but stop them from diverging.
+ */
+/**
+ * The canonical axes every plan is judged against — the union of what the
+ * interactive debate ("complete, correct, safe, optimal") and the headless
+ * perspectives (architect / skeptic / research / security / implementer)
+ * historically evaluated, deduplicated into one list.
+ */
+export const PLAN_GATE_DIMENSIONS = [
+    {
+        id: "correctness",
+        label: "Correct & complete",
+        probe: "Every task has concrete steps and acceptance criteria; nothing essential is missing.",
+    },
+    {
+        id: "structure",
+        label: "Structural fit",
+        probe: "File map is correct, dependency order is sound, module boundaries are respected.",
+    },
+    {
+        id: "safety",
+        label: "Safe",
+        probe: "Permission model, path traversal, secret handling, and any planned bash are safe.",
+    },
+    {
+        id: "grounding",
+        label: "Grounded",
+        probe: "Plan claims cite real codebase evidence (file:line), not assumptions.",
+    },
+    {
+        id: "feasibility",
+        label: "Feasible & optimal",
+        probe: "Estimates are realistic and it is the simplest approach that works — no YAGNI or scope creep.",
+    },
+];
+/** Fast lookup by id. */
+export const PLAN_GATE_DIMENSION_BY_ID = Object.fromEntries(PLAN_GATE_DIMENSIONS.map((d) => [d.id, d]));
+/**
+ * Render the axes as a bullet list for a prompt. Both the debate topic and the
+ * perspective prompt append this so a plan is judged against identical criteria
+ * regardless of which gate path runs.
+ */
+export function renderGateAxes() {
+    return [
+        "The plan is judged against these axes:",
+        ...PLAN_GATE_DIMENSIONS.map((d) => `- ${d.label}: ${d.probe}`),
+    ].join("\n");
+}
+//# sourceMappingURL=plan-gate-vocabulary.js.map

package/dist/src/gsd/product-workspace.d.ts

@@ -0,0 +1,13 @@
+import type { PhasePlanArtifact, ProductSpec } from "../product-loop/types.js";
+export interface ProductWorkspaceOpts {
+    idea: string;
+    sessionModelId: string;
+    productSpec?: ProductSpec;
+    runId?: string;
+}
+export declare function buildProjectMd(idea: string, spec?: ProductSpec): string;
+export declare function buildRoadmapFromPhasePlan(idea: string, plan: PhasePlanArtifact): string;
+/** Bootstrap gsd-compatible PROJECT.md + ROADMAP.md for WorkflowKind.product (/ideal). */
+export declare function ensureProductPlanningWorkspace(cwd: string, opts: ProductWorkspaceOpts): string;
+export declare function syncRoadmapFromPhasePlan(cwd: string, idea: string, plan: PhasePlanArtifact): void;
+export declare function readProjectMdSummary(cwd: string): string | null;

package/dist/src/gsd/product-workspace.js

@@ -0,0 +1,124 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { ensurePlanningWorkspace } from "./config-bridge.js";
+import { planningArtifact, planningRoot } from "./paths.js";
+import { setStateField } from "./workflow-engine.js";
+export function buildProjectMd(idea, spec) {
+    const title = idea.trim().slice(0, 80) || "Product";
+    const mvp = spec?.mvp?.length ? spec.mvp.map((m) => `- [ ] ${m}`).join("\n") : `- [ ] ${idea.trim()}`;
+    return `# ${title}
+
+## What This Is
+
+${idea.trim()}
+
+## Core Value
+
+Ship the scoped MVP via Muonroi /ideal with gsd-native phase tracking.
+
+## Requirements
+
+### Active
+
+${mvp}
+
+### Out of Scope
+
+- Post-MVP backlog — tracked in product-loop artifacts, not this milestone
+
+## Context
+
+- Workflow kind: **product** (Muonroi /ideal (native workflow))
+- Stack: ${spec?.stack ?? "TBD"}
+`;
+}
+export function buildRoadmapFromPhasePlan(idea, plan) {
+    const title = idea.trim().slice(0, 80) || "Product";
+    const lines = [
+        `# Roadmap: ${title}`,
+        "",
+        "## Overview",
+        "",
+        `Product loop decomposition — ${plan.phases.length} phase(s) synced from /ideal phase plan.`,
+        "",
+        "## Phases",
+        "",
+    ];
+    plan.phases.forEach((phase, index) => {
+        const num = index + 1;
+        lines.push(`- [ ] **Phase ${num}: ${phase.name}** - ${phase.goal.slice(0, 120)}`);
+    });
+    lines.push("", "## Phase Details", "");
+    plan.phases.forEach((phase, index) => {
+        const num = index + 1;
+        const depText = phase.dependsOn.length > 0
+            ? phase.dependsOn
+                .map((dep) => {
+                // Defensive: dependsOn is declared string[] but an un-normalised
+                // LLM plan can carry bare numbers — String() keeps this crash-proof
+                // regardless of caller (parsePhasePlanJson normalises the common path).
+                const depStr = String(dep);
+                const match = depStr.match(/phase-(\d+)/i) ?? depStr.match(/^(\d+)$/);
+                return match ? `Phase ${match[1]}` : depStr;
+            })
+                .join(", ")
+            : index === 0
+                ? "Nothing (first phase)"
+                : `Phase ${index}`;
+        lines.push(`### Phase ${num}: ${phase.name}`);
+        lines.push(`**Goal**: ${phase.goal}`);
+        lines.push(`**Depends on**: ${depText}`);
+        lines.push("**Success Criteria** (what must be TRUE):");
+        for (const [j, c] of phase.successCriteria.entries()) {
+            lines.push(`  ${j + 1}. ${c}`);
+        }
+        lines.push("**Plans**: TBD");
+        lines.push("");
+        lines.push("Plans:");
+        lines.push(`- [ ] ${String(num).padStart(2, "0")}-01: Sprint scope for ${phase.name}`);
+        lines.push("");
+    });
+    return `${lines.join("\n")}\n`;
+}
+/** Bootstrap gsd-compatible PROJECT.md + ROADMAP.md for WorkflowKind.product (/ideal). */
+export function ensureProductPlanningWorkspace(cwd, opts) {
+    const root = ensurePlanningWorkspace(cwd, opts.sessionModelId);
+    setStateField(cwd, "Workflow Kind", "product");
+    if (opts.runId) {
+        setStateField(cwd, "Ideal Run", opts.runId);
+    }
+    const projectPath = planningArtifact(cwd, "PROJECT.md");
+    if (!existsSync(projectPath)) {
+        writeFileSync(projectPath, `${buildProjectMd(opts.idea, opts.productSpec)}\n`, "utf8");
+    }
+    const roadmapPath = planningArtifact(cwd, "ROADMAP.md");
+    if (!existsSync(roadmapPath)) {
+        const stub = [
+            `# Roadmap: ${opts.idea.trim().slice(0, 80)}`,
+            "",
+            "## Overview",
+            "",
+            "Awaiting /ideal phase plan — ROADMAP will sync when phase-runner generates phases.md.",
+            "",
+            "## Phases",
+            "",
+            "- [ ] **Phase 1: MVP** - Initial /ideal scope",
+            "",
+        ].join("\n");
+        writeFileSync(roadmapPath, `${stub}\n`, "utf8");
+    }
+    return root;
+}
+export function syncRoadmapFromPhasePlan(cwd, idea, plan) {
+    mkdirSync(planningRoot(cwd), { recursive: true });
+    const path = planningArtifact(cwd, "ROADMAP.md");
+    writeFileSync(path, buildRoadmapFromPhasePlan(idea, plan), "utf8");
+}
+export function readProjectMdSummary(cwd) {
+    const path = planningArtifact(cwd, "PROJECT.md");
+    if (!existsSync(path))
+        return null;
+    const raw = readFileSync(path, "utf8");
+    const match = raw.match(/## What This Is\s+([\s\S]*?)(?=\n## |\n---|Z)/);
+    return match?.[1]?.trim() ?? raw.slice(0, 400);
+}
+//# sourceMappingURL=product-workspace.js.map

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

@@ -0,0 +1,25 @@
+export interface TaskShipOpts {
+    cwd: string;
+    notes?: string[];
+    commitMessage?: string;
+    verifyEvidence?: string;
+    changedFiles?: string[];
+}
+export interface TaskShipResult {
+    ok: boolean;
+    shipMdPath: string;
+    notes: string[];
+}
+export declare function readPlanContext(cwd: string): {
+    title: string;
+    planPath: string | null;
+};
+export declare function writeTaskShipMd(cwd: string, payload: {
+    title: string;
+    verifyEvidence?: string;
+    changedFiles?: string[];
+    notes: string[];
+    commitMessage?: string;
+}): string;
+/** Task-level ship — SHIP.md only (no git, no README/package.json). */
+export declare function runTaskShip(opts: TaskShipOpts): TaskShipResult;

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

@@ -0,0 +1,65 @@
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { planningArtifact } from "./paths.js";
+export function readPlanContext(cwd) {
+    const planPath = planningArtifact(cwd, "PLAN.md");
+    if (!existsSync(planPath)) {
+        return { title: "Task delivery", planPath: null };
+    }
+    const body = readFileSync(planPath, "utf8");
+    const h1 = body.match(/^#\s+(.+)$/m);
+    return { title: h1?.[1]?.trim() ?? "Task delivery", planPath };
+}
+export function writeTaskShipMd(cwd, payload) {
+    const shipPath = planningArtifact(cwd, "SHIP.md");
+    const lines = [
+        `# Ship: ${payload.title}`,
+        "",
+        "## Status",
+        "",
+        "Ready for delivery (gsd_ship — muonroi-cli native host).",
+        "",
+    ];
+    if (payload.verifyEvidence?.trim()) {
+        lines.push("## Verify evidence", "", payload.verifyEvidence.trim(), "");
+    }
+    if (payload.commitMessage?.trim()) {
+        lines.push("## Suggested commit message (unverified — agent-supplied)", "", payload.commitMessage.trim(), "");
+    }
+    if (payload.changedFiles?.length) {
+        lines.push("## Files touched", "");
+        for (const f of payload.changedFiles)
+            lines.push(`- ${f}`);
+        lines.push("");
+    }
+    if (payload.notes.length) {
+        lines.push("## Notes", "");
+        for (const n of payload.notes)
+            lines.push(`- ${n}`);
+        lines.push("");
+    }
+    lines.push("---", `_Generated by gsd_ship at ${new Date().toISOString()}_`, "");
+    writeFileSync(shipPath, lines.join("\n"), "utf8");
+    return shipPath;
+}
+/** Task-level ship — SHIP.md only (no git, no README/package.json). */
+export function runTaskShip(opts) {
+    const ctx = readPlanContext(opts.cwd);
+    let verifyEvidence = opts.verifyEvidence;
+    if (!verifyEvidence) {
+        const verifyPath = planningArtifact(opts.cwd, "VERIFY.md");
+        if (existsSync(verifyPath)) {
+            verifyEvidence = readFileSync(verifyPath, "utf8").trim();
+        }
+    }
+    const notes = [...(opts.notes ?? [])];
+    const shipMdPath = writeTaskShipMd(opts.cwd, {
+        title: ctx.title,
+        verifyEvidence,
+        changedFiles: opts.changedFiles,
+        notes,
+        commitMessage: opts.commitMessage,
+    });
+    notes.push(`Wrote ${shipMdPath}`);
+    return { ok: true, shipMdPath, notes };
+}
+//# sourceMappingURL=ship-bridge.js.map

package/dist/src/gsd/state-document.d.ts

@@ -0,0 +1,40 @@
+/**
+ * state-document.ts — Native replacement for gsd-core/bin/lib/state-document.cjs
+ *
+ * STATE.md Document Module — pure transforms for STATE.md text.
+ * This module does not read the filesystem and does not own persistence or locking.
+ */
+export interface StateDocumentModule {
+    stateExtractField: (content: string, fieldName: string) => string | null;
+    stateReplaceField: (content: string, fieldName: string, newValue: string) => string | null;
+}
+/**
+ * Extract a field value from STATE.md content.
+ * Supports bold inline (**FieldName:** value), plain line-start (FieldName: value),
+ * and pipe-table (| FieldName | value |) formats.
+ */
+export declare function stateExtractField(content: string, fieldName: string): string | null;
+/**
+ * Replace a field value in STATE.md content.
+ * Returns null if the field is not found in any known format.
+ */
+export declare function stateReplaceField(content: string, fieldName: string, newValue: string): string | null;
+/**
+ * Replace a field with a primary name, falling back to an alternate field name.
+ */
+export declare function stateReplaceFieldWithFallback(content: string, primary: string, fallback: string | undefined, value: string): string;
+/** Normalize a status string to a canonical value. */
+export declare function normalizeStateStatus(status: string, pausedAt?: string): string;
+/** Compute progress percentage from plan and phase counts. */
+export declare function computeProgressPercent(completedPlans: number | null, totalPlans: number | null, completedPhases: number | null, totalPhases: number | null): number | null;
+/**
+ * KNOWN_TEMPLATE_DEFAULTS — per-field table of handler-written values.
+ * A value in this list is safe to overwrite on the next handler call.
+ */
+export declare const KNOWN_TEMPLATE_DEFAULTS: Record<string, string[]>;
+/**
+ * Regex patterns matching handler-generated Status values with variable components.
+ */
+export declare const KNOWN_STATUS_PATTERNS: RegExp[];
+/** Check if a value is a known template default (handler may overwrite it). */
+export declare function isStateTemplateDefault(field: string, value: string | null | undefined): boolean;