gsd-pi 2.76.0 → 2.77.0-dev.2daa994b6

package/dist/resources/extensions/gsd/hook-emitter.js

@@ -0,0 +1,108 @@
+// GSD Extension — Layer 2 Event Emitter Bridge
+//
+// Holds a module-scoped reference to the ExtensionAPI so deeply-nested code
+// (auto-loop, git-service callers, verification, budget) can emit Layer 2
+// events without having to thread `pi` through every function signature.
+//
+// Set once from `registerGsdExtension`. All emitters are best-effort — a
+// missing `pi` (e.g. in standalone unit tests) silently becomes a no-op.
+let _pi;
+export function setHookEmitter(pi) {
+    _pi = pi;
+}
+export function clearHookEmitter() {
+    _pi = undefined;
+}
+// ─── Notification ──────────────────────────────────────────────────────────
+export async function emitNotification(kind, message, details) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "notification", kind, message, details });
+}
+// ─── Git Lifecycle ─────────────────────────────────────────────────────────
+export async function emitBeforeCommit(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "before_commit",
+        ...args,
+    }));
+}
+export async function emitCommit(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "commit", ...args });
+}
+export async function emitBeforePush(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "before_push",
+        ...args,
+    }));
+}
+export async function emitPush(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "push", ...args });
+}
+export async function emitBeforePr(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "before_pr",
+        ...args,
+    }));
+}
+export async function emitPrOpened(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "pr_opened", ...args });
+}
+// ─── Verification ──────────────────────────────────────────────────────────
+export async function emitBeforeVerify(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "before_verify",
+        ...args,
+    }));
+}
+export async function emitVerifyResult(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "verify_result", ...args });
+}
+// ─── Budget ────────────────────────────────────────────────────────────────
+export async function emitBudgetThreshold(args) {
+    if (!_pi)
+        return undefined;
+    return (await _pi.emitExtensionEvent({
+        type: "budget_threshold",
+        fraction: args.fraction,
+        spent: args.spent,
+        limit: args.limit,
+        currency: "USD",
+    }));
+}
+// ─── Orchestrator Boundaries ───────────────────────────────────────────────
+export async function emitMilestoneStart(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "milestone_start", ...args });
+}
+export async function emitMilestoneEnd(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "milestone_end", ...args });
+}
+export async function emitUnitStart(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "unit_start", ...args });
+}
+export async function emitUnitEnd(args) {
+    if (!_pi)
+        return;
+    await _pi.emitExtensionEvent({ type: "unit_end", ...args });
+}

package/dist/resources/extensions/gsd/init-wizard.js

@@ -8,7 +8,7 @@
 import { existsSync, mkdirSync, writeFileSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 import { showNextAction } from "../shared/tui.js";
-import { nativeInit } from "./native-git-bridge.js";
+import { nativeInit, nativeAddAll, nativeCommit } from "./native-git-bridge.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
 import { gsdRoot } from "./paths.js";
 import { assertSafeDirectory } from "./validate-directory.js";
@@ -40,6 +40,7 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
         ctx.ui.notify(`Project detected:\n${detectionSummary.join("\n")}`, "info");
     }
     // ── Step 2: Git setup ──────────────────────────────────────────────────────
+    let didInitGit = false;
     if (!signals.isGitRepo) {
         const gitChoice = await showNextAction(ctx, {
             title: "GSD — Project Setup",
@@ -54,6 +55,7 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
             return { completed: false, bootstrapped: false };
         if (gitChoice === "init_git") {
             nativeInit(basePath, prefs.mainBranch);
+            didInitGit = true;
         }
     }
     else {
@@ -244,6 +246,18 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     // Ensure .gitignore
     ensureGitignore(basePath);
     untrackRuntimeFiles(basePath);
+    // Create initial commit so git log and git worktree work immediately (#4530).
+    // Without this, the branch is "unborn" (zero commits) and downstream operations
+    // like `git log` and `git worktree add` fail.
+    if (didInitGit) {
+        try {
+            nativeAddAll(basePath);
+            nativeCommit(basePath, "chore: init project");
+        }
+        catch {
+            // Non-fatal — user can commit manually; don't block project init
+        }
+    }
     // Auto-generate codebase map for instant agent orientation
     try {
         const result = generateCodebaseMap(basePath);

package/dist/resources/extensions/gsd/journal.js

@@ -11,8 +11,10 @@
  * - queryJournal() enables programmatic filtering by flowId, eventType, unitId, time range
  * - Silent failure: journal writes never throw — absence of events is the failure signal
  */
-import { appendFileSync, mkdirSync, readdirSync, readFileSync } from "node:fs";
+import { appendFileSync, closeSync, existsSync, mkdirSync, openSync, readdirSync, readFileSync, } from "node:fs";
 import { join } from "node:path";
+import { isStaleWrite } from "./auto/turn-epoch.js";
+import { withFileLockSync } from "./file-lock.js";
 import { gsdRoot } from "./paths.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
 import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
@@ -26,12 +28,25 @@ import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
  * Never throws — all errors are silently caught.
  */
 export function emitJournalEvent(basePath, entry) {
+    // Drop writes from a turn superseded by timeout recovery / cancellation.
+    // See auto/turn-epoch.ts for the full rationale.
+    if (isStaleWrite("journal"))
+        return;
     try {
         const journalDir = join(gsdRoot(basePath), "journal");
         mkdirSync(journalDir, { recursive: true });
         const dateStr = entry.ts.slice(0, 10);
         const filePath = join(journalDir, `${dateStr}.jsonl`);
-        appendFileSync(filePath, JSON.stringify(entry) + "\n");
+        // Ensure file exists so proper-lockfile can acquire a lock against it.
+        if (!existsSync(filePath))
+            closeSync(openSync(filePath, "a"));
+        // onLocked: "skip" — journal writes are best-effort. POSIX O_APPEND
+        // atomicity still protects small entries; the lock mainly serializes
+        // larger writes and gives cross-process exclusivity on platforms where
+        // O_APPEND semantics are weaker (Windows).
+        withFileLockSync(filePath, () => {
+            appendFileSync(filePath, JSON.stringify(entry) + "\n");
+        }, { onLocked: "skip" });
     }
     catch {
         // Silent failure — journal must never break auto-mode

package/dist/resources/extensions/gsd/key-manager.js

@@ -12,6 +12,12 @@ import { getErrorMessage } from "./error-utils.js";
 export const PROVIDER_REGISTRY = [
     // LLM Providers
     { id: "anthropic", label: "Anthropic (Claude)", category: "llm", envVar: "ANTHROPIC_API_KEY", prefixes: ["sk-ant-"], hasOAuth: true, dashboardUrl: "console.anthropic.com" },
+    // Claude Code CLI: routes through the local `claude` binary — no API key,
+    // authentication is handled by the CLI's own OAuth flow.
+    // Referenced by doctor-providers.ts, auto-model-selection.ts, and others;
+    // must be in the canonical registry so all consumers see the same catalog.
+    // See: https://github.com/gsd-build/gsd-2/issues/4541
+    { id: "claude-code", label: "Claude Code CLI", category: "llm", hasOAuth: true },
     { id: "openai", label: "OpenAI", category: "llm", envVar: "OPENAI_API_KEY", prefixes: ["sk-"], dashboardUrl: "platform.openai.com/api-keys" },
     { id: "github-copilot", label: "GitHub Copilot", category: "llm", envVar: "GITHUB_TOKEN", hasOAuth: true },
     { id: "openai-codex", label: "ChatGPT Plus/Pro (Codex)", category: "llm", hasOAuth: true },
@@ -22,6 +28,8 @@ export const PROVIDER_REGISTRY = [
     { id: "xai", label: "xAI (Grok)", category: "llm", envVar: "XAI_API_KEY", dashboardUrl: "console.x.ai" },
     { id: "openrouter", label: "OpenRouter", category: "llm", envVar: "OPENROUTER_API_KEY", dashboardUrl: "openrouter.ai/keys" },
     { id: "mistral", label: "Mistral", category: "llm", envVar: "MISTRAL_API_KEY", dashboardUrl: "console.mistral.ai" },
+    { id: "minimax", label: "MiniMax", category: "llm", envVar: "MINIMAX_API_KEY", dashboardUrl: "platform.minimax.io" },
+    { id: "minimax-cn", label: "MiniMax CN", category: "llm", envVar: "MINIMAX_CN_API_KEY", dashboardUrl: "platform.minimax.io" },
     { id: "ollama-cloud", label: "Ollama Cloud", category: "llm", envVar: "OLLAMA_API_KEY" },
     { id: "custom-openai", label: "Custom (OpenAI-compat)", category: "llm", envVar: "CUSTOM_OPENAI_API_KEY" },
     { id: "cerebras", label: "Cerebras", category: "llm", envVar: "CEREBRAS_API_KEY" },
@@ -387,6 +395,26 @@ const TEST_ENDPOINTS = {
         url: "https://api.mistral.ai/v1/models",
         headers: (key) => ({ Authorization: `Bearer ${key}` }),
     },
+    minimax: {
+        url: "https://api.minimax.io/anthropic/v1/messages",
+        method: "POST",
+        headers: (key) => ({
+            "x-api-key": key,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        }),
+        body: JSON.stringify({ model: "MiniMax-M2.7", max_tokens: 1, messages: [{ role: "user", content: "hi" }] }),
+    },
+    "minimax-cn": {
+        url: "https://api.minimaxi.com/anthropic/v1/messages",
+        method: "POST",
+        headers: (key) => ({
+            "x-api-key": key,
+            "anthropic-version": "2023-06-01",
+            "content-type": "application/json",
+        }),
+        body: JSON.stringify({ model: "MiniMax-M2.7", max_tokens: 1, messages: [{ role: "user", content: "hi" }] }),
+    },
     openrouter: {
         url: "https://openrouter.ai/api/v1/models",
         headers: (key) => ({ Authorization: `Bearer ${key}` }),

package/dist/resources/extensions/gsd/memory-backfill.js

@@ -0,0 +1,126 @@
+// GSD2 — Decisions -> memories backfill (ADR-013 step 5)
+//
+// Idempotent one-shot migration that copies every active decisions row into
+// the memories table with category="architecture" and a structured_fields
+// payload preserving the original gsd_save_decision schema (when_context,
+// scope, decision, choice, rationale, made_by, revisable, sourceDecisionId).
+//
+// The backfill exists so the cutover in ADR-013 step 6 can drop the
+// decisions table without losing schema fidelity. Idempotency is enforced
+// by tagging each backfilled memory with structured_fields.sourceDecisionId
+// and skipping any decision whose ID already appears in the memories table.
+//
+// Triggered opportunistically by buildBeforeAgentStartResult so the cost
+// only ever fires once per project. Costs O(N) inserts on first run where
+// N is the active-decisions count; subsequent runs are an O(N) lookup that
+// finds existing markers and exits.
+import { isDbAvailable, _getAdapter } from "./gsd-db.js";
+import { createMemory } from "./memory-store.js";
+import { logWarning } from "./workflow-logger.js";
+/**
+ * Backfill active decisions rows into the memories table.
+ *
+ * - Idempotent (per-row): every row written carries
+ *   `structured_fields.sourceDecisionId = "<decisionId>"`. Each candidate
+ *   decision is checked individually; only decisions whose id is already
+ *   present in the memory store are skipped. A user-authored memory with
+ *   their own `sourceDecisionId` does NOT abort the backfill.
+ * - Best-effort: never throws. Logs and returns 0 on failure so a broken
+ *   backfill cannot block agent startup.
+ * - Active-only: skips rows where `superseded_by IS NOT NULL`. Superseded
+ *   decisions are historical record; the memory store is for active
+ *   knowledge.
+ *
+ * Returns the number of memories written (0 when already backfilled or
+ * when the DB has no decisions). Callers can log the result or surface it
+ * to the user.
+ */
+export function backfillDecisionsToMemories() {
+    if (!isDbAvailable())
+        return 0;
+    const adapter = _getAdapter();
+    if (!adapter)
+        return 0;
+    try {
+        const decisions = adapter
+            .prepare("SELECT id, when_context, scope, decision, choice, rationale, made_by, revisable, superseded_by FROM decisions WHERE superseded_by IS NULL")
+            .all();
+        if (decisions.length === 0)
+            return 0;
+        // Per-row idempotency: each memory backfilled from a decision carries
+        // structured_fields.sourceDecisionId="<decisionId>". Skipping is decided
+        // per row by matching that exact id, NOT by a global sentinel — a global
+        // sentinel would silently abort the backfill if a user manually called
+        // capture_thought with their own structuredFields.sourceDecisionId.
+        const checkExisting = adapter.prepare("SELECT 1 FROM memories WHERE structured_fields LIKE :pattern LIMIT 1");
+        let written = 0;
+        for (const raw of decisions) {
+            const row = {
+                id: String(raw["id"] ?? ""),
+                when_context: String(raw["when_context"] ?? ""),
+                scope: String(raw["scope"] ?? ""),
+                decision: String(raw["decision"] ?? ""),
+                choice: String(raw["choice"] ?? ""),
+                rationale: String(raw["rationale"] ?? ""),
+                made_by: String(raw["made_by"] ?? "agent"),
+                revisable: String(raw["revisable"] ?? ""),
+                superseded_by: raw["superseded_by"] == null ? null : String(raw["superseded_by"]),
+            };
+            if (!row.id)
+                continue;
+            // Pattern is anchored to the JSON-stringified shape and the exact
+            // decision id to avoid prefix collisions (e.g. "D1" vs "D10").
+            if (checkExisting.get({ ":pattern": `%"sourceDecisionId":"${row.id}"%` }))
+                continue;
+            const content = synthesizeContent(row);
+            const id = createMemory({
+                category: "architecture",
+                content,
+                scope: row.scope || "project",
+                confidence: 0.85,
+                structuredFields: {
+                    sourceDecisionId: row.id,
+                    when_context: row.when_context,
+                    scope: row.scope,
+                    decision: row.decision,
+                    choice: row.choice,
+                    rationale: row.rationale,
+                    made_by: row.made_by,
+                    revisable: row.revisable,
+                },
+            });
+            if (id)
+                written += 1;
+        }
+        return written;
+    }
+    catch (e) {
+        logWarning("memory-backfill", `decisions->memories backfill failed: ${e.message}`);
+        return 0;
+    }
+}
+/**
+ * Combine the decision's structured fields into a 1-3 sentence content
+ * string suitable for keyword retrieval and human review.
+ *
+ * Format: "<decision> Chose: <choice>. Rationale: <rationale>."
+ * Truncates each field to keep the synthesized line under ~600 chars so
+ * memory_query rendering stays readable.
+ */
+function synthesizeContent(row) {
+    const trim = (value, max) => {
+        const cleaned = value.replace(/\s+/g, " ").trim();
+        return cleaned.length > max ? cleaned.slice(0, max - 1) + "\u2026" : cleaned;
+    };
+    const parts = [];
+    const decision = trim(row.decision, 240);
+    const choice = trim(row.choice, 200);
+    const rationale = trim(row.rationale, 200);
+    if (decision)
+        parts.push(decision);
+    if (choice)
+        parts.push(`Chose: ${choice}.`);
+    if (rationale)
+        parts.push(`Rationale: ${rationale}.`);
+    return parts.join(" ");
+}

package/dist/resources/extensions/gsd/memory-extractor.js

@@ -62,7 +62,9 @@ export function buildMemoryLLMCall(ctx) {
         // which returns undefined for OAuth users (Claude Max / Claude Pro).
         // See: https://github.com/gsd-build/gsd-2/issues/2959
         const resolvedKeyPromise = ctx.modelRegistry.getApiKey(selectedModel).catch(() => undefined);
-        return async (system, user) => {
+        // Expose on the returned fn so tests can await resolution deterministically
+        // (avoids arbitrary setTimeout polling for an internal microtask).
+        const llmCall = async (system, user) => {
             const { completeSimple } = await import('@gsd/pi-ai');
             const resolvedApiKey = await resolvedKeyPromise;
             const result = await completeSimple(selectedModel, {
@@ -79,6 +81,10 @@ export function buildMemoryLLMCall(ctx) {
                 .map(c => c.text);
             return textParts.join('');
         };
+        // Attach the in-flight API-key resolution so tests (and callers) can
+        // `await llmCall.apiKeyReady` rather than relying on setTimeout polling.
+        llmCall.apiKeyReady = resolvedKeyPromise;
+        return llmCall;
     }
     catch {
         return null;

package/dist/resources/extensions/gsd/memory-store.js

@@ -29,8 +29,22 @@ function rowToMemory(row) {
         hit_count: row['hit_count'],
         scope: row['scope'] ?? 'project',
         tags: parseTags(row['tags']),
+        structured_fields: parseStructuredFields(row['structured_fields']),
     };
 }
+function parseStructuredFields(raw) {
+    if (typeof raw !== 'string' || raw.length === 0)
+        return null;
+    try {
+        const parsed = JSON.parse(raw);
+        return parsed && typeof parsed === 'object' && !Array.isArray(parsed)
+            ? parsed
+            : null;
+    }
+    catch {
+        return null;
+    }
+}
 function parseTags(raw) {
     if (typeof raw !== 'string' || raw.length === 0)
         return [];
@@ -376,6 +390,7 @@ export function createMemory(fields) {
             updatedAt: now,
             scope: fields.scope ?? 'project',
             tags: fields.tags ?? [],
+            structuredFields: fields.structuredFields ?? null,
         });
         // Derive the real ID from the assigned seq (SELECT is still fine via adapter)
         const row = adapter.prepare('SELECT seq FROM memories WHERE id = :id').get({ ':id': placeholder });
@@ -553,6 +568,10 @@ export function applyMemoryActions(actions, unitType, unitId) {
                             source_unit_id: unitId,
                             scope: action.scope,
                             tags: action.tags,
+                            // ADR-013: forward structured payload through the action layer so
+                            // bulk applyMemoryActions callers (extraction, ingestion) don't
+                            // silently drop it.
+                            structuredFields: action.structuredFields ?? null,
                         });
                         break;
                     case 'UPDATE':

package/dist/resources/extensions/gsd/milestone-actions.js

@@ -18,6 +18,18 @@ import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
 import { deleteMilestone, getMilestone, isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
 import { removeWorktree } from "./worktree-manager.js";
 import { logWarning } from "./workflow-logger.js";
+import { isAutoActive } from "./auto.js";
+/**
+ * Writer-side assert for mutations that race with auto-mode's squash merge (#4704).
+ * Auto-mode is confirmed not to call parkMilestone/discardMilestone/unparkMilestone
+ * internally — these throws only surface invariant violations from new or forgotten
+ * call sites, which is the correct failure mode to catch loudly.
+ */
+function assertNotAutoActive(action) {
+    if (isAutoActive()) {
+        throw new Error(`${action} cannot run while auto-mode is active. Stop auto-mode first with /gsd stop.`);
+    }
+}
 // ─── Park ──────────────────────────────────────────────────────────────────
 /**
  * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
@@ -25,6 +37,7 @@ import { logWarning } from "./workflow-logger.js";
  * Returns true if successfully parked, false if milestone not found or already parked.
  */
 export function parkMilestone(basePath, milestoneId, reason) {
+    assertNotAutoActive("park milestone");
     const mDir = resolveMilestonePath(basePath, milestoneId);
     if (!mDir || !existsSync(mDir))
         return false;
@@ -65,6 +78,7 @@ export function parkMilestone(basePath, milestoneId, reason) {
  * Returns true if successfully unparked, false if milestone not found or not parked.
  */
 export function unparkMilestone(basePath, milestoneId) {
+    assertNotAutoActive("unpark milestone");
     const mDir = resolveMilestonePath(basePath, milestoneId);
     if (!mDir || !existsSync(mDir))
         return false;
@@ -97,6 +111,7 @@ export function unparkMilestone(basePath, milestoneId) {
  * Returns true if successfully discarded, false if milestone not found.
  */
 export function discardMilestone(basePath, milestoneId) {
+    assertNotAutoActive("discard milestone");
     const mDir = resolveMilestonePath(basePath, milestoneId);
     if (!mDir || !existsSync(mDir))
         return false;