gsd-pi 2.74.0-dev.28a6415 → 2.74.0-dev.658744a

package/src/resources/extensions/gsd/ecosystem/gsd-extension-api.ts

@@ -0,0 +1,228 @@
+// GSD2 — Ecosystem Extension API wrapper
+// Wraps pi's ExtensionAPI to expose typed GSD context (phase + active unit)
+// to extensions loaded from `./.gsd/extensions/`. The wrapper intercepts only
+// `on("before_agent_start", ...)` so GSD can dispatch ecosystem handlers AFTER
+// refreshing state — fixing the load-order race where third-party
+// `.pi/extensions/` handlers see a stale module-level snapshot (#3338).
+//
+// SINGLE-SESSION INVARIANT: the module-level `_snapshot` is per-process.
+// Worktree or project switches do NOT reload extensions, matching pi's
+// `.pi/extensions/` behavior. Only re-launching the CLI rebinds the snapshot.
+
+import type {
+  BeforeAgentStartEvent,
+  ExtensionAPI,
+  ExtensionHandler,
+} from "@gsd/pi-coding-agent";
+
+// Structural mirror of pi's internal BeforeAgentStartEventResult. The internal
+// type is not re-exported from the package root, and constraint #3 forbids
+// changes to packages/pi-coding-agent/, so we mirror the public shape here.
+// `any` on inner fields keeps assignability bidirectional with pi's stricter
+// `Pick<CustomMessage, ...>` shape (CustomMessage is also not re-exported).
+// Source of truth: packages/pi-coding-agent/src/core/extensions/types.ts
+export interface BeforeAgentStartEventResult {
+  message?: {
+    customType: string;
+    content?: any;
+    display?: any;
+    details?: any;
+  };
+  systemPrompt?: string;
+}
+
+import type { GSDActiveUnit, GSDState, Phase } from "../types.js";
+import { isGSDActive, getCurrentPhase } from "../../shared/gsd-phase-state.js";
+import { logWarning } from "../workflow-logger.js";
+
+// ─── Public Interface ───────────────────────────────────────────────────
+
+export interface GSDExtensionAPI extends ExtensionAPI {
+  /** Current GSD workflow phase, or null if no project state. */
+  getPhase(): Phase | null;
+  /** Currently active milestone/slice/task triple, or null if none. */
+  getActiveUnit(): GSDActiveUnit | null;
+}
+
+export type GSDEcosystemBeforeAgentStartHandler = ExtensionHandler<
+  BeforeAgentStartEvent,
+  BeforeAgentStartEventResult
+>;
+
+// ─── Auto-loop phase mapping ────────────────────────────────────────────
+
+const AUTO_LOOP_PHASE_MAP: Record<string, Phase> = {
+  "plan-milestone": "planning",
+  "plan-slice": "planning",
+  "research": "researching",
+  "discuss": "discussing",
+  "execute-task": "executing",
+  "verify": "verifying",
+  "summarize-task": "summarizing",
+  "summarize-slice": "summarizing",
+  "advance": "advancing",
+  "validate-milestone": "validating-milestone",
+  "complete-milestone": "completing-milestone",
+  "replan-slice": "replanning-slice",
+};
+
+/** Exposed for unit tests. Returns null for unknown keys (does NOT default). */
+export function mapAutoLoopPhase(raw: string): Phase | null {
+  return AUTO_LOOP_PHASE_MAP[raw] ?? null;
+}
+
+function resolvePhase(state: GSDState | null): Phase | null {
+  if (!state) return null;
+  if (isGSDActive()) {
+    const raw = getCurrentPhase();
+    if (raw != null) {
+      const mapped = AUTO_LOOP_PHASE_MAP[raw];
+      if (mapped) return mapped;
+      logWarning("ecosystem", `unknown auto-loop phase: ${raw}`);
+      // FALL THROUGH to state.phase rather than defaulting to "executing".
+    }
+  }
+  return state.phase;
+}
+
+function resolveActiveUnit(state: GSDState | null): GSDActiveUnit | null {
+  if (!state) return null;
+  const m = state.activeMilestone;
+  const s = state.activeSlice;
+  const t = state.activeTask;
+  if (!m || !s || !t) return null;
+  return {
+    milestoneId: m.id,
+    milestoneTitle: m.title,
+    sliceId: s.id,
+    sliceTitle: s.title,
+    taskId: t.id,
+    taskTitle: t.title,
+  };
+}
+
+// ─── Module-level snapshot ──────────────────────────────────────────────
+
+interface Snapshot {
+  phase: Phase | null;
+  activeUnit: GSDActiveUnit | null;
+}
+
+let _snapshot: Snapshot = { phase: null, activeUnit: null };
+
+/** Refresh the snapshot from a freshly derived GSDState (or null on failure). */
+export function updateSnapshot(state: GSDState | null): void {
+  _snapshot = {
+    phase: resolvePhase(state),
+    activeUnit: resolveActiveUnit(state),
+  };
+}
+
+export function getSnapshotPhase(): Phase | null {
+  return _snapshot.phase;
+}
+
+export function getSnapshotActiveUnit(): GSDActiveUnit | null {
+  return _snapshot.activeUnit;
+}
+
+/** Test-only: reset the snapshot to its initial empty state. */
+export function _resetSnapshot(): void {
+  _snapshot = { phase: null, activeUnit: null };
+}
+
+// ─── Wrapper factory ────────────────────────────────────────────────────
+
+/**
+ * Build a GSDExtensionAPI by manually delegating every ExtensionAPI method
+ * to the underlying pi instance, except `on("before_agent_start", ...)`
+ * which is captured into `sharedHandlers` for GSD-owned dispatch.
+ *
+ * Uses `satisfies GSDExtensionAPI` (NOT `as`) so TypeScript catches drift
+ * when pi adds new ExtensionAPI methods.
+ */
+export function createGSDExtensionAPI(
+  pi: ExtensionAPI,
+  sharedHandlers: GSDEcosystemBeforeAgentStartHandler[],
+): GSDExtensionAPI {
+  const wrapper = {
+    // ── Event subscription (single intercept point) ────────────────────
+    on(event: any, handler: any): void {
+      if (event === "before_agent_start") {
+        sharedHandlers.push(handler as GSDEcosystemBeforeAgentStartHandler);
+        return;
+      }
+      (pi.on as (e: any, h: any) => void)(event, handler);
+    },
+
+    // ── Event emission ─────────────────────────────────────────────────
+    emitBeforeModelSelect: (...args: Parameters<ExtensionAPI["emitBeforeModelSelect"]>) =>
+      pi.emitBeforeModelSelect(...args),
+    emitAdjustToolSet: (...args: Parameters<ExtensionAPI["emitAdjustToolSet"]>) =>
+      pi.emitAdjustToolSet(...args),
+
+    // ── Tool / command / shortcut / flag registration ──────────────────
+    registerTool: ((tool: any) => pi.registerTool(tool)) as ExtensionAPI["registerTool"],
+    registerCommand: (...args: Parameters<ExtensionAPI["registerCommand"]>) =>
+      pi.registerCommand(...args),
+    registerBeforeInstall: (...args: Parameters<ExtensionAPI["registerBeforeInstall"]>) =>
+      pi.registerBeforeInstall(...args),
+    registerAfterInstall: (...args: Parameters<ExtensionAPI["registerAfterInstall"]>) =>
+      pi.registerAfterInstall(...args),
+    registerBeforeRemove: (...args: Parameters<ExtensionAPI["registerBeforeRemove"]>) =>
+      pi.registerBeforeRemove(...args),
+    registerAfterRemove: (...args: Parameters<ExtensionAPI["registerAfterRemove"]>) =>
+      pi.registerAfterRemove(...args),
+    registerShortcut: (...args: Parameters<ExtensionAPI["registerShortcut"]>) =>
+      pi.registerShortcut(...args),
+    registerFlag: (...args: Parameters<ExtensionAPI["registerFlag"]>) =>
+      pi.registerFlag(...args),
+    getFlag: (...args: Parameters<ExtensionAPI["getFlag"]>) => pi.getFlag(...args),
+
+    // ── Message rendering ──────────────────────────────────────────────
+    registerMessageRenderer: ((customType: string, renderer: any) =>
+      pi.registerMessageRenderer(customType, renderer)) as ExtensionAPI["registerMessageRenderer"],
+
+    // ── Actions ────────────────────────────────────────────────────────
+    sendMessage: ((message: any, options?: any) =>
+      pi.sendMessage(message, options)) as ExtensionAPI["sendMessage"],
+    sendUserMessage: (...args: Parameters<ExtensionAPI["sendUserMessage"]>) =>
+      pi.sendUserMessage(...args),
+    retryLastTurn: () => pi.retryLastTurn(),
+    appendEntry: ((customType: string, data?: any) =>
+      pi.appendEntry(customType, data)) as ExtensionAPI["appendEntry"],
+
+    // ── Session metadata ───────────────────────────────────────────────
+    setSessionName: (...args: Parameters<ExtensionAPI["setSessionName"]>) =>
+      pi.setSessionName(...args),
+    getSessionName: () => pi.getSessionName(),
+    setLabel: (...args: Parameters<ExtensionAPI["setLabel"]>) => pi.setLabel(...args),
+    exec: (...args: Parameters<ExtensionAPI["exec"]>) => pi.exec(...args),
+    getActiveTools: () => pi.getActiveTools(),
+    getAllTools: () => pi.getAllTools(),
+    setActiveTools: (...args: Parameters<ExtensionAPI["setActiveTools"]>) =>
+      pi.setActiveTools(...args),
+    getCommands: () => pi.getCommands(),
+
+    // ── Model & thinking ───────────────────────────────────────────────
+    setModel: (...args: Parameters<ExtensionAPI["setModel"]>) => pi.setModel(...args),
+    getThinkingLevel: () => pi.getThinkingLevel(),
+    setThinkingLevel: (...args: Parameters<ExtensionAPI["setThinkingLevel"]>) =>
+      pi.setThinkingLevel(...args),
+
+    // ── Provider registration ──────────────────────────────────────────
+    registerProvider: (...args: Parameters<ExtensionAPI["registerProvider"]>) =>
+      pi.registerProvider(...args),
+    unregisterProvider: (...args: Parameters<ExtensionAPI["unregisterProvider"]>) =>
+      pi.unregisterProvider(...args),
+
+    // ── Shared event bus (passthrough property) ────────────────────────
+    events: pi.events,
+
+    // ── GSD-specific additions ─────────────────────────────────────────
+    getPhase: (): Phase | null => _snapshot.phase,
+    getActiveUnit: (): GSDActiveUnit | null => _snapshot.activeUnit,
+  } satisfies GSDExtensionAPI;
+
+  return wrapper;
+}

package/src/resources/extensions/gsd/ecosystem/loader.ts

@@ -0,0 +1,201 @@
+// GSD2 — Ecosystem extension loader for ./.gsd/extensions/
+// Discovers and registers single-file extensions that consume GSDExtensionAPI.
+// Trust-gated (mirrors pi's `.pi/extensions/` model) and isolated from pi's
+// own loader chain — handlers run in GSD's own dispatch step, not pi's.
+
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { pathToFileURL } from "node:url";
+
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import { getAgentDir } from "@gsd/pi-coding-agent";
+
+import { logWarning } from "../workflow-logger.js";
+import {
+  createGSDExtensionAPI,
+  type GSDEcosystemBeforeAgentStartHandler,
+  type GSDExtensionAPI,
+} from "./gsd-extension-api.js";
+
+// ─── Trust check (inlined; pi does not export isProjectTrusted from its
+// package root, and constraint forbids modifying packages/pi-coding-agent/) ─
+
+const TRUSTED_PROJECTS_FILE = "trusted-projects.json";
+
+function isProjectTrusted(projectPath: string, agentDir: string): boolean {
+  const canonical = path.resolve(projectPath);
+  const trustedPath = path.join(agentDir, TRUSTED_PROJECTS_FILE);
+  try {
+    const content = fs.readFileSync(trustedPath, "utf-8");
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed)) {
+      return parsed.includes(canonical);
+    }
+  } catch {
+    // missing or malformed — treat as untrusted
+  }
+  return false;
+}
+
+// ─── Ready-promise singleton ────────────────────────────────────────────
+
+let _readyPromise: Promise<void> | null = null;
+let _untrustedWarned = false;
+
+/**
+ * Discover and register ecosystem extensions from `./.gsd/extensions/`.
+ * Idempotent: subsequent calls with the same arguments return the same
+ * pending promise (no double-load).
+ */
+export function loadEcosystemExtensions(
+  pi: ExtensionAPI,
+  sharedHandlers: GSDEcosystemBeforeAgentStartHandler[],
+  cwd: string = process.cwd(),
+): Promise<void> {
+  if (_readyPromise) return _readyPromise;
+  _readyPromise = _loadEcosystemExtensionsImpl(pi, sharedHandlers, cwd);
+  return _readyPromise;
+}
+
+/**
+ * Returns a promise that resolves when ecosystem loading has completed.
+ * If loading was never kicked off this returns a resolved promise so the
+ * `before_agent_start` handler can `await` unconditionally.
+ */
+export function getEcosystemReadyPromise(): Promise<void> {
+  return _readyPromise ?? Promise.resolve();
+}
+
+/** Test-only: clear the singleton so tests can re-run loading. */
+export function _resetEcosystemLoader(): void {
+  _readyPromise = null;
+  _untrustedWarned = false;
+}
+
+// ─── Implementation ─────────────────────────────────────────────────────
+
+async function _loadEcosystemExtensionsImpl(
+  pi: ExtensionAPI,
+  sharedHandlers: GSDEcosystemBeforeAgentStartHandler[],
+  cwd: string,
+): Promise<void> {
+  const extDir = path.join(cwd, ".gsd", "extensions");
+  if (!fs.existsSync(extDir)) return;
+
+  // Trust gate: refuse to load arbitrary code from untrusted project dirs.
+  if (!isProjectTrusted(cwd, getAgentDir())) {
+    if (!_untrustedWarned) {
+      _untrustedWarned = true;
+      logWarning(
+        "ecosystem",
+        ".gsd/extensions present but project is not trusted — skipping ecosystem extensions. Run `pi trust` to opt in.",
+      );
+    }
+    return;
+  }
+
+  // Resolve realpath ONCE so symlink-escape detection has a stable anchor.
+  let realExtDir: string;
+  try {
+    realExtDir = fs.realpathSync(extDir);
+  } catch (err) {
+    logWarning(
+      "ecosystem",
+      `failed to resolve extensions dir: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return;
+  }
+
+  let entries: string[];
+  try {
+    entries = fs
+      .readdirSync(extDir)
+      .filter((f) => f.endsWith(".js") || f.endsWith(".ts"))
+      .sort(); // deterministic load order
+  } catch (err) {
+    logWarning(
+      "ecosystem",
+      `failed to read extensions dir: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return;
+  }
+
+  // The wrapper api is built once per loader run and shared by all extensions
+  // so they all read from the same module-level snapshot.
+  const api: GSDExtensionAPI = createGSDExtensionAPI(pi, sharedHandlers);
+
+  for (const entry of entries) {
+    await _loadOne(extDir, realExtDir, entry, api);
+  }
+}
+
+async function _loadOne(
+  extDir: string,
+  realExtDir: string,
+  entry: string,
+  api: GSDExtensionAPI,
+): Promise<void> {
+  const fullPath = path.join(extDir, entry);
+
+  // Symlink-escape guard: reject entries whose realpath is not under realExtDir.
+  let realFullPath: string;
+  try {
+    realFullPath = fs.realpathSync(fullPath);
+  } catch (err) {
+    logWarning(
+      "ecosystem",
+      `failed to resolve ${entry}: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return;
+  }
+  const realExtDirWithSep = realExtDir.endsWith(path.sep) ? realExtDir : realExtDir + path.sep;
+  if (
+    realFullPath !== realExtDir &&
+    !realFullPath.startsWith(realExtDirWithSep)
+  ) {
+    logWarning("ecosystem", `rejecting ${entry}: realpath escapes extensions dir`);
+    return;
+  }
+
+  // For .ts files, require a sibling compiled .js — we do not run a TS loader
+  // in production. Drop mtime heuristics: if .js exists, prefer it; otherwise warn.
+  let importPath = realFullPath;
+  if (entry.endsWith(".ts")) {
+    const jsSibling = realFullPath.slice(0, -3) + ".js";
+    if (fs.existsSync(jsSibling)) {
+      importPath = jsSibling;
+    } else {
+      logWarning(
+        "ecosystem",
+        `${entry}: TypeScript source has no compiled .js sibling — compile it first`,
+      );
+      return;
+    }
+  }
+
+  let mod: any;
+  try {
+    mod = await import(pathToFileURL(importPath).href);
+  } catch (err) {
+    logWarning(
+      "ecosystem",
+      `failed to import ${entry}: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    return;
+  }
+
+  const factory = mod?.default;
+  if (typeof factory !== "function") {
+    logWarning("ecosystem", `${entry}: default export is not a function`);
+    return;
+  }
+
+  try {
+    await factory(api);
+  } catch (err) {
+    logWarning(
+      "ecosystem",
+      `factory threw for ${entry}: ${err instanceof Error ? err.message : String(err)}`,
+    );
+  }
+}

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
 ---