gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.96d4bb599

package/dist/resources/extensions/gsd/health-widget-core.js

@@ -43,47 +43,75 @@ function truncateMessage(msg, maxLen) {
 }
 /**
  * Build compact health lines for the widget.
- * Returns a string array suitable for setWidget().
+ * When `width` is provided, system + budget render left and last-commit
+ * right-aligned. Without width, all parts are joined inline (RPC fallback).
  */
-export function buildHealthLines(data) {
+export function buildHealthLines(data, width) {
     if (data.projectState === "none") {
         return ["  GSD  No project loaded — run /gsd to start"];
     }
     if (data.projectState === "initialized") {
         return ["  GSD  Project initialized — run /gsd to continue setup"];
     }
-    const parts = [];
+    const leftParts = [];
     const totalIssues = data.environmentErrorCount + data.environmentWarningCount + (data.providerIssue ? 1 : 0);
     if (totalIssues === 0) {
-        parts.push("● System OK");
+        leftParts.push("● System OK");
     }
     else if (data.environmentErrorCount > 0 || data.providerIssue?.includes("✗")) {
-        parts.push(`✗ ${totalIssues} issue${totalIssues > 1 ? "s" : ""}`);
+        leftParts.push(`✗ ${totalIssues} issue${totalIssues > 1 ? "s" : ""}`);
     }
     else {
-        parts.push(`⚠ ${totalIssues} warning${totalIssues > 1 ? "s" : ""}`);
+        leftParts.push(`⚠ ${totalIssues} warning${totalIssues > 1 ? "s" : ""}`);
     }
     if (data.budgetCeiling !== undefined && data.budgetCeiling > 0) {
         const pct = Math.min(100, (data.budgetSpent / data.budgetCeiling) * 100);
-        parts.push(`Budget: ${formatCost(data.budgetSpent)}/${formatCost(data.budgetCeiling)} (${pct.toFixed(0)}%)`);
+        leftParts.push(`Budget: ${formatCost(data.budgetSpent)}/${formatCost(data.budgetCeiling)} (${pct.toFixed(0)}%)`);
     }
     else if (data.budgetSpent > 0) {
-        parts.push(`Spent: ${formatCost(data.budgetSpent)}`);
+        leftParts.push(`Spent: ${formatCost(data.budgetSpent)}`);
     }
     if (data.providerIssue) {
-        parts.push(data.providerIssue);
+        leftParts.push(data.providerIssue);
     }
     if (data.environmentErrorCount > 0) {
-        parts.push(`Env: ${data.environmentErrorCount} error${data.environmentErrorCount > 1 ? "s" : ""}`);
+        leftParts.push(`Env: ${data.environmentErrorCount} error${data.environmentErrorCount > 1 ? "s" : ""}`);
     }
     else if (data.environmentWarningCount > 0) {
-        parts.push(`Env: ${data.environmentWarningCount} warning${data.environmentWarningCount > 1 ? "s" : ""}`);
+        leftParts.push(`Env: ${data.environmentWarningCount} warning${data.environmentWarningCount > 1 ? "s" : ""}`);
     }
-    // Always-on last commit display — shows relative time + truncated message
+    // Last commit goes on the right-hand side when width is known.
+    let rightText = "";
     if (data.lastCommitEpoch !== null && data.lastCommitEpoch > 0) {
         const relTime = formatRelativeTime(data.lastCommitEpoch);
         const msg = data.lastCommitMessage ? ` — ${truncateMessage(data.lastCommitMessage, 50)}` : "";
-        parts.push(`Last commit: ${relTime}${msg}`);
+        rightText = `Last commit: ${relTime}${msg}`;
     }
-    return [`  ${parts.join("  │  ")}`];
+    const leftText = leftParts.join("  │  ");
+    if (width === undefined) {
+        const inline = rightText ? `${leftText}  │  ${rightText}` : leftText;
+        return [`  ${inline}`];
+    }
+    const prefix = "  ";
+    const innerWidth = Math.max(0, width - prefix.length);
+    const leftVis = leftText.length;
+    const rightVis = rightText.length;
+    if (!rightText)
+        return [`${prefix}${truncateMessage(leftText, innerWidth)}`];
+    const MIN_GAP = 2;
+    if (leftVis + MIN_GAP + rightVis > innerWidth) {
+        // Preserve the left (status + budget) and truncate the right side
+        // (last commit) with an ellipsis so the combined line never exceeds
+        // innerWidth. If even the left alone overflows, clamp it too.
+        const leftRoom = Math.max(1, Math.min(leftVis, innerWidth - MIN_GAP - 1));
+        const clampedLeft = truncateMessage(leftText, leftRoom);
+        const rightRoom = Math.max(0, innerWidth - clampedLeft.length - MIN_GAP);
+        const clampedRight = rightRoom > 0 ? truncateMessage(rightText, rightRoom) : "";
+        if (!clampedRight)
+            return [`${prefix}${clampedLeft}`];
+        const pad = " ".repeat(Math.max(MIN_GAP, innerWidth - clampedLeft.length - clampedRight.length));
+        return [`${prefix}${clampedLeft}${pad}${clampedRight}`];
+    }
+    const padding = " ".repeat(innerWidth - leftVis - rightVis);
+    return [`${prefix}${leftText}${padding}${rightText}`];
 }

package/dist/resources/extensions/gsd/health-widget.js

@@ -111,13 +111,16 @@ export function initHealthWidget(ctx) {
         const refreshTimer = setInterval(() => {
             void refresh();
         }, REFRESH_INTERVAL_MS);
+        let cachedWidth;
         return {
-            render(_width) {
-                if (!cachedLines)
-                    cachedLines = buildHealthLines(data);
+            render(width) {
+                if (!cachedLines || cachedWidth !== width) {
+                    cachedLines = buildHealthLines(data, width);
+                    cachedWidth = width;
+                }
                 return cachedLines;
             },
-            invalidate() { cachedLines = undefined; },
+            invalidate() { cachedLines = undefined; cachedWidth = undefined; },
             dispose() {
                 clearInterval(refreshTimer);
             },

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

@@ -14,6 +14,7 @@ import { gsdRoot } from "./paths.js";
 import { assertSafeDirectory } from "./validate-directory.js";
 import { runSkillInstallStep } from "./skill-catalog.js";
 import { generateCodebaseMap, writeCodebaseMap } from "./codebase-generator.js";
+import { handlePrefsWizard, writePreferencesFile } from "./commands-prefs-wizard.js";
 // ─── Defaults ───────────────────────────────────────────────────────────────────
 const DEFAULT_PREFS = {
     mode: "solo",
@@ -185,8 +186,51 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     catch {
         // Non-fatal — skill installation failure should never block project init
     }
-    // ── Step 9: Bootstrap .gsd/ ────────────────────────────────────────────────
-    bootstrapGsdDirectory(basePath, prefs, signals);
+    // ── Step 9: Optional full-prefs review ─────────────────────────────────────
+    // Ask BEFORE bootstrapping so a defer (`not_yet`) leaves the project untouched.
+    // Once the user commits, we bootstrap and route preferences through the unified
+    // writer (commands-prefs-wizard.writePreferencesFile) so init and the prefs
+    // wizard share one serializer. The "Open full wizard" branch surfaces every
+    // configurable preference, prefilled with the init answers.
+    const reviewChoice = await showNextAction(ctx, {
+        title: "GSD — Review All Preferences (Optional)",
+        summary: [
+            "Open the full preferences wizard now? It includes models, timeouts,",
+            "budget, notifications, and skills — all pre-filled with your answers.",
+            "",
+            "Skip if you just want sensible defaults; you can always run /gsd prefs project later.",
+        ],
+        actions: [
+            { id: "skip", label: "Skip — use defaults", description: "Save preferences and continue", recommended: true },
+            { id: "review", label: "Open full wizard", description: "Tweak any category before saving" },
+        ],
+        notYetMessage: "Run /gsd init when ready.",
+    });
+    if (reviewChoice === "not_yet") {
+        // User deferred — don't create .gsd/ or persist preferences. Pre-step state
+        // (e.g. git init from Step 2) remains as-is, matching prior step semantics.
+        return { completed: false, bootstrapped: false };
+    }
+    // ── Step 10: Bootstrap .gsd/ + write preferences ───────────────────────────
+    bootstrapGsdDirectoryStructure(basePath, signals);
+    const prefillPrefs = mapInitPrefsToWizardShape(prefs);
+    // Always derive the preferences path from basePath so init writing the
+    // structure to one location and preferences to another (cwd-derived) is
+    // impossible — see #4457 codex review.
+    const projectPrefsPath = join(gsdRoot(basePath), "PREFERENCES.md");
+    if (reviewChoice === "review") {
+        // Wizard writes via writePreferencesFile internally; pass pathOverride so it
+        // targets basePath rather than cwd.
+        await handlePrefsWizard(ctx, "project", prefillPrefs, { pathOverride: projectPrefsPath });
+    }
+    else {
+        // Direct path: write the init-collected prefs through the unified writer.
+        await writePreferencesFile(projectPrefsPath, prefillPrefs, ctx, {
+            scope: "project",
+            defaultBody: buildInitPreferencesBody(),
+            notifyOnSave: false,
+        });
+    }
     // Initialize SQLite database so GSD starts in full-capability mode (#3880).
     // Without this, isDbAvailable() returns false and GSD enters degraded
     // markdown-only mode until a tool handler happens to call ensureDbOpen().
@@ -372,67 +416,64 @@ async function customizeAdvancedPrefs(ctx, prefs) {
     prefs.autoPush = pushChoice !== "no";
 }
 // ─── Bootstrap ──────────────────────────────────────────────────────────────────
-function bootstrapGsdDirectory(basePath, prefs, signals) {
+/**
+ * Create .gsd/ directory structure and seed CONTEXT.md.
+ *
+ * Preferences are written separately by the caller via the unified
+ * writePreferencesFile helper so init and the prefs wizard share one path.
+ */
+function bootstrapGsdDirectoryStructure(basePath, signals) {
     // Final safety check before writing any files
     assertSafeDirectory(basePath);
     const gsd = gsdRoot(basePath);
     mkdirSync(join(gsd, "milestones"), { recursive: true });
     mkdirSync(join(gsd, "runtime"), { recursive: true });
-    // Write PREFERENCES.md from wizard answers
-    const preferencesContent = buildPreferencesFile(prefs);
-    writeFileSync(join(gsd, "PREFERENCES.md"), preferencesContent, "utf-8");
     // Seed CONTEXT.md with detected project signals
     const contextContent = buildContextSeed(signals);
     if (contextContent) {
         writeFileSync(join(gsd, "CONTEXT.md"), contextContent, "utf-8");
     }
 }
-function buildPreferencesFile(prefs) {
-    const lines = ["---"];
-    lines.push("version: 1");
-    lines.push(`mode: ${prefs.mode}`);
-    // Git preferences
-    lines.push("git:");
-    lines.push(`  isolation: ${prefs.gitIsolation}`);
-    lines.push(`  main_branch: ${prefs.mainBranch}`);
-    lines.push(`  auto_push: ${prefs.autoPush}`);
-    // Verification commands
+/**
+ * Map init wizard's typed ProjectPreferences to the prefs-wizard's
+ * Record<string, unknown> shape, matching the keys serializePreferencesToFrontmatter
+ * expects (mode, git.{isolation,main_branch,auto_push}, verification_commands, etc.).
+ *
+ * Exported for testing; init-wizard uses it inline.
+ */
+export function mapInitPrefsToWizardShape(prefs) {
+    const out = {
+        mode: prefs.mode,
+        git: {
+            isolation: prefs.gitIsolation,
+            main_branch: prefs.mainBranch,
+            auto_push: prefs.autoPush,
+        },
+    };
     if (prefs.verificationCommands.length > 0) {
-        lines.push("verification_commands:");
-        for (const cmd of prefs.verificationCommands) {
-            lines.push(`  - "${cmd}"`);
-        }
+        out.verification_commands = prefs.verificationCommands;
     }
-    // Custom instructions
     if (prefs.customInstructions.length > 0) {
-        lines.push("custom_instructions:");
-        for (const inst of prefs.customInstructions) {
-            lines.push(`  - "${inst.replace(/"/g, '\\"')}"`);
-        }
+        out.custom_instructions = prefs.customInstructions;
     }
-    // Token profile (only if non-default)
     if (prefs.tokenProfile !== "balanced") {
-        lines.push(`token_profile: ${prefs.tokenProfile}`);
+        out.token_profile = prefs.tokenProfile;
     }
-    // Phase skips
     if (prefs.skipResearch) {
-        lines.push("phases:");
-        lines.push("  skip_research: true");
-    }
-    // Defaults for wizard-generated files
-    lines.push("always_use_skills: []");
-    lines.push("prefer_skills: []");
-    lines.push("avoid_skills: []");
-    lines.push("skill_rules: []");
-    lines.push("---");
-    lines.push("");
-    lines.push("# GSD Project Preferences");
-    lines.push("");
-    lines.push("Generated by `/gsd init`. Edit directly or use `/gsd prefs project` to modify.");
-    lines.push("");
-    lines.push("See `~/.gsd/agent/extensions/gsd/docs/preferences-reference.md` for full field documentation.");
-    lines.push("");
-    return lines.join("\n");
+        out.phases = { skip_research: true };
+    }
+    return out;
+}
+function buildInitPreferencesBody() {
+    return [
+        "",
+        "# GSD Project Preferences",
+        "",
+        "Generated by `/gsd init`. Edit directly or use `/gsd prefs project` to modify.",
+        "",
+        "See `~/.gsd/agent/extensions/gsd/docs/preferences-reference.md` for full field documentation.",
+        "",
+    ].join("\n");
 }
 function buildContextSeed(signals) {
     const lines = [];

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -115,7 +115,7 @@ function renderRoadmapMarkdown(milestone, slices) {
     lines.push("## Slices");
     lines.push("");
     for (const slice of slices) {
-        const done = slice.status === "complete" ? "x" : " ";
+        const done = isClosedStatus(slice.status) ? "x" : " ";
         const depends = `[${(slice.depends ?? []).join(",")}]`;
         lines.push(`- [${done}] **${slice.id}: ${slice.title}** \`risk:${slice.risk}\` \`depends:${depends}\``);
         lines.push(`  > After this: ${slice.demo}`);
@@ -386,7 +386,7 @@ export async function renderRoadmapCheckboxes(basePath, milestoneId) {
     // Apply checkbox patches for each slice
     let updated = content;
     for (const slice of slices) {
-        const isDone = slice.status === "complete";
+        const isDone = isClosedStatus(slice.status);
         const sid = slice.id;
         if (isDone) {
             // Set [x]: replace "- [ ] **S01:" with "- [x] **S01:"
@@ -631,20 +631,20 @@ export function detectStaleRenders(basePath) {
                 const content = readFileSync(roadmapPath, "utf-8");
                 const parsed = parseRoadmap(content);
                 for (const slice of slices) {
-                    const isCompleteInDb = slice.status === "complete";
+                    const isCompleteInDb = isClosedStatus(slice.status);
                     const roadmapSlice = parsed.slices.find((s) => s.id === slice.id);
                     if (!roadmapSlice)
                         continue;
                     if (isCompleteInDb && !roadmapSlice.done) {
                         stale.push({
                             path: roadmapPath,
-                            reason: `${slice.id} is complete in DB but unchecked in roadmap`,
+                            reason: `${slice.id} is closed in DB but unchecked in roadmap`,
                         });
                     }
                     else if (!isCompleteInDb && roadmapSlice.done) {
                         stale.push({
                             path: roadmapPath,
-                            reason: `${slice.id} is not complete in DB but checked in roadmap`,
+                            reason: `${slice.id} is not closed in DB but checked in roadmap`,
                         });
                     }
                 }

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

@@ -0,0 +1,219 @@
+// GSD Memory Embeddings — provider-agnostic embedding layer
+//
+// Same model-discovery pattern as buildMemoryLLMCall: prefers a dedicated
+// embedding-capable model when available, and returns null when none is
+// found (which is the common case — not every provider exposes embeddings).
+//
+// When embeddings are unavailable, all calls become no-ops and
+// queryMemoriesRanked falls back to keyword-only scoring.
+import { _getAdapter, isDbAvailable, upsertMemoryEmbedding, deleteMemoryEmbedding } from "./gsd-db.js";
+import { logWarning } from "./workflow-logger.js";
+// ─── Model selection ────────────────────────────────────────────────────────
+const EMBEDDING_ID_HINTS = [
+    "embed",
+    "embedding",
+    "voyage",
+    "text-embedding",
+    "nomic",
+    "jina-embed",
+    "bge",
+    "mxbai-embed",
+];
+/**
+ * Try to build an embedding function from the model registry. Returns null
+ * when no embedding-capable model is obvious from the registry metadata.
+ *
+ * NOTE: the Pi SDK doesn't yet expose a dedicated embeddings API for every
+ * provider. This implementation currently targets Anthropic / OpenAI-shaped
+ * SDKs: when the caller has direct API access via `ctx.modelRegistry`, they
+ * can wire this up by providing an `embedFn` override. We ship the hint-based
+ * detection here so future providers can plug in without touching callers.
+ */
+export function buildEmbeddingFn(ctx) {
+    try {
+        const available = ctx.modelRegistry?.getAvailable?.();
+        if (!available || available.length === 0)
+            return null;
+        const candidate = available.find((model) => {
+            const id = typeof model?.id === "string" ? model.id.toLowerCase() : "";
+            return EMBEDDING_ID_HINTS.some((hint) => id.includes(hint));
+        });
+        if (!candidate)
+            return null;
+        // We don't currently have a provider-neutral embedding call in Pi; the
+        // detection surface is in place so wiring can happen once Pi offers it.
+        return null;
+    }
+    catch (err) {
+        logWarning("memory-embeddings", `model discovery failed: ${err.message}`);
+        return null;
+    }
+}
+// ─── Vector (de)serialization ───────────────────────────────────────────────
+export function packFloat32(vec) {
+    return new Uint8Array(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+export function unpackFloat32(blob) {
+    if (!blob)
+        return null;
+    try {
+        if (blob instanceof Float32Array)
+            return blob;
+        let view;
+        if (blob instanceof Uint8Array) {
+            view = blob;
+        }
+        else if (blob instanceof ArrayBuffer) {
+            view = new Uint8Array(blob);
+        }
+        else if (blob.buffer && blob.byteLength != null) {
+            const buf = blob;
+            view = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+        }
+        else if (Array.isArray(blob)) {
+            return new Float32Array(blob);
+        }
+        else {
+            return null;
+        }
+        if (view.byteLength % 4 !== 0)
+            return null;
+        // Copy into an aligned buffer — BLOBs may arrive at odd byte offsets.
+        const aligned = new ArrayBuffer(view.byteLength);
+        new Uint8Array(aligned).set(view);
+        return new Float32Array(aligned);
+    }
+    catch {
+        return null;
+    }
+}
+// ─── Math ───────────────────────────────────────────────────────────────────
+export function cosineSimilarity(a, b) {
+    if (a.length === 0 || a.length !== b.length)
+        return 0;
+    let dot = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+        const x = a[i];
+        const y = b[i];
+        dot += x * y;
+        normA += x * x;
+        normB += y * y;
+    }
+    if (normA === 0 || normB === 0)
+        return 0;
+    return dot / (Math.sqrt(normA) * Math.sqrt(normB));
+}
+// ─── Read helpers ───────────────────────────────────────────────────────────
+export function getEmbeddingForMemory(memoryId) {
+    if (!isDbAvailable())
+        return null;
+    const adapter = _getAdapter();
+    if (!adapter)
+        return null;
+    try {
+        const row = adapter
+            .prepare("SELECT memory_id, model, dim, vector FROM memory_embeddings WHERE memory_id = :id")
+            .get({ ":id": memoryId });
+        if (!row)
+            return null;
+        const vector = unpackFloat32(row["vector"]);
+        if (!vector)
+            return null;
+        return {
+            memoryId: row["memory_id"],
+            model: row["model"],
+            dim: row["dim"],
+            vector,
+        };
+    }
+    catch {
+        return null;
+    }
+}
+export function loadAllEmbeddings() {
+    if (!isDbAvailable())
+        return [];
+    const adapter = _getAdapter();
+    if (!adapter)
+        return [];
+    try {
+        const rows = adapter
+            .prepare(`SELECT e.memory_id, e.model, e.dim, e.vector
+         FROM memory_embeddings e
+         JOIN memories m ON m.id = e.memory_id
+         WHERE m.superseded_by IS NULL`)
+            .all();
+        const out = [];
+        for (const row of rows) {
+            const vector = unpackFloat32(row["vector"]);
+            if (!vector)
+                continue;
+            out.push({
+                memoryId: row["memory_id"],
+                model: row["model"],
+                dim: row["dim"],
+                vector,
+            });
+        }
+        return out;
+    }
+    catch {
+        return [];
+    }
+}
+// ─── Write helpers ──────────────────────────────────────────────────────────
+export function saveEmbedding(memoryId, vector, model) {
+    if (!isDbAvailable())
+        return false;
+    try {
+        upsertMemoryEmbedding({
+            memoryId,
+            model,
+            dim: vector.length,
+            vector: packFloat32(vector),
+            updatedAt: new Date().toISOString(),
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function removeEmbedding(memoryId) {
+    if (!isDbAvailable())
+        return false;
+    try {
+        return deleteMemoryEmbedding(memoryId);
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Orchestration ──────────────────────────────────────────────────────────
+/**
+ * Embed each memory's content via `embedFn` (if provided) and persist the
+ * resulting vectors. Returns the number of successfully embedded memories.
+ * Safe to call with embedFn=null — it becomes a no-op.
+ */
+export async function embedMemories(memories, embedFn, model) {
+    if (!embedFn || memories.length === 0)
+        return 0;
+    try {
+        const vectors = await embedFn(memories.map((m) => m.content));
+        let count = 0;
+        for (let i = 0; i < memories.length && i < vectors.length; i++) {
+            const vector = vectors[i];
+            if (!vector || vector.length === 0)
+                continue;
+            if (saveEmbedding(memories[i].id, vector, model))
+                count++;
+        }
+        return count;
+    }
+    catch (err) {
+        logWarning("memory-embeddings", `embed failed: ${err.message}`);
+        return 0;
+    }
+}