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

package/src/resources/extensions/gsd/health-widget-core.ts

@@ -61,9 +61,10 @@ function truncateMessage(msg: string, maxLen: number): string {
 
 /**
  * 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: HealthWidgetData): string[] {
+export function buildHealthLines(data: HealthWidgetData, width?: number): string[] {
   if (data.projectState === "none") {
     return ["  GSD  No project loaded — run /gsd to start"];
   }
@@ -72,40 +73,68 @@ export function buildHealthLines(data: HealthWidgetData): string[] {
     return ["  GSD  Project initialized — run /gsd to continue setup"];
   }
 
-  const parts: string[] = [];
+  const leftParts: string[] = [];
 
   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/src/resources/extensions/gsd/health-widget.ts

@@ -129,12 +129,16 @@ export function initHealthWidget(ctx: ExtensionContext): void {
       void refresh();
     }, REFRESH_INTERVAL_MS);
 
+    let cachedWidth: number | undefined;
     return {
-      render(_width: number): string[] {
-        if (!cachedLines) cachedLines = buildHealthLines(data);
+      render(width: number): string[] {
+        if (!cachedLines || cachedWidth !== width) {
+          cachedLines = buildHealthLines(data, width);
+          cachedWidth = width;
+        }
         return cachedLines;
       },
-      invalidate(): void { cachedLines = undefined; },
+      invalidate(): void { cachedLines = undefined; cachedWidth = undefined; },
       dispose(): void {
         clearInterval(refreshTimer);
       },

package/src/resources/extensions/gsd/init-wizard.ts

@@ -17,6 +17,7 @@ import { assertSafeDirectory } from "./validate-directory.js";
 import type { ProjectDetection, ProjectSignals } from "./detection.js";
 import { runSkillInstallStep } from "./skill-catalog.js";
 import { generateCodebaseMap, writeCodebaseMap } from "./codebase-generator.js";
+import { handlePrefsWizard, writePreferencesFile } from "./commands-prefs-wizard.js";
 
 // ─── Types ──────────────────────────────────────────────────────────────────────
 
@@ -232,8 +233,53 @@ export async function showProjectInit(
     // 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
@@ -453,11 +499,13 @@ async function customizeAdvancedPrefs(
 
 // ─── Bootstrap ──────────────────────────────────────────────────────────────────
 
-function bootstrapGsdDirectory(
-  basePath: string,
-  prefs: ProjectPreferences,
-  signals: ProjectSignals,
-): void {
+/**
+ * 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: string, signals: ProjectSignals): void {
   // Final safety check before writing any files
   assertSafeDirectory(basePath);
 
@@ -465,10 +513,6 @@ function bootstrapGsdDirectory(
   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) {
@@ -476,60 +520,49 @@ function bootstrapGsdDirectory(
   }
 }
 
-function buildPreferencesFile(prefs: ProjectPreferences): string {
-  const lines: string[] = ["---"];
-  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}`);
+/**
+ * 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: ProjectPreferences): Record<string, unknown> {
+  const out: Record<string, unknown> = {
+    mode: prefs.mode,
+    git: {
+      isolation: prefs.gitIsolation,
+      main_branch: prefs.mainBranch,
+      auto_push: prefs.autoPush,
+    },
+  };
 
-  // Verification commands
   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");
+    out.phases = { 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 out;
+}
 
-  return lines.join("\n");
+function buildInitPreferencesBody(): string {
+  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: ProjectSignals): string | null {

package/src/resources/extensions/gsd/markdown-renderer.ts

@@ -169,7 +169,7 @@ function renderRoadmapMarkdown(milestone: MilestoneRow, slices: SliceRow[]): str
   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}`);
@@ -496,7 +496,7 @@ export async function renderRoadmapCheckboxes(
   // 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) {
@@ -821,19 +821,19 @@ export function detectStaleRenders(basePath: string): StaleEntry[] {
         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: { id: string }) => 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/src/resources/extensions/gsd/memory-embeddings.ts

@@ -0,0 +1,235 @@
+// 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 type { ExtensionContext } from "@gsd/pi-coding-agent";
+
+import { _getAdapter, isDbAvailable, upsertMemoryEmbedding, deleteMemoryEmbedding } from "./gsd-db.js";
+import { logWarning } from "./workflow-logger.js";
+
+// ─── Types ──────────────────────────────────────────────────────────────────
+
+export type EmbedFn = (texts: string[]) => Promise<Float32Array[]>;
+
+export interface EmbeddingModelInfo {
+  id: string;
+}
+
+export interface MemoryEmbeddingRow {
+  memoryId: string;
+  model: string;
+  dim: number;
+  vector: Float32Array;
+}
+
+// ─── 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: ExtensionContext): EmbedFn | null {
+  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 as Error).message}`);
+    return null;
+  }
+}
+
+// ─── Vector (de)serialization ───────────────────────────────────────────────
+
+export function packFloat32(vec: Float32Array): Uint8Array {
+  return new Uint8Array(vec.buffer, vec.byteOffset, vec.byteLength);
+}
+
+export function unpackFloat32(blob: unknown): Float32Array | null {
+  if (!blob) return null;
+  try {
+    if (blob instanceof Float32Array) return blob;
+    let view: Uint8Array;
+    if (blob instanceof Uint8Array) {
+      view = blob;
+    } else if (blob instanceof ArrayBuffer) {
+      view = new Uint8Array(blob);
+    } else if ((blob as Buffer).buffer && (blob as Buffer).byteLength != null) {
+      const buf = blob as Buffer;
+      view = new Uint8Array(buf.buffer, buf.byteOffset, buf.byteLength);
+    } else if (Array.isArray(blob)) {
+      return new Float32Array(blob as number[]);
+    } 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: Float32Array, b: Float32Array): number {
+  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: string): MemoryEmbeddingRow | null {
+  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"] as string,
+      model: row["model"] as string,
+      dim: row["dim"] as number,
+      vector,
+    };
+  } catch {
+    return null;
+  }
+}
+
+export function loadAllEmbeddings(): MemoryEmbeddingRow[] {
+  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: MemoryEmbeddingRow[] = [];
+    for (const row of rows) {
+      const vector = unpackFloat32(row["vector"]);
+      if (!vector) continue;
+      out.push({
+        memoryId: row["memory_id"] as string,
+        model: row["model"] as string,
+        dim: row["dim"] as number,
+        vector,
+      });
+    }
+    return out;
+  } catch {
+    return [];
+  }
+}
+
+// ─── Write helpers ──────────────────────────────────────────────────────────
+
+export function saveEmbedding(
+  memoryId: string,
+  vector: Float32Array,
+  model: string,
+): boolean {
+  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: string): boolean {
+  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: Array<{ id: string; content: string }>,
+  embedFn: EmbedFn | null,
+  model: string,
+): Promise<number> {
+  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 as Error).message}`);
+    return 0;
+  }
+}