gsd-pi 2.74.0-dev.703eabc → 2.74.0-dev.b2838e6

package/src/resources/extensions/gsd/commands/handlers/core.ts

@@ -4,7 +4,7 @@ import type { GSDState } from "../../types.js";
 
 import { computeProgressScore, formatProgressLine } from "../../progress-score.js";
 import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath } from "../../preferences.js";
-import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard } from "../../commands-prefs-wizard.js";
+import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard, handleLanguage } from "../../commands-prefs-wizard.js";
 import { runEnvironmentChecks } from "../../doctor-environment.js";
 import { deriveState } from "../../state.js";
 import { handleCmux } from "../../commands-cmux.js";
@@ -395,6 +395,10 @@ export async function handleCoreCommand(
     await handlePrefs(trimmed.replace(/^prefs\s*/, "").trim(), ctx);
     return true;
   }
+  if (trimmed === "language" || trimmed.startsWith("language ")) {
+    await handleLanguage(trimmed.replace(/^language\s*/, "").trim(), ctx);
+    return true;
+  }
   if (trimmed === "cmux" || trimmed.startsWith("cmux ")) {
     await handleCmux(trimmed.replace(/^cmux\s*/, "").trim(), ctx);
     return true;

package/src/resources/extensions/gsd/commands-prefs-wizard.ts

@@ -756,8 +756,8 @@ export async function handlePrefsWizard(
 /** Wrap a YAML value in double quotes if it contains special characters. */
 export function yamlSafeString(val: unknown): string {
   if (typeof val !== "string") return String(val);
-  if (/[:#{\[\]'"`,|>&*!?@%]/.test(val) || val.trim() !== val || val === "") {
-    return `"${val.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+  if (/[:#{\[\]'"`,|>&*!?@%\r\n]/.test(val) || val.trim() !== val || val === "") {
+    return `"${val.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\r/g, "\\r").replace(/\n/g, "\\n")}"`;
   }
   return val;
 }
@@ -825,7 +825,7 @@ export function serializePreferencesToFrontmatter(prefs: Record<string, unknown>
     "dynamic_routing", "uok", "token_profile", "phases", "parallel",
     "auto_visualize", "auto_report",
     "verification_commands", "verification_auto_fix", "verification_max_retries",
-    "search_provider", "context_selection",
+    "search_provider", "context_selection", "language",
   ];
 
   const seen = new Set<string>();
@@ -862,3 +862,57 @@ export async function ensurePreferencesFile(
     ctx.ui.notify(`Using existing ${scope} GSD skill preferences at ${path}`, "info");
   }
 }
+
+/**
+ * Handle `/gsd language [code]` — set or clear the global language preference.
+ * Without an argument, shows the current setting.
+ * Project-level override can be set by editing `.gsd/preferences.md` directly
+ * (project language overrides global when both are set).
+ */
+export async function handleLanguage(args: string, ctx: ExtensionCommandContext): Promise<void> {
+  const path = getGlobalGSDPreferencesPath();
+  const lang = args.trim();
+
+  // Show current setting when called without argument
+  if (!lang) {
+    const loaded = loadGlobalGSDPreferences();
+    const current = loaded?.preferences.language;
+    if (current) {
+      ctx.ui.notify(`Current language preference: ${current}\nUse /gsd language <name> to change, or /gsd language off to clear.`, "info");
+    } else {
+      ctx.ui.notify("No language preference set. Use /gsd language <name> to set one (e.g. /gsd language Chinese).", "info");
+    }
+    return;
+  }
+
+  // Ensure preferences file exists with the canonical template
+  await ensurePreferencesFile(path, ctx, "global");
+
+  // Read via the same validated path as other handlers
+  const existing = loadGlobalGSDPreferences();
+  const prefs: Record<string, unknown> = existing?.preferences ? { ...existing.preferences } : { version: 1 };
+
+  if (lang === "off" || lang === "none" || lang === "clear") {
+    delete prefs.language;
+    ctx.ui.notify("Language preference cleared. GSD will use the default language.", "info");
+  } else {
+    // Validate before writing — reject values that would fail on next load
+    if (lang.length > 50 || /[\r\n]/.test(lang)) {
+      ctx.ui.notify(
+        "Language value must be 50 characters or fewer with no newlines (e.g. /gsd language Chinese).",
+        "warning",
+      );
+      return;
+    }
+    prefs.language = lang;
+    ctx.ui.notify(`Language preference set to: ${lang}\nGSD will now respond in ${lang} across all sessions.`, "info");
+  }
+
+  const rawContent = existsSync(path) ? readFileSync(path, "utf-8") : `---\nversion: 1\n---\n`;
+  const frontmatter = serializePreferencesToFrontmatter(prefs);
+  const body = extractBodyAfterFrontmatter(rawContent)
+    ?? "\n# GSD Skill Preferences\n\nSee `~/.gsd/agent/extensions/gsd/docs/preferences-reference.md` for full field documentation and examples.\n";
+  await saveFile(path, `---\n${frontmatter}---${body}`);
+  await ctx.waitForIdle();
+  await ctx.reload();
+}

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

@@ -102,6 +102,8 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `custom_instructions`: extra durable instructions related to skill use. For operational project knowledge (recurring rules, gotchas, patterns), use `.gsd/KNOWLEDGE.md` instead — it's injected into every agent prompt automatically and agents can append to it during execution.
 
+- `language`: preferred response language for all GSD interactions. Accepts any language name or code — `"Chinese"`, `"zh"`, `"German"`, `"de"`, `"日本語"`, etc. When set, GSD injects "Always respond in \<language\>" into every agent's system prompt, including after `/clear`. Quickest way to set it: `/gsd language <name>`. To clear: `/gsd language off`.
+
 - `models`: per-stage model selection (applies to both auto-mode and guided-flow dispatches). Keys: `research`, `planning`, `discuss`, `execution`, `execution_simple`, `completion`, `validation`, `subagent`. Values can be:
   - Simple string: `"claude-sonnet-4-6"` — single model, no fallbacks
   - Provider-qualified string: `"bedrock/claude-sonnet-4-6"` — targets a specific provider when the same model ID exists across multiple providers

package/src/resources/extensions/gsd/guided-flow.ts

@@ -269,10 +269,12 @@ export function checkAutoStartAfterDiscuss(): boolean {
   } catch (e) { logWarning("guided", `CONTEXT-DRAFT.md unlink failed: ${(e as Error).message}`); }
 
   // Cleanup: remove discussion manifest after auto-start (only needed during discussion)
-  try { unlinkSync(manifestPath); } catch (e) { logWarning("guided", `manifest unlink failed: ${(e as Error).message}`); }
+  if (existsSync(manifestPath)) {
+    try { unlinkSync(manifestPath); } catch (e) { logWarning("guided", `manifest unlink failed: ${(e as Error).message}`); }
+  }
 
   pendingAutoStartMap.delete(basePath);
-  ctx.ui.notify(`Milestone ${milestoneId} ready.`, "info");
+  ctx.ui.notify(`Milestone ${milestoneId} ready.`, "success");
   startAutoDetached(ctx, pi, basePath, false, { step });
   return true;
 }

package/src/resources/extensions/gsd/preferences-types.ts

@@ -115,6 +115,7 @@ export const KNOWN_PREFERENCE_KEYS = new Set<string>([
   "discuss_web_research",
   "discuss_depth",
   "flat_rate_providers",
+  "language",
 ]);
 
 /** Canonical list of all dispatch unit types. */
@@ -403,6 +404,11 @@ export interface GSDPreferences {
    * same regardless of model.  Case-insensitive.
    */
   flat_rate_providers?: string[];
+  /**
+   * Language preference for GSD responses. Accepts any language name or code
+   * (e.g. "Chinese", "zh", "German", "de", "日本語"). Persists across /clear.
+   */
+  language?: string;
 }
 
 export interface LoadedGSDPreferences {

package/src/resources/extensions/gsd/preferences-validation.ts

@@ -1107,5 +1107,15 @@ export function validatePreferences(preferences: GSDPreferences): {
     }
   }
 
+  // ─── Language ────────────────────────────────────────────────────────
+  if (preferences.language !== undefined) {
+    const trimmed = typeof preferences.language === "string" ? preferences.language.trim() : undefined;
+    if (trimmed && trimmed.length <= 50 && !/[\r\n]/.test(trimmed)) {
+      validated.language = trimmed;
+    } else {
+      errors.push(`language must be a non-empty string up to 50 characters with no newlines (e.g. "Chinese", "de", "日本語")`);
+    }
+  }
+
   return { preferences: validated, errors, warnings };
 }

package/src/resources/extensions/gsd/preferences.ts

@@ -447,6 +447,7 @@ function mergePreferences(base: GSDPreferences, override: GSDPreferences): GSDPr
     slice_parallel: (base.slice_parallel || override.slice_parallel)
       ? { ...(base.slice_parallel ?? {}), ...(override.slice_parallel ?? {}) }
       : undefined,
+    language: override.language ?? base.language,
   };
 }
 
@@ -562,6 +563,11 @@ export function renderPreferencesForSystemPrompt(preferences: GSDPreferences, re
     }
   }
 
+  if (preferences.language) {
+    const safeLang = preferences.language.replace(/[\r\n]/g, " ").slice(0, 50);
+    lines.push(`- Language: Always respond in ${safeLang}.`);
+  }
+
   return lines.join("\n");
 }
 

package/src/resources/extensions/gsd/safety/evidence-collector.ts

@@ -68,11 +68,11 @@ export function getFilePaths(): string[] {
  * Record a tool call at dispatch time (before execution).
  * Exit codes and output are filled in by recordToolResult after execution.
  */
-export function recordToolCall(toolName: string, input: Record<string, unknown>): void {
+export function recordToolCall(toolCallId: string, toolName: string, input: Record<string, unknown>): void {
   if (toolName === "bash" || toolName === "Bash") {
     unitEvidence.push({
       kind: "bash",
-      toolCallId: "",
+      toolCallId,
       command: String(input.command ?? ""),
       exitCode: -1,
       outputSnippet: "",
@@ -81,14 +81,14 @@ export function recordToolCall(toolName: string, input: Record<string, unknown>)
   } else if (toolName === "write" || toolName === "Write") {
     unitEvidence.push({
       kind: "write",
-      toolCallId: "",
+      toolCallId,
       path: String(input.file_path ?? input.path ?? ""),
       timestamp: Date.now(),
     });
   } else if (toolName === "edit" || toolName === "Edit") {
     unitEvidence.push({
       kind: "edit",
-      toolCallId: "",
+      toolCallId,
       path: String(input.file_path ?? input.path ?? ""),
       timestamp: Date.now(),
     });
@@ -96,8 +96,9 @@ export function recordToolCall(toolName: string, input: Record<string, unknown>)
 }
 
 /**
- * Record a tool execution result. Matches the most recent unresolved entry
- * of the same kind and fills in the toolCallId, exit code, and output.
+ * Record a tool execution result. Matches the entry by toolCallId (assigned
+ * at dispatch time) and fills in exit code + output. Prior versions matched
+ * by `kind + empty-string` which corrupted parallel tool calls.
  */
 export function recordToolResult(
   toolCallId: string,
@@ -105,36 +106,19 @@ export function recordToolResult(
   result: unknown,
   isError: boolean,
 ): void {
-  const normalizedName = toolName.toLowerCase();
-
-  if (normalizedName === "bash") {
-    const entry = findLastUnresolved("bash") as BashEvidence | undefined;
-    if (entry) {
-      entry.toolCallId = toolCallId;
-      const text = extractResultText(result);
-      entry.outputSnippet = text.slice(0, 500);
-      const exitMatch = text.match(/Command exited with code (\d+)/);
-      entry.exitCode = exitMatch ? Number(exitMatch[1]) : (isError ? 1 : 0);
-    }
-  } else if (normalizedName === "write" || normalizedName === "edit") {
-    const entry = findLastUnresolved(normalizedName as "write" | "edit");
-    if (entry) {
-      entry.toolCallId = toolCallId;
-    }
+  const entry = unitEvidence.find(e => e.toolCallId === toolCallId);
+  if (!entry) return;
+
+  if (entry.kind === "bash") {
+    const text = extractResultText(result);
+    entry.outputSnippet = text.slice(0, 500);
+    const exitMatch = text.match(/Command exited with code (\d+)/);
+    entry.exitCode = exitMatch ? Number(exitMatch[1]) : (isError ? 1 : 0);
   }
 }
 
 // ─── Internals ──────────────────────────────────────────────────────────────
 
-function findLastUnresolved(kind: string): EvidenceEntry | undefined {
-  for (let i = unitEvidence.length - 1; i >= 0; i--) {
-    if (unitEvidence[i].kind === kind && unitEvidence[i].toolCallId === "") {
-      return unitEvidence[i];
-    }
-  }
-  return undefined;
-}
-
 function extractResultText(result: unknown): string {
   if (typeof result === "string") return result;
   if (result && typeof result === "object") {

package/src/resources/extensions/gsd/templates/PREFERENCES.md

@@ -89,6 +89,7 @@ remote_questions:
 uat_dispatch:
 post_unit_hooks: []
 pre_dispatch_hooks: []
+# language:
 # experimental:
 #   rtk: false
 ---

package/src/resources/extensions/gsd/tests/artifacts-table-preserved-on-cache-invalidate.test.ts

@@ -0,0 +1,177 @@
+/**
+ * Regression test: invalidateAllCaches() must NOT wipe the artifacts table.
+ *
+ * Prior to this fix, `cache.ts` bundled `clearArtifacts()` (which runs
+ * `DELETE FROM artifacts`) into `invalidateAllCaches()`. That helper fires
+ * on every post-unit pass, so rows written by `saveArtifactToDb` and
+ * `writeAndStore` (RESEARCH, CONTEXT, VALIDATION, ASSESSMENT, PLAN,
+ * ROADMAP, task PLAN, task SUMMARY) got deleted within seconds of being
+ * written. The milestone completed on disk, but `SELECT COUNT(*) FROM
+ * artifacts` returned 0, and the agent fell into a "file exists but DB
+ * record missing" recovery loop.
+ *
+ * The artifacts table is a write-through store, not a read cache. Routine
+ * cache invalidation must preserve its contents.
+ *
+ * Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+ */
+
+import { describe, test, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+
+import { invalidateAllCaches } from "../cache.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertArtifact,
+  isDbAvailable,
+  _getAdapter,
+} from "../gsd-db.ts";
+
+afterEach(() => {
+  if (isDbAvailable()) {
+    try {
+      closeDatabase();
+    } catch {
+      /* best-effort teardown */
+    }
+  }
+});
+
+describe("invalidateAllCaches() must preserve the artifacts table", () => {
+  test("rows survive a single invalidate call", () => {
+    const opened = openDatabase(":memory:");
+    assert.equal(opened, true, "in-memory DB must open");
+
+    insertArtifact({
+      path: "milestones/M001/slices/S01/S01-RESEARCH.md",
+      artifact_type: "RESEARCH",
+      milestone_id: "M001",
+      slice_id: "S01",
+      task_id: null,
+      full_content: "# Research\n\nFindings go here.\n",
+    });
+
+    invalidateAllCaches();
+
+    const adapter = _getAdapter();
+    assert.ok(adapter, "adapter should be available");
+    const row = adapter!
+      .prepare(
+        "SELECT path, artifact_type, length(full_content) AS len FROM artifacts WHERE path = :path",
+      )
+      .get({ ":path": "milestones/M001/slices/S01/S01-RESEARCH.md" }) as
+      | { path: string; artifact_type: string; len: number }
+      | undefined;
+
+    assert.ok(
+      row,
+      "artifact row must still exist after invalidateAllCaches — this is the Phase B bug",
+    );
+    assert.equal(row!.artifact_type, "RESEARCH");
+    assert.ok((row!.len ?? 0) > 0, "full_content must not be truncated");
+  });
+
+  test("multiple rows for a full milestone survive repeated invalidates", () => {
+    openDatabase(":memory:");
+
+    const inserts = [
+      {
+        path: "milestones/M001/M001-ROADMAP.md",
+        artifact_type: "ROADMAP",
+        milestone_id: "M001",
+        slice_id: null,
+        task_id: null,
+      },
+      {
+        path: "milestones/M001/slices/S01/S01-RESEARCH.md",
+        artifact_type: "RESEARCH",
+        milestone_id: "M001",
+        slice_id: "S01",
+        task_id: null,
+      },
+      {
+        path: "milestones/M001/slices/S01/S01-PLAN.md",
+        artifact_type: "PLAN",
+        milestone_id: "M001",
+        slice_id: "S01",
+        task_id: null,
+      },
+      {
+        path: "milestones/M001/slices/S01/tasks/T01-PLAN.md",
+        artifact_type: "PLAN",
+        milestone_id: "M001",
+        slice_id: "S01",
+        task_id: "T01",
+      },
+      {
+        path: "milestones/M001/slices/S01/tasks/T01-SUMMARY.md",
+        artifact_type: "SUMMARY",
+        milestone_id: "M001",
+        slice_id: "S01",
+        task_id: "T01",
+      },
+      {
+        path: "milestones/M001/M001-SUMMARY.md",
+        artifact_type: "SUMMARY",
+        milestone_id: "M001",
+        slice_id: null,
+        task_id: null,
+      },
+    ];
+
+    for (const i of inserts) {
+      insertArtifact({ ...i, full_content: `# ${i.artifact_type} content\n` });
+    }
+
+    // Simulate a full milestone's worth of post-unit cycles.
+    for (let i = 0; i < 10; i++) {
+      invalidateAllCaches();
+    }
+
+    const adapter = _getAdapter()!;
+    const count = (
+      adapter.prepare("SELECT COUNT(*) AS n FROM artifacts").get() as { n: number }
+    ).n;
+
+    assert.equal(
+      count,
+      inserts.length,
+      `all ${inserts.length} artifact rows must survive repeated invalidate calls; got ${count}`,
+    );
+  });
+});
+
+describe("cache.ts must not re-import clearArtifacts into invalidateAllCaches", () => {
+  const src = readFileSync(
+    resolve(process.cwd(), "src", "resources", "extensions", "gsd", "cache.ts"),
+    "utf-8",
+  );
+
+  test("clearArtifacts is not imported from gsd-db", () => {
+    assert.ok(
+      !/import\s*\{[^}]*clearArtifacts[^}]*\}\s*from\s*['"]\.\/gsd-db/.test(src),
+      "cache.ts must not import clearArtifacts — it causes the artifacts-table-wipe regression",
+    );
+  });
+
+  test("invalidateAllCaches does not call clearArtifacts", () => {
+    const fnIdx = src.indexOf("function invalidateAllCaches");
+    assert.ok(fnIdx !== -1);
+    const body = src.slice(fnIdx, fnIdx + 1000);
+    assert.ok(
+      !/\bclearArtifacts\s*\(/.test(body),
+      "invalidateAllCaches must not call clearArtifacts() — it wipes the write-through store",
+    );
+  });
+
+  test("cache.ts documents why clearArtifacts is not bundled here", () => {
+    // Future reviewers need to see the rationale or they'll re-add it.
+    assert.ok(
+      /artifacts.*NOT included|write-through store/i.test(src),
+      "cache.ts must explain why the artifacts table is NOT invalidated here",
+    );
+  });
+});