gsd-pi 2.73.1 → 2.74.0-dev.6e23363

package/dist/resources/extensions/gsd/commands-ship.js

@@ -0,0 +1,187 @@
+/**
+ * GSD Command — /gsd ship
+ *
+ * Creates a PR from milestone artifacts: generates title + body from
+ * roadmap, slice summaries, and metrics, then opens via `gh pr create`.
+ */
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { deriveState } from "./state.js";
+import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile } from "./paths.js";
+import { getLedger, getProjectTotals, aggregateByModel, formatCost, formatTokenCount, loadLedgerFromDisk } from "./metrics.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch } from "./native-git-bridge.js";
+import { formatDuration } from "../shared/format-utils.js";
+function git(basePath, args) {
+    return execFileSync("git", args, { cwd: basePath, encoding: "utf-8" }).trim();
+}
+function isValidRefName(name) {
+    try {
+        execFileSync("git", ["check-ref-format", "--branch", name], { stdio: "pipe" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function listSliceIds(basePath, milestoneId) {
+    // Slices live at <milestoneDir>/slices/<sliceId>/ with canonical S\d+ IDs.
+    // Use resolveSlicePath with a probe to find the real slices directory root.
+    const probe = resolveSlicePath(basePath, milestoneId, "S01");
+    let slicesDir = null;
+    if (probe) {
+        // probe looks like <milestoneDir>/slices/S01 — parent is slices dir.
+        slicesDir = probe.replace(/[\\/][^\\/]+$/, "");
+    }
+    else {
+        // Fall back to scanning the milestones roadmap file's sibling slices dir.
+        const roadmap = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+        if (roadmap) {
+            slicesDir = roadmap.replace(/[\\/][^\\/]+$/, "") + "/slices";
+        }
+    }
+    if (!slicesDir || !existsSync(slicesDir))
+        return [];
+    try {
+        return readdirSync(slicesDir, { withFileTypes: true })
+            .filter((e) => e.isDirectory() && /^S\d+$/.test(e.name))
+            .map((e) => e.name)
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function collectSliceSummaries(basePath, milestoneId) {
+    const summaries = [];
+    for (const sliceId of listSliceIds(basePath, milestoneId)) {
+        const summaryPath = resolveSliceFile(basePath, milestoneId, sliceId, "SUMMARY");
+        if (!summaryPath || !existsSync(summaryPath))
+            continue;
+        try {
+            const content = readFileSync(summaryPath, "utf-8").trim();
+            if (content)
+                summaries.push(`### ${sliceId}\n${content}`);
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    return summaries;
+}
+function generatePRContent(basePath, milestoneId, milestoneTitle) {
+    const title = `feat: ${milestoneTitle || milestoneId}`;
+    const sections = [];
+    // TL;DR
+    sections.push("## TL;DR\n");
+    sections.push(`**What:** Ship milestone ${milestoneId} — ${milestoneTitle || "(untitled)"}`);
+    sections.push(`**Why:** Milestone work complete, ready for review.`);
+    sections.push(`**How:** See slice summaries below.\n`);
+    // What — slice summaries
+    const summaries = collectSliceSummaries(basePath, milestoneId);
+    if (summaries.length > 0) {
+        sections.push("## What\n");
+        sections.push(summaries.join("\n\n"));
+        sections.push("");
+    }
+    // Roadmap status
+    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+    if (roadmapPath && existsSync(roadmapPath)) {
+        try {
+            const roadmap = readFileSync(roadmapPath, "utf-8");
+            const checkboxLines = roadmap.split("\n").filter((l) => /^\s*-\s*\[[ x]\]/.test(l));
+            if (checkboxLines.length > 0) {
+                sections.push("## Roadmap\n");
+                sections.push(checkboxLines.join("\n"));
+                sections.push("");
+            }
+        }
+        catch {
+            // non-fatal
+        }
+    }
+    // Metrics
+    const ledger = getLedger();
+    const units = ledger?.units ?? loadLedgerFromDisk(basePath)?.units ?? [];
+    if (units.length > 0) {
+        const totals = getProjectTotals(units);
+        const byModel = aggregateByModel(units);
+        sections.push("## Metrics\n");
+        sections.push(`- **Units executed:** ${units.length}`);
+        sections.push(`- **Total cost:** ${formatCost(totals.cost)}`);
+        sections.push(`- **Tokens:** ${formatTokenCount(totals.tokens.input)} input / ${formatTokenCount(totals.tokens.output)} output`);
+        if (totals.duration > 0) {
+            sections.push(`- **Duration:** ${formatDuration(totals.duration)}`);
+        }
+        if (byModel.length > 0) {
+            sections.push(`- **Models:** ${byModel.map((m) => `${m.model} (${m.units} units)`).join(", ")}`);
+        }
+        sections.push("");
+    }
+    // Change type checklist
+    sections.push("## Change type\n");
+    sections.push("- [x] `feat` — New feature or capability");
+    sections.push("- [ ] `fix` — Bug fix");
+    sections.push("- [ ] `refactor` — Code restructuring");
+    sections.push("- [ ] `test` — Adding or updating tests");
+    sections.push("- [ ] `docs` — Documentation only");
+    sections.push("- [ ] `chore` — Build, CI, or tooling changes\n");
+    // AI disclosure
+    sections.push("---\n");
+    sections.push("*This PR was prepared with AI assistance (GSD auto-mode).*");
+    return { title, body: sections.join("\n") };
+}
+export async function handleShip(args, ctx, _pi) {
+    const basePath = process.cwd();
+    const dryRun = args.includes("--dry-run");
+    const draft = args.includes("--draft");
+    const force = args.includes("--force");
+    const baseMatch = args.match(/--base\s+(\S+)/);
+    const base = baseMatch?.[1] ?? nativeDetectMainBranch(basePath);
+    if (!isValidRefName(base)) {
+        ctx.ui.notify(`Invalid base branch name: ${base}`, "error");
+        return;
+    }
+    // 1. Validate milestone state
+    const state = await deriveState(basePath);
+    if (!state.activeMilestone) {
+        ctx.ui.notify("No active milestone to ship. Complete milestone work first.", "warning");
+        return;
+    }
+    const milestoneId = state.activeMilestone.id;
+    const milestoneTitle = state.activeMilestone.title ?? "";
+    // 2. Check for incomplete work (use GSD phase as proxy — no phase field on ActiveRef)
+    if (state.phase !== "complete" && !force) {
+        ctx.ui.notify(`Milestone ${milestoneId} may not be complete (phase: ${state.phase}). Use --force to ship anyway.`, "warning");
+        return;
+    }
+    // 3. Generate PR content
+    const { title, body } = generatePRContent(basePath, milestoneId, milestoneTitle);
+    // 4. Dry-run — just show the PR content
+    if (dryRun) {
+        ctx.ui.notify(`--- PR Preview ---\n\nTitle: ${title}\n\n${body}`, "info");
+        return;
+    }
+    // 5. Check git state
+    const currentBranch = nativeGetCurrentBranch(basePath);
+    if (!isValidRefName(currentBranch)) {
+        ctx.ui.notify(`Current branch name is invalid for git: ${currentBranch}`, "error");
+        return;
+    }
+    if (currentBranch === base) {
+        ctx.ui.notify(`You're on ${base} — create a feature branch first.`, "warning");
+        return;
+    }
+    // 6. Push and create PR (all argv-safe, no shell interpolation)
+    try {
+        git(basePath, ["push", "-u", "origin", currentBranch]);
+        const ghArgs = ["pr", "create", "--base", base, "--title", title, "--body", body];
+        if (draft)
+            ghArgs.push("--draft");
+        const prUrl = execFileSync("gh", ghArgs, { cwd: basePath, encoding: "utf-8" }).trim();
+        ctx.ui.notify(`PR created: ${prUrl}`, "success");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Failed to create PR: ${msg}`, "error");
+    }
+}

package/dist/resources/extensions/gsd/db-writer.js

@@ -301,8 +301,7 @@ export async function saveRequirementToDb(fields, basePath) {
         catch (diskErr) {
             logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveRequirementToDb', error: String(diskErr.message) });
             try {
-                const rollbackAdapter = db._getAdapter();
-                rollbackAdapter?.prepare('DELETE FROM requirements WHERE id = :id').run({ ':id': id });
+                db.deleteRequirementById(id);
             }
             catch (rollbackErr) {
                 logError('manifest', 'SPLIT BRAIN: disk write failed AND DB rollback failed — DB has orphaned row', { fn: 'saveRequirementToDb', id, error: String(rollbackErr.message) });
@@ -405,7 +404,7 @@ export async function saveDecisionToDb(fields, basePath) {
         catch (diskErr) {
             logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveDecisionToDb', error: String(diskErr.message) });
             try {
-                adapter?.prepare('DELETE FROM decisions WHERE id = :id').run({ ':id': id });
+                db.deleteDecisionById(id);
             }
             catch (rollbackErr) {
                 logError('manifest', 'SPLIT BRAIN: disk write failed AND DB rollback failed — DB has orphaned row', { fn: 'saveDecisionToDb', id, error: String(rollbackErr.message) });
@@ -614,8 +613,7 @@ export async function saveArtifactToDb(opts, basePath) {
             }
             catch (diskErr) {
                 logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveArtifactToDb', error: String(diskErr.message) });
-                const rollbackAdapter = db._getAdapter();
-                rollbackAdapter?.prepare('DELETE FROM artifacts WHERE path = :path').run({ ':path': opts.path });
+                db.deleteArtifactByPath(opts.path);
                 throw diskErr;
             }
         }

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -153,11 +153,11 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `context_pause_threshold`: number (0-100) — context window usage percentage at which auto-mode should pause to suggest checkpointing. Set to `0` to disable. Default: `0` (disabled).
 
-- `token_profile`: `"budget"`, `"balanced"`, or `"quality"` — coordinates model selection, phase skipping, and context compression. `budget` skips research/reassessment and uses cheaper models; `balanced` (default) skips research/reassessment to reduce token burn; `quality` prefers higher-quality models. See token-optimization docs.
+- `token_profile`: `"budget"`, `"balanced"`, `"quality"`, or `"burn-max"` — coordinates model selection, phase skipping, and context compression. `budget` skips research/reassessment and uses cheaper models; `balanced` (default) skips research/reassessment to reduce token burn; `quality` prefers higher-quality models; `burn-max` keeps full-context defaults, disables downgrade routing, and keeps phase skips off.
 
 - `phases`: fine-grained control over which phases run. Usually set by `token_profile`, but can be overridden. Keys:
   - `skip_research`: boolean — skip milestone-level research. Default: `false`.
-  - `reassess_after_slice`: boolean — run roadmap reassessment after each completed slice. Default: `false`.
+  - `reassess_after_slice`: boolean — run roadmap reassessment after each completed slice. Default: `true`.
   - `skip_reassess`: boolean — force-disable roadmap reassessment even if `reassess_after_slice` is enabled. Default: `false`.
   - `skip_slice_research`: boolean — skip per-slice research. Default: `false`.
 
@@ -191,6 +191,19 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
   - `hooks`: boolean — enable routing hooks. Default: `true`.
   - `capability_routing`: boolean — enable capability-profile scoring for model selection within a tier. Requires `enabled: true`. Default: `false`.
 
+- `uok`: Unified Orchestration Kernel controls. Keys:
+  - `enabled`: boolean — enable kernel wrappers and contract observers. Default: `true`.
+  - `legacy_fallback.enabled`: boolean — emergency release fallback that forces legacy orchestration behavior even when `uok.enabled` is `true`. Default: `false`.
+    - Runtime override: set `GSD_UOK_FORCE_LEGACY=1` (or `GSD_UOK_LEGACY_FALLBACK=1`) to force legacy behavior for the current process.
+  - `gates.enabled`: boolean — route checks through the unified gate runner and persist `gate_runs`.
+  - `model_policy.enabled`: boolean — enforce policy filtering before model capability scoring.
+  - `execution_graph.enabled`: boolean — enable DAG scheduler facade/adapters for execution.
+  - `gitops.enabled`: boolean — persist turn-level git transaction records.
+  - `gitops.turn_action`: `"commit"` | `"snapshot"` | `"status-only"` — turn transaction mode.
+  - `gitops.turn_push`: boolean — whether turn transactions should include push intent metadata.
+  - `audit_unified.enabled`: boolean — dual-write unified audit envelope events.
+  - `plan_v2.enabled`: boolean — enable bounded clarify/research/draft/compile planning flow.
+
 - `context_management`: configures context hygiene for auto-mode sessions. Keys:
   - `observation_masking`: boolean — mask old tool results to reduce context bloat. Default: `true`.
   - `observation_mask_turns`: number — keep this many recent turns verbatim (1-50). Default: `8`.

package/dist/resources/extensions/gsd/git-service.js

@@ -15,7 +15,7 @@ import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { detectWorktreeName, } from "./worktree.js";
 import { SLICE_BRANCH_RE, QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
-import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, nativeResetSoft, nativeCommitSubject, } from "./native-git-bridge.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, nativeResetSoft, nativeCommitSubject, _resetHasChangesCache, } from "./native-git-bridge.js";
 import { GSDError, GSD_MERGE_CONFLICT, GSD_GIT_ERROR } from "./errors.js";
 import { getErrorMessage } from "./error-utils.js";
 export const VALID_BRANCH_NAME = /^[a-zA-Z0-9_\-\/.]+$/;
@@ -641,6 +641,54 @@ export function createGitService(basePath) {
     const gitPrefs = loadEffectiveGSDPreferences()?.preferences?.git ?? {};
     return new GitServiceImpl(basePath, gitPrefs);
 }
+function buildTurnSnapshotLabel(unitType, unitId) {
+    const raw = `${unitType}/${unitId}`.trim();
+    if (!raw)
+        return "turn";
+    return raw
+        .replace(/[^a-zA-Z0-9._/-]/g, "-")
+        .replace(/\/{2,}/g, "/")
+        .replace(/-{2,}/g, "-")
+        .replace(/^[-/]+|[-/]+$/g, "") || "turn";
+}
+export function runTurnGitAction(args) {
+    try {
+        // Force fresh working-tree status per turn; nativeHasChanges caches briefly.
+        _resetHasChangesCache();
+        if (args.action === "status-only") {
+            return {
+                action: args.action,
+                status: "ok",
+                dirty: nativeHasChanges(args.basePath),
+            };
+        }
+        const git = createGitService(args.basePath);
+        if (args.action === "snapshot") {
+            const label = buildTurnSnapshotLabel(args.unitType, args.unitId);
+            git.createSnapshot(label);
+            return {
+                action: args.action,
+                status: "ok",
+                snapshotLabel: label,
+                dirty: nativeHasChanges(args.basePath),
+            };
+        }
+        const commitMessage = git.autoCommit(args.unitType, args.unitId, [], args.taskContext) ?? undefined;
+        return {
+            action: args.action,
+            status: "ok",
+            commitMessage,
+            dirty: nativeHasChanges(args.basePath),
+        };
+    }
+    catch (err) {
+        return {
+            action: args.action,
+            status: "failed",
+            error: getErrorMessage(err),
+        };
+    }
+}
 // ─── Commit Type Inference ─────────────────────────────────────────────────
 /**
  * Infer a conventional commit type from a title (and optional one-liner).

package/dist/resources/extensions/gsd/graph-context.js

@@ -0,0 +1,157 @@
+/**
+ * Graph-aware context injection for dispatch prompt builders.
+ *
+ * Reads the pre-built graph.json and returns a formatted context block
+ * for injection into prompts. Gracefully returns null when no graph exists
+ * or the query yields no results — callers must handle null.
+ */
+import { logWarning } from "./workflow-logger.js";
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+let cachedGraphApi = null;
+let resolvedGraphApi = false;
+function readGraphFile(projectDir) {
+    try {
+        const graphPath = join(projectDir, ".gsd", "graphs", "graph.json");
+        const raw = readFileSync(graphPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const nodes = Array.isArray(parsed.nodes) ? parsed.nodes : [];
+        const edges = Array.isArray(parsed.edges) ? parsed.edges : [];
+        return { nodes, edges, builtAt: typeof parsed.builtAt === "string" ? parsed.builtAt : undefined };
+    }
+    catch {
+        return null;
+    }
+}
+async function fallbackGraphQuery(projectDir, term, budget = 3000) {
+    const graph = readGraphFile(projectDir);
+    if (!graph)
+        return { nodes: [], edges: [] };
+    const needle = term.trim().toLowerCase();
+    const matches = graph.nodes.filter((node) => {
+        const hay = [node.id, node.label, node.description].filter(Boolean).join(" ").toLowerCase();
+        return hay.includes(needle);
+    });
+    const maxNodes = Math.max(1, Math.floor(Math.max(1, budget) / 20));
+    const selectedIds = new Set(matches.slice(0, maxNodes).map((node) => node.id));
+    const nodeById = new Map(graph.nodes.map((node) => [node.id, node]));
+    // Pull one-hop neighbors so relation context survives even when the term
+    // matches only one side of an edge.
+    for (const edge of graph.edges) {
+        if (selectedIds.size >= maxNodes)
+            break;
+        const touchesSelection = selectedIds.has(edge.from) || selectedIds.has(edge.to);
+        if (!touchesSelection)
+            continue;
+        if (selectedIds.has(edge.from) && !selectedIds.has(edge.to) && nodeById.has(edge.to)) {
+            selectedIds.add(edge.to);
+        }
+        else if (selectedIds.has(edge.to) && !selectedIds.has(edge.from) && nodeById.has(edge.from)) {
+            selectedIds.add(edge.from);
+        }
+    }
+    const nodes = graph.nodes.filter((node) => selectedIds.has(node.id));
+    const remainingBudget = Math.max(0, budget - nodes.length * 20);
+    const maxEdges = Math.floor(remainingBudget / 10);
+    const edges = graph.edges
+        .filter((edge) => selectedIds.has(edge.from) && selectedIds.has(edge.to))
+        .slice(0, maxEdges);
+    return { nodes, edges };
+}
+async function fallbackGraphStatus(projectDir) {
+    const graph = readGraphFile(projectDir);
+    if (!graph)
+        return { exists: false, stale: false };
+    if (!graph.builtAt)
+        return { exists: true, stale: false };
+    const builtAtMs = Date.parse(graph.builtAt);
+    if (!Number.isFinite(builtAtMs))
+        return { exists: true, stale: false };
+    const ageHours = (Date.now() - builtAtMs) / (1000 * 60 * 60);
+    return { exists: true, stale: ageHours > 24, ageHours };
+}
+function isGraphApi(mod) {
+    if (!mod || typeof mod !== "object")
+        return false;
+    const candidate = mod;
+    return typeof candidate.graphQuery === "function" && typeof candidate.graphStatus === "function";
+}
+async function resolveGraphApi() {
+    if (resolvedGraphApi && cachedGraphApi)
+        return cachedGraphApi;
+    resolvedGraphApi = true;
+    try {
+        const imported = await import("@gsd-build/mcp-server");
+        if (isGraphApi(imported)) {
+            cachedGraphApi = imported;
+            return cachedGraphApi;
+        }
+        logWarning("prompt", "@gsd-build/mcp-server graph exports unavailable; using local graph fallback");
+    }
+    catch {
+        // Fall back to local reader implementation.
+    }
+    cachedGraphApi = {
+        graphQuery: fallbackGraphQuery,
+        graphStatus: fallbackGraphStatus,
+    };
+    return cachedGraphApi;
+}
+/**
+ * Query the knowledge graph for nodes related to the given term and format
+ * the result as an inlined context block.
+ *
+ * Returns null when:
+ * - @gsd-build/mcp-server fails to import
+ * - graph.json does not exist (graphQuery already handles this gracefully)
+ * - query returns zero nodes
+ *
+ * Annotates the block header when the graph is stale (> 24 hours old).
+ */
+export async function inlineGraphSubgraph(projectDir, term, opts) {
+    if (!term || !term.trim())
+        return null;
+    try {
+        const graphApi = await resolveGraphApi();
+        const result = await graphApi.graphQuery(projectDir, term, opts.budget);
+        if (result.nodes.length === 0)
+            return null;
+        // Check staleness for annotation
+        let staleAnnotation = "";
+        try {
+            const status = await graphApi.graphStatus(projectDir);
+            if (status.exists && status.stale && status.ageHours !== undefined) {
+                const hours = Math.round(status.ageHours);
+                staleAnnotation = `\n> ⚠ Graph last built ${hours}h ago — context may be outdated`;
+            }
+        }
+        catch {
+            // Non-fatal — skip annotation on error
+        }
+        // Format nodes as a compact list
+        const nodeLines = result.nodes.map((node) => {
+            const desc = node.description ? ` — ${node.description}` : "";
+            return `- **${node.label}** (\`${node.type}\`, ${node.confidence})${desc}`;
+        });
+        // Format edges as relations (only if present)
+        const edgeLines = result.edges.length > 0
+            ? result.edges.map((edge) => `- \`${edge.from}\` →[${edge.type}]→ \`${edge.to}\``)
+            : [];
+        const sections = [
+            `### Knowledge Graph Context (term: "${term}")`,
+            `Source: \`.gsd/graphs/graph.json\``,
+            staleAnnotation,
+            "",
+            `**Nodes (${result.nodes.length}):**`,
+            ...nodeLines,
+        ];
+        if (edgeLines.length > 0) {
+            sections.push("", `**Relations (${result.edges.length}):**`, ...edgeLines);
+        }
+        return sections.filter((l) => l !== undefined).join("\n");
+    }
+    catch (err) {
+        logWarning("prompt", `inlineGraphSubgraph failed (non-fatal): ${err instanceof Error ? err.message : String(err)}`);
+        return null;
+    }
+}