@tuan_son.dinh/gsd 2.6.3 → 2.7.0

package/src/resources/extensions/gsd/git-service.ts

@@ -9,8 +9,7 @@
  */
 
 import { execSync } from "node:child_process";
-import { existsSync, readFileSync } from "node:fs";
-import { join, sep } from "node:path";
+import { sep } from "node:path";
 
 import {
   detectWorktreeName,
@@ -127,9 +126,11 @@ export class GitServiceImpl {
   /**
    * Smart staging: `git add -A` excluding GSD runtime paths via pathspec.
    * Falls back to plain `git add -A` if the exclusion pathspec fails.
+   * @param extraExclusions Additional pathspec exclusions beyond RUNTIME_EXCLUSION_PATHS.
    */
-  private smartStage(): void {
-    const excludes = RUNTIME_EXCLUSION_PATHS.map(p => `':(exclude)${p}'`);
+  private smartStage(extraExclusions: readonly string[] = []): void {
+    const allExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
+    const excludes = allExclusions.map(p => `':(exclude)${p}'`);
     const args = ["add", "-A", "--", ".", ...excludes];
     try {
       this.git(args);
@@ -161,13 +162,14 @@ export class GitServiceImpl {
   /**
    * Auto-commit dirty working tree with a conventional chore message.
    * Returns the commit message on success, or null if nothing to commit.
+   * @param extraExclusions Additional paths to exclude from staging (e.g. [".gsd/"] for pre-switch commits).
    */
-  autoCommit(unitType: string, unitId: string): string | null {
+  autoCommit(unitType: string, unitId: string, extraExclusions: readonly string[] = []): string | null {
     // Quick check: is there anything dirty at all?
     const status = this.git(["status", "--short"], { allowFailure: true });
     if (!status) return null;
 
-    this.smartStage();
+    this.smartStage(extraExclusions);
 
     // After smart staging, check if anything was actually staged
     // (all changes might have been runtime files that got excluded)
@@ -187,6 +189,11 @@ export class GitServiceImpl {
    * In the main tree: origin/HEAD symbolic-ref → main/master fallback → current branch.
    */
   getMainBranch(): string {
+    // Explicit preference takes priority (double-check validity as defense-in-depth)
+    if (this.prefs.main_branch && VALID_BRANCH_NAME.test(this.prefs.main_branch)) {
+      return this.prefs.main_branch;
+    }
+
     const wtName = detectWorktreeName(this.basePath);
     if (wtName) {
       const wtBranch = `worktree/${wtName}`;
@@ -195,12 +202,6 @@ export class GitServiceImpl {
       return this.git(["branch", "--show-current"]);
     }
 
-    // Explicit preference takes priority over auto-detection
-    const configured = this.prefs.main_branch;
-    if (configured && VALID_BRANCH_NAME.test(configured)) {
-      return configured;
-    }
-
     const symbolic = this.git(["symbolic-ref", "refs/remotes/origin/HEAD"], { allowFailure: true });
     if (symbolic) {
       const match = symbolic.match(/refs\/remotes\/origin\/(.+)$/);
@@ -258,9 +259,6 @@ export class GitServiceImpl {
    * branch (preserves planning artifacts). Falls back to main when on another
    * slice branch (avoids chaining slice branches).
    *
-   * When creating a new branch, fetches from remote first (best-effort) to
-   * ensure the local main is up-to-date.
-   *
    * Auto-commits dirty state via smart staging before checkout so runtime
    * files are never accidentally committed during branch switches.
    *
@@ -281,9 +279,8 @@ export class GitServiceImpl {
       if (remotes) {
         const remote = this.prefs.remote ?? "origin";
         const fetchResult = this.git(["fetch", "--prune", remote], { allowFailure: true });
-        // fetchResult is empty string on both success and allowFailure-caught error.
-        // Check if local is behind upstream (informational only).
-        if (remotes.split("\n").includes(remote)) {
+        if (fetchResult === "" && remotes.split("\n").includes(remote)) {
+          // Check if local is behind upstream (informational only)
           const behind = this.git(
             ["rev-list", "--count", "HEAD..@{upstream}"],
             { allowFailure: true },
@@ -311,8 +308,9 @@ export class GitServiceImpl {
       }
     }
 
-    // Auto-commit dirty state via smart staging before checkout
-    this.autoCommit("pre-switch", current);
+    // Auto-commit dirty state via smart staging before checkout.
+    // Exclude .gsd/ to prevent merge conflicts when both branches modify planning artifacts.
+    this.autoCommit("pre-switch", current, [".gsd/"]);
 
     this.git(["checkout", branch]);
     return created;
@@ -326,7 +324,8 @@ export class GitServiceImpl {
     const current = this.getCurrentBranch();
     if (current === mainBranch) return;
 
-    this.autoCommit("pre-switch", current);
+    // Exclude .gsd/ to prevent merge conflicts when both branches modify planning artifacts.
+    this.autoCommit("pre-switch", current, [".gsd/"]);
 
     this.git(["checkout", mainBranch]);
   }
@@ -357,93 +356,40 @@ export class GitServiceImpl {
   /**
    * Run pre-merge verification check. Auto-detects test runner from project
    * files, or uses custom command from prefs.pre_merge_check.
-   *
-   * Gating:
-   * - `false` → skip (return passed:true, skipped:true)
-   * - non-empty string (not "auto") → use as custom command
-   * - `true`, `"auto"`, or `undefined` → auto-detect from project files
-   *
-   * Auto-detection order:
-   *   package.json scripts.test → npm test
-   *   package.json scripts.build (only if no test) → npm run build
-   *   Cargo.toml → cargo test
-   *   Makefile with test: target → make test
-   *   pyproject.toml → python -m pytest
-   *
-   * If no runner detected in auto mode, returns passed:true (don't block).
+   * Gated on prefs.pre_merge_check (false = skip, string = custom command).
+   * Stub: to be implemented in T03.
    */
   runPreMergeCheck(): PreMergeCheckResult {
-    const pref = this.prefs.pre_merge_check;
-
-    // Explicitly disabled
-    if (pref === false) {
+    if (this.prefs.pre_merge_check === false || this.prefs.pre_merge_check === undefined) {
       return { passed: true, skipped: true };
     }
 
-    let command: string | null = null;
-
-    // Custom string command (not "auto")
-    if (typeof pref === "string" && pref !== "auto" && pref.trim() !== "") {
-      command = pref.trim();
-    }
-
-    // Auto-detect (true, "auto", or undefined)
-    if (command === null) {
-      command = this.detectTestRunner();
-    }
-
-    if (command === null) {
-      return { passed: true, command: "none", error: "no test runner detected" };
+    // Determine command: explicit string or auto-detect from package.json
+    let command: string;
+    if (typeof this.prefs.pre_merge_check === "string") {
+      command = this.prefs.pre_merge_check;
+    } else {
+      // Auto-detect: look for package.json with a test script
+      try {
+        const pkg = execSync("cat package.json", { cwd: this.basePath, encoding: "utf-8" });
+        const parsed = JSON.parse(pkg);
+        if (parsed.scripts?.test) {
+          command = "npm test";
+        } else {
+          return { passed: true, skipped: true };
+        }
+      } catch {
+        return { passed: true, skipped: true };
+      }
     }
 
-    // Execute the command
     try {
-      execSync(command, {
-        cwd: this.basePath,
-        timeout: 300_000,
-        stdio: ["ignore", "pipe", "pipe"],
-        encoding: "utf-8",
-      });
-      return { passed: true, command };
+      execSync(command, { cwd: this.basePath, stdio: "pipe", encoding: "utf-8" });
+      return { passed: true, skipped: false, command };
     } catch (err) {
-      const stderr = err instanceof Error && "stderr" in err
-        ? String((err as { stderr: unknown }).stderr).slice(0, 2000)
-        : String(err).slice(0, 2000);
-      return { passed: false, command, error: stderr };
-    }
-  }
-
-  /**
-   * Detect a test/build runner from project files in basePath.
-   * Returns the command string or null if nothing detected.
-   */
-  private detectTestRunner(): string | null {
-    const pkgPath = join(this.basePath, "package.json");
-    if (existsSync(pkgPath)) {
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf-8"));
-        if (pkg?.scripts?.test) return "npm test";
-        if (pkg?.scripts?.build) return "npm run build";
-      } catch { /* invalid JSON — skip */ }
-    }
-
-    if (existsSync(join(this.basePath, "Cargo.toml"))) {
-      return "cargo test";
+      const msg = err instanceof Error ? err.message : String(err);
+      return { passed: false, skipped: false, command, error: msg };
     }
-
-    const makefilePath = join(this.basePath, "Makefile");
-    if (existsSync(makefilePath)) {
-      try {
-        const content = readFileSync(makefilePath, "utf-8");
-        if (/^test\s*:/m.test(content)) return "make test";
-      } catch { /* skip */ }
-    }
-
-    if (existsSync(join(this.basePath, "pyproject.toml"))) {
-      return "python -m pytest";
-    }
-
-    return null;
   }
 
   // ─── Merge ─────────────────────────────────────────────────────────────
@@ -531,7 +477,8 @@ export class GitServiceImpl {
       );
     }
 
-    // Snapshot the branch HEAD before merge (gated on prefs.snapshots)
+    // Snapshot the branch HEAD before merge (gated on prefs)
+    // We need to save the ref while the branch still exists
     this.createSnapshot(branch);
 
     // Build rich commit message before squash (needs branch history)
@@ -540,18 +487,20 @@ export class GitServiceImpl {
       commitType, milestoneId, sliceId, sliceTitle, mainBranch, branch,
     );
 
-    // Squash merge
-    this.git(["merge", "--squash", branch]);
-
-    // Pre-merge check: run after squash (tests merged result), reset on failure
-    const checkResult = this.runPreMergeCheck();
-    if (!checkResult.passed && !checkResult.skipped) {
-      // Undo the squash merge — nothing committed yet, reset staging area
-      this.git(["reset", "--hard", "HEAD"]);
-      const cmdInfo = checkResult.command ? ` (command: ${checkResult.command})` : "";
-      const errInfo = checkResult.error ? `\n${checkResult.error}` : "";
+    // Squash merge — abort cleanly on conflict so the working tree is never
+    // left in a half-merged state (see: merge-bug-fix).
+    try {
+      this.git(["merge", "--squash", branch]);
+    } catch (mergeError) {
+      // git merge --squash exits non-zero on conflict. The working tree now
+      // has conflict markers and a dirty index. Reset to restore a clean state.
+      this.git(["reset", "--hard", "HEAD"], { allowFailure: true });
+      const msg = mergeError instanceof Error ? mergeError.message : String(mergeError);
       throw new Error(
-        `Pre-merge check failed${cmdInfo}. Merge aborted.${errInfo}`,
+        `Squash-merge of "${branch}" into "${mainBranch}" failed with conflicts. ` +
+        `Working tree has been reset to a clean state. ` +
+        `Resolve manually: git checkout ${mainBranch} && git merge --squash ${branch}\n` +
+        `Original error: ${msg}`,
       );
     }
 
@@ -564,7 +513,11 @@ export class GitServiceImpl {
     // Auto-push to remote if enabled
     if (this.prefs.auto_push === true) {
       const remote = this.prefs.remote ?? "origin";
-      this.git(["push", remote, mainBranch], { allowFailure: true });
+      const pushResult = this.git(["push", remote, mainBranch], { allowFailure: true });
+      if (pushResult === "") {
+        // push succeeded (empty stdout is normal) or failed silently
+        // Verify by checking if remote is reachable — the allowFailure handles errors
+      }
     }
 
     return {

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

@@ -6,7 +6,7 @@
  * No execution state, no hooks, no tools — the LLM does the rest.
  */
 
-import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext } from "@gsd/pi-coding-agent";
 import { showNextAction } from "../shared/next-action-ui.js";
 import { loadFile, parseRoadmap } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
@@ -611,8 +611,9 @@ export async function showSmartEntry(
       });
 
       if (choice === "plan") {
+        const secretsOutputPath = relMilestoneFile(basePath, milestoneId, "SECRETS");
         dispatchWorkflow(pi, loadPrompt("guided-plan-milestone", {
-          milestoneId, milestoneTitle,
+          milestoneId, milestoneTitle, secretsOutputPath,
         }));
       } else if (choice === "discuss") {
         dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {

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

@@ -21,8 +21,8 @@
 import type {
   ExtensionAPI,
   ExtensionContext,
-} from "@mariozechner/pi-coding-agent";
-import { createBashTool, createWriteTool, createReadTool, createEditTool } from "@mariozechner/pi-coding-agent";
+} from "@gsd/pi-coding-agent";
+import { createBashTool, createWriteTool, createReadTool, createEditTool } from "@gsd/pi-coding-agent";
 
 import { registerGSDCommand } from "./commands.js";
 import { registerWorktreeCommand, getWorktreeOriginalCwd, getActiveWorktreeName } from "./worktree-command.js";
@@ -44,11 +44,11 @@ import {
   relSliceFile, relSlicePath, relTaskFile,
   buildSliceFileName, gsdRoot,
 } from "./paths.js";
-import { Key } from "@mariozechner/pi-tui";
+import { Key } from "@gsd/pi-tui";
 import { join } from "node:path";
 import { existsSync } from "node:fs";
 import { shortcutDesc } from "../shared/terminal.js";
-import { Text } from "@mariozechner/pi-tui";
+import { Text } from "@gsd/pi-tui";
 
 // ── ASCII logo ────────────────────────────────────────────────────────────
 const GSD_LOGO_LINES = [
@@ -64,9 +64,20 @@ export default function (pi: ExtensionAPI) {
   registerGSDCommand(pi);
   registerWorktreeCommand(pi);
 
-  // ── /exit — kill the process immediately ──────────────────────────────
+  // ── /exit — graceful exit (cleanup auto-mode, save state) ──────────────
   pi.registerCommand("exit", {
-    description: "Exit GSD immediately",
+    description: "Exit GSD gracefully (saves auto-mode state)",
+    handler: async (_ctx) => {
+      // Gracefully stop auto-mode if running (saves activity log, clears locks)
+      const { stopAuto } = await import("./auto.js");
+      await stopAuto(_ctx, pi);
+      process.exit(0);
+    },
+  });
+
+  // ── /kill — immediate exit (bypass cleanup) ─────────────────────────────
+  pi.registerCommand("kill", {
+    description: "Exit GSD immediately (no cleanup)",
     handler: async (_ctx) => {
       process.exit(0);
     },
@@ -164,7 +175,7 @@ export default function (pi: ExtensionAPI) {
       const version = process.env.GSD_VERSION || "0.0.0";
 
       const logoText = GSD_LOGO_LINES.map((line) => theme.fg("accent", line)).join("\n");
-      const titleLine = `  ${theme.bold("Get Shit Done")} ${theme.fg("dim", `v${version}`)}`;
+      const titleLine = `  ${theme.bold("Get Shit Done")} ${theme.fg("dim", `v${version}`)} ${theme.fg("dim", "— Lucent")}`;
 
       const headerContent = `${logoText}\n${titleLine}`;
       ctx.ui.setHeader((_ui, _theme) => new Text(headerContent, 1, 0));

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

@@ -15,7 +15,7 @@
 
 import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
-import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionContext } from "@gsd/pi-coding-agent";
 import { gsdRoot } from "./paths.js";
 
 // ─── Types ────────────────────────────────────────────────────────────────────

package/src/resources/extensions/gsd/migrate/command.ts

@@ -9,7 +9,7 @@
  * output for GSD-2 standards compliance.
  */
 
-import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
 import { existsSync, readFileSync } from "node:fs";
 import { resolve, join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";

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

@@ -1,7 +1,7 @@
 import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { isAbsolute, join } from "node:path";
-import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import { getAgentDir } from "@gsd/pi-coding-agent";
 import type { GitPreferences } from "./git-service.ts";
 import { VALID_BRANCH_NAME } from "./git-service.ts";
 
@@ -17,11 +17,43 @@ export interface GSDSkillRule {
   avoid?: string[];
 }
 
+/**
+ * Model configuration for a single phase.
+ * Supports primary model with optional fallbacks for resilience.
+ */
+export interface GSDPhaseModelConfig {
+  /** Primary model ID (e.g., "claude-opus-4-6") */
+  model: string;
+  /** Fallback models to try in order if primary fails (e.g., rate limits, credits exhausted) */
+  fallbacks?: string[];
+}
+
+/**
+ * Legacy model config — simple string per phase.
+ * Kept for backward compatibility; will be migrated to GSDModelConfigV2 on load.
+ */
 export interface GSDModelConfig {
-  research?: string;   // e.g. "claude-sonnet-4-6"
-  planning?: string;   // e.g. "claude-opus-4-6"
-  execution?: string;  // e.g. "claude-sonnet-4-6"
-  completion?: string; // e.g. "claude-sonnet-4-6"
+  research?: string;
+  planning?: string;
+  execution?: string;
+  completion?: string;
+}
+
+/**
+ * Extended model config with per-phase fallback support.
+ * Each phase can specify a primary model and ordered fallbacks.
+ */
+export interface GSDModelConfigV2 {
+  research?: string | GSDPhaseModelConfig;
+  planning?: string | GSDPhaseModelConfig;
+  execution?: string | GSDPhaseModelConfig;
+  completion?: string | GSDPhaseModelConfig;
+}
+
+/** Normalized model selection with resolved fallbacks */
+export interface ResolvedModelConfig {
+  primary: string;
+  fallbacks: string[];
 }
 
 export type PlanningDepth = "thorough" | "standard" | "minimal";
@@ -479,26 +511,56 @@ export function resolveSkillDiscoveryMode(): SkillDiscoveryMode {
  * Returns undefined if no model preference is set for this unit type.
  */
 export function resolveModelForUnit(unitType: string): string | undefined {
+  const resolved = resolveModelWithFallbacksForUnit(unitType);
+  return resolved?.primary;
+}
+
+/**
+ * Resolve model and fallbacks for a given auto-mode unit type.
+ * Returns the primary model and ordered fallbacks, or undefined if not configured.
+ *
+ * Supports both legacy string format and extended object format:
+ * - Legacy: `planning: claude-opus-4-6`
+ * - Extended: `planning: { model: claude-opus-4-6, fallbacks: [glm-5, minimax-m2.5] }`
+ */
+export function resolveModelWithFallbacksForUnit(unitType: string): ResolvedModelConfig | undefined {
   const prefs = loadEffectiveGSDPreferences();
   if (!prefs?.preferences.models) return undefined;
-  const m = prefs.preferences.models;
+  const m = prefs.preferences.models as GSDModelConfigV2;
 
+  let phaseConfig: string | GSDPhaseModelConfig | undefined;
   switch (unitType) {
     case "research-milestone":
     case "research-slice":
-      return m.research;
+      phaseConfig = m.research;
+      break;
     case "plan-milestone":
     case "plan-slice":
     case "replan-slice":
-      return m.planning;
+      phaseConfig = m.planning;
+      break;
     case "execute-task":
-      return m.execution;
+      phaseConfig = m.execution;
+      break;
     case "complete-slice":
     case "run-uat":
-      return m.completion;
+      phaseConfig = m.completion;
+      break;
     default:
       return undefined;
   }
+
+  if (!phaseConfig) return undefined;
+
+  // Normalize: string -> { model, fallbacks: [] }
+  if (typeof phaseConfig === "string") {
+    return { primary: phaseConfig, fallbacks: [] };
+  }
+
+  return {
+    primary: phaseConfig.model,
+    fallbacks: phaseConfig.fallbacks ?? [],
+  };
 }
 
 export function resolveAutoSupervisorConfig(): AutoSupervisorConfig {

package/src/resources/extensions/gsd/prompts/guided-plan-milestone.md

@@ -21,3 +21,7 @@ Plan milestone {{milestoneId}} ("{{milestoneTitle}}"). Read `.gsd/DECISIONS.md`
 - **Don't invent risks.** If the project is straightforward, skip the proof strategy and just ship value in smart order. Not everything has major unknowns.
 - **Ship features, not proofs.** A completed slice should leave the product in a state where the new capability is actually usable through its real interface. A login flow slice ends with a working login page, not a middleware function. An API slice ends with endpoints that return real data from a real store, not hardcoded fixtures. A dashboard slice ends with a real dashboard rendering real data, not a component that renders mock props. If a slice can't ship the real thing yet because a dependency isn't built, it should ship with realistic stubs that are clearly marked for replacement — but the user-facing surface must be real.
 - **Ambition matches the milestone.** The number and depth of slices should match the milestone's ambition. A milestone promising "core platform with auth, data model, and primary user loop" should have enough slices to actually deliver all three as working features — not two proof-of-concept slices and a note that "the rest will come in the next milestone." If the milestone's context promises an outcome, the roadmap must deliver it.
+
+## Secret Forecasting
+
+After writing the roadmap, analyze the slices and their boundary maps for external service dependencies (third-party APIs, SaaS platforms, cloud providers, databases requiring credentials, OAuth providers, etc.). If this milestone requires any external API keys or secrets, read the template at `~/.gsd/agent/extensions/gsd/templates/secrets-manifest.md` for the expected format and write `{{secretsOutputPath}}` listing every predicted secret as an H3 section with the Service name, a direct Dashboard URL to the console page where the key is created, a Format hint showing what the key looks like, Status set to `pending`, and Destination (`dotenv`, `vercel`, or `convex`). Include numbered step-by-step guidance for obtaining each key. If this milestone does not require any external API keys or secrets, skip this step entirely — do not create an empty manifest.

package/src/resources/extensions/gsd/prompts/plan-milestone.md

@@ -59,6 +59,23 @@ If the roadmap has only one slice, also write the slice plan and task plans inli
 
 This eliminates a separate research-slice + plan-slice cycle when the work is straightforward.
 
+## Secret Forecasting
+
+After writing the roadmap, analyze the slices and their boundary maps for external service dependencies (third-party APIs, SaaS platforms, cloud providers, databases requiring credentials, OAuth providers, etc.).
+
+If this milestone requires any external API keys or secrets:
+
+1. Read the template at `~/.gsd/agent/extensions/gsd/templates/secrets-manifest.md` for the expected format
+2. Write `{{secretsOutputPath}}` listing every predicted secret as an H3 section with:
+   - **Service** — the external service name
+   - **Dashboard** — direct URL to the console/dashboard page where the key is created (not a generic homepage)
+   - **Format hint** — what the key looks like (e.g. `sk-...`, `ghp_...`, 40-char hex, UUID)
+   - **Status** — always `pending` during planning
+   - **Destination** — `dotenv`, `vercel`, or `convex` depending on where the key will be consumed
+   - Numbered step-by-step guidance for obtaining the key (navigate to dashboard → create project → generate key → copy)
+
+If this milestone does not require any external API keys or secrets, skip this step entirely — do not create an empty manifest.
+
 **You MUST write the file `{{outputAbsPath}}` before finishing.**
 {{skipObservabilityNote}}
 

package/src/resources/extensions/gsd/session-forensics.ts

@@ -18,7 +18,7 @@
  * - Tool results: { role: "toolResult", toolCallId: "toolu_...", toolName: "bash", isError: bool, content: ... }
  */
 
-import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { readFileSync, readdirSync, existsSync, statSync } from "node:fs";
 import { execSync } from "node:child_process";
 import { basename, join } from "node:path";
 
@@ -62,8 +62,16 @@ export interface RecoveryBriefing {
 
 // ─── JSONL Parsing ────────────────────────────────────────────────────────────
 
+/** Max bytes to parse from a JSONL source. Prevents V8 OOM on bloated activity logs. */
+const MAX_JSONL_BYTES = 10 * 1024 * 1024; // 10 MB
+
 function parseJSONL(raw: string): unknown[] {
-  return raw.trim().split("\n").map(line => {
+  // If the file is enormous, only parse the tail (most recent entries).
+  // This prevents the OOM crash path: large file → split → map → parse → OOM.
+  const source = raw.length > MAX_JSONL_BYTES
+    ? raw.slice(-MAX_JSONL_BYTES)
+    : raw;
+  return source.trim().split("\n").map(line => {
     try { return JSON.parse(line); }
     catch { return null; }
   }).filter(Boolean) as unknown[];
@@ -239,10 +247,15 @@ export function synthesizeCrashRecovery(
 
     // Primary source: surviving pi session file
     if (sessionFile && existsSync(sessionFile)) {
-      const raw = readFileSync(sessionFile, "utf-8");
-      const allEntries = parseJSONL(raw);
-      const sessionEntries = extractLastSession(allEntries);
-      trace = extractTrace(sessionEntries);
+      const stat = statSync(sessionFile, { throwIfNoEntry: false });
+      const fileSize = stat?.size ?? 0;
+      // Skip files that would blow up memory; fall back to activity log
+      if (fileSize <= MAX_JSONL_BYTES * 2) {
+        const raw = readFileSync(sessionFile, "utf-8");
+        const allEntries = parseJSONL(raw);
+        const sessionEntries = extractLastSession(allEntries);
+        trace = extractTrace(sessionEntries);
+      }
     }
 
     // Fallback: last GSD activity log

package/src/resources/extensions/gsd/skill-discovery.ts

@@ -10,7 +10,7 @@
 
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { getAgentDir } from "@mariozechner/pi-coding-agent";
+import { getAgentDir } from "@gsd/pi-coding-agent";
 
 const SKILLS_DIR = join(getAgentDir(), "skills");
 

package/src/resources/extensions/gsd/templates/secrets-manifest.md

@@ -0,0 +1,22 @@
+# Secrets Manifest
+
+<!-- This file lists predicted API keys and secrets for the milestone.
+     Each H3 section defines one secret with setup guidance.
+     The parser extracts entries by H3 heading (the env var name).
+     Bold fields: Service, Dashboard, Format hint, Status, Destination.
+     Guidance is a numbered list under each entry. -->
+
+**Milestone:** {{milestone}}
+**Generated:** {{generatedAt}}
+
+### {{ENV_VAR_NAME}}
+
+**Service:** {{serviceName}}
+**Dashboard:** {{dashboardUrl}}
+**Format hint:** {{formatHint}}
+**Status:** pending
+**Destination:** dotenv
+
+1. {{Step 1 guidance}}
+2. {{Step 2 guidance}}
+3. {{Step 3 guidance}}