@opengsd/gsd-pi 1.0.2-dev.235ebf3 → 1.0.2-dev.29398d2

package/src/resources/extensions/gsd/tests/worktree-post-create-hook.test.ts

@@ -13,7 +13,7 @@ import { mkdtempSync, mkdirSync, rmSync, existsSync, writeFileSync, readFileSync
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
-import { runWorktreePostCreateHook } from "../auto-worktree.ts";
+import { runWorktreePostCreateHook } from "../worktree-post-create-hook.ts";
 
 function makeTmpDir(): string {
   return mkdtempSync(join(tmpdir(), "gsd-wt-hook-test-"));
@@ -45,10 +45,150 @@ function writeNodeHookScript(filePath: string, code: string): void {
 test("returns null when no hook path is provided", () => {
   const src = makeTmpDir();
   const wt = makeTmpDir();
+  const previousGsdHome = process.env.GSD_HOME;
   try {
+    process.env.GSD_HOME = join(src, "empty-gsd-home");
     const result = runWorktreePostCreateHook(src, wt, undefined);
     assert.equal(result, null);
   } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(src, { recursive: true, force: true });
+    rmSync(wt, { recursive: true, force: true });
+  }
+});
+
+test("reads git.worktree_post_create from project preferences without loading auto-worktree", () => {
+  const src = makeTmpDir();
+  const wt = makeTmpDir();
+  const previousGsdHome = process.env.GSD_HOME;
+  try {
+    process.env.GSD_HOME = join(src, "empty-gsd-home");
+    const hooksDir = join(src, ".gsd", "hooks");
+    mkdirSync(hooksDir, { recursive: true });
+    writeFileSync(
+      join(src, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "git:",
+        `  worktree_post_create: ${hookPath(".gsd/hooks/post-create")}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    const hookFile = hookPath(join(hooksDir, "post-create"));
+    writeNodeHookScript(
+      hookFile,
+      `require("fs").writeFileSync(require("path").join(process.env.WORKTREE_DIR, "configured-hook-ran"), "ok");`,
+    );
+
+    const result = runWorktreePostCreateHook(src, wt);
+
+    assert.equal(result, null);
+    assert.ok(existsSync(join(wt, "configured-hook-ran")), "configured hook should run");
+  } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(src, { recursive: true, force: true });
+    rmSync(wt, { recursive: true, force: true });
+  }
+});
+
+test("prefers canonical project PREFERENCES.md over legacy lowercase preferences.md", () => {
+  const src = makeTmpDir();
+  const wt = makeTmpDir();
+  const previousGsdHome = process.env.GSD_HOME;
+  try {
+    process.env.GSD_HOME = join(src, "empty-gsd-home");
+    const hooksDir = join(src, ".gsd", "hooks");
+    mkdirSync(hooksDir, { recursive: true });
+    writeFileSync(
+      join(src, ".gsd", "preferences.md"),
+      [
+        "---",
+        "git:",
+        `  worktree_post_create: ${hookPath(".gsd/hooks/legacy")}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    writeFileSync(
+      join(src, ".gsd", "PREFERENCES.md"),
+      [
+        "---",
+        "git:",
+        `  worktree_post_create: ${hookPath(".gsd/hooks/canonical")}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    writeNodeHookScript(
+      hookPath(join(hooksDir, "canonical")),
+      `require("fs").writeFileSync(require("path").join(process.env.WORKTREE_DIR, "configured-hook-ran"), "canonical");`,
+    );
+    writeNodeHookScript(
+      hookPath(join(hooksDir, "legacy")),
+      `require("fs").writeFileSync(require("path").join(process.env.WORKTREE_DIR, "configured-hook-ran"), "legacy");`,
+    );
+
+    const result = runWorktreePostCreateHook(src, wt);
+
+    assert.equal(result, null);
+    assert.equal(readFileSync(join(wt, "configured-hook-ran"), "utf-8"), "canonical");
+  } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    rmSync(src, { recursive: true, force: true });
+    rmSync(wt, { recursive: true, force: true });
+  }
+});
+
+test("prefers canonical global PREFERENCES.md over legacy lowercase preferences.md", () => {
+  const src = makeTmpDir();
+  const wt = makeTmpDir();
+  const previousGsdHome = process.env.GSD_HOME;
+  try {
+    const gsdHomeDir = join(src, "global-gsd-home");
+    process.env.GSD_HOME = gsdHomeDir;
+    const hooksDir = join(src, ".gsd", "hooks");
+    mkdirSync(hooksDir, { recursive: true });
+    mkdirSync(gsdHomeDir, { recursive: true });
+    writeFileSync(
+      join(gsdHomeDir, "preferences.md"),
+      [
+        "---",
+        "git:",
+        `  worktree_post_create: ${hookPath(".gsd/hooks/legacy")}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    writeFileSync(
+      join(gsdHomeDir, "PREFERENCES.md"),
+      [
+        "---",
+        "git:",
+        `  worktree_post_create: ${hookPath(".gsd/hooks/canonical")}`,
+        "---",
+        "",
+      ].join("\n"),
+    );
+    writeNodeHookScript(
+      hookPath(join(hooksDir, "canonical")),
+      `require("fs").writeFileSync(require("path").join(process.env.WORKTREE_DIR, "configured-hook-ran"), "canonical");`,
+    );
+    writeNodeHookScript(
+      hookPath(join(hooksDir, "legacy")),
+      `require("fs").writeFileSync(require("path").join(process.env.WORKTREE_DIR, "configured-hook-ran"), "legacy");`,
+    );
+
+    const result = runWorktreePostCreateHook(src, wt);
+
+    assert.equal(result, null);
+    assert.equal(readFileSync(join(wt, "configured-hook-ran"), "utf-8"), "canonical");
+  } finally {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
     rmSync(src, { recursive: true, force: true });
     rmSync(wt, { recursive: true, force: true });
   }

package/src/resources/extensions/gsd/tests/zombie-gsd-state.test.ts

@@ -14,7 +14,7 @@
 
 import { test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -79,3 +79,47 @@ test("#2942: injected existsFn — milestones/ alone is enough", () => {
     p === "/proj/.gsd" || p === "/proj/.gsd/milestones";
   assert.equal(hasGsdBootstrapArtifacts("/proj/.gsd", existsFn), true);
 });
+
+test("bare /gsd routes zombie .gsd folders to project init before closeout/db checks", async (t) => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-zombie-bare-command-"));
+  t.after(() => rmSync(base, { recursive: true, force: true }));
+  mkdirSync(join(base, ".gsd", "runtime"), { recursive: true });
+
+  const previousCwd = process.cwd();
+  const previousGsdHome = process.env.GSD_HOME;
+  const previousProjectRoot = process.env.GSD_PROJECT_ROOT;
+  try {
+    process.chdir(base);
+    process.env.GSD_HOME = join(base, ".test-gsd-home");
+    delete process.env.GSD_PROJECT_ROOT;
+
+    const notifications: string[] = [];
+    const ctx = {
+      hasUI: false,
+      ui: {
+        notify: (content: unknown) => notifications.push(String(content)),
+        setStatus: () => {},
+        setWidget: () => {},
+      },
+    };
+    const { handleAutoCommand } = await import("../commands/handlers/auto.ts");
+
+    await handleAutoCommand("", ctx as any, {} as any);
+
+    assert.ok(
+      notifications.some((message) => message.includes("/gsd init did not start")),
+      "bare /gsd should route unbootstrapped zombie folders to the init wizard",
+    );
+    assert.equal(
+      existsSync(join(base, ".gsd", "gsd.db")),
+      false,
+      "bare /gsd should not create the project DB before init has bootstrapped .gsd/",
+    );
+  } finally {
+    process.chdir(previousCwd);
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    if (previousProjectRoot === undefined) delete process.env.GSD_PROJECT_ROOT;
+    else process.env.GSD_PROJECT_ROOT = previousProjectRoot;
+  }
+});

package/src/resources/extensions/gsd/tools/complete-task.ts

@@ -173,6 +173,15 @@ export async function handleCompleteTask(
   if (!params.milestoneId || typeof params.milestoneId !== "string" || params.milestoneId.trim() === "") {
     return { error: "milestoneId is required and must be a non-empty string" };
   }
+  if (!params.oneLiner || typeof params.oneLiner !== "string" || params.oneLiner.trim() === "") {
+    return { error: "oneLiner is required and must be a non-empty string" };
+  }
+  if (!params.narrative || typeof params.narrative !== "string" || params.narrative.trim() === "") {
+    return { error: "narrative is required and must be a non-empty string" };
+  }
+  if (!params.verification || typeof params.verification !== "string" || params.verification.trim() === "") {
+    return { error: "verification is required and must be a non-empty string" };
+  }
 
   const artifactBasePath = resolveCanonicalMilestoneRoot(basePath, params.milestoneId);
 

package/src/resources/extensions/gsd/tools/workflow-tool-executors.ts

@@ -306,7 +306,7 @@ export interface TaskCompleteParams {
   milestoneId: string;
   oneLiner: string;
   narrative: string;
-  verification: string;
+  verification?: string;
   deviations?: string;
   knownIssues?: string;
   keyFiles?: string[];
@@ -315,6 +315,40 @@ export interface TaskCompleteParams {
   verificationEvidence?: VerificationEvidenceInput[];
 }
 
+type NormalizedVerificationEvidence = {
+  command: string;
+  exitCode: number;
+  verdict: string;
+  durationMs: number;
+};
+
+function normalizeVerificationEvidence(
+  evidence: VerificationEvidenceInput[] | undefined,
+): NormalizedVerificationEvidence[] {
+  return (evidence ?? []).map((entry) =>
+    typeof entry === "string"
+      ? { command: entry, exitCode: -1, verdict: "unknown (coerced from string)", durationMs: 0 }
+      : entry,
+  );
+}
+
+function deriveVerificationSummary(
+  evidence: NormalizedVerificationEvidence[],
+): string | null {
+  if (evidence.length === 0) return null;
+
+  const rendered = evidence.slice(0, 3).map((entry) => {
+    const command = entry.command.trim() || "(unspecified command)";
+    const verdict = entry.verdict.trim() || "recorded";
+    return `\`${command}\` exited ${entry.exitCode} (${verdict})`;
+  });
+  const suffix = evidence.length > rendered.length
+    ? `; ${evidence.length - rendered.length} more check(s) recorded`
+    : "";
+
+  return `Verification evidence recorded: ${rendered.join("; ")}${suffix}.`;
+}
+
 export type CompleteMilestoneExecutorParams = Partial<CompleteMilestoneParams> & Record<string, unknown>;
 export type SliceCompleteExecutorParams = CompleteSliceParams;
 export type PlanMilestoneExecutorParams = PlanMilestoneParams;
@@ -350,9 +384,27 @@ export async function executeTaskComplete(
   }
   try {
     const coerced = { ...params };
-    coerced.verificationEvidence = (params.verificationEvidence ?? []).map((v) =>
-      typeof v === "string" ? { command: v, exitCode: -1, verdict: "unknown (coerced from string)", durationMs: 0 } : v,
-    );
+    const verificationEvidence = normalizeVerificationEvidence(params.verificationEvidence);
+    coerced.verificationEvidence = verificationEvidence;
+
+    const verification = typeof params.verification === "string" ? params.verification.trim() : "";
+    if (verification.length === 0) {
+      const derived = deriveVerificationSummary(verificationEvidence);
+      if (derived) {
+        coerced.verification = derived;
+      } else if (params.blockerDiscovered === true) {
+        coerced.verification = "Not run: blocker discovered before verification.";
+      } else {
+        return {
+          content: [{
+            type: "text",
+            text: "Error completing task: verification is required unless verificationEvidence is provided or blockerDiscovered is true.",
+          }],
+          details: { operation: "complete_task", error: "verification_required" },
+          isError: true,
+        };
+      }
+    }
 
     const result = await handleCompleteTask(coerced as any, basePath);
     if ("error" in result) {

package/src/resources/extensions/gsd/worktree-lifecycle.ts

@@ -216,6 +216,10 @@ export type EnterResult =
       cause?: unknown;
     };
 
+export interface StrandedMilestoneAdoptionOptions {
+  mode: "worktree" | "branch";
+}
+
 export type ExitResult =
   | { ok: true; merged: boolean; codeFilesChanged: boolean }
   | { ok: false; reason: "merge-conflict" | "teardown-failed"; cause?: unknown };
@@ -237,6 +241,8 @@ export interface MergeContext {
    */
   worktreeBasePath: string;
   milestoneId: string;
+  /** Temporary override used while recovering stranded work. */
+  isolationModeOverride?: "worktree" | "branch" | "none";
   /**
    * When true, `mergeMilestoneStandalone` returns `{ merged: false,
    * mode: "skipped" }` immediately (mirrors the single-loop guard). Default
@@ -533,6 +539,7 @@ export function _enterMilestoneCore(
   deps: WorktreeLifecycleDeps,
   milestoneId: string,
   ctx: NotifyCtx,
+  opts: { modeOverride?: "worktree" | "branch" } = {},
 ): EnterResult {
   if (!isValidMilestoneId(milestoneId)) {
     debugLog("WorktreeLifecycle", {
@@ -653,7 +660,7 @@ export function _enterMilestoneCore(
   // Handles the case where originalBasePath is falsy and basePath is itself
   // a worktree path — prevents double-nested worktree paths (#3729).
   const basePath = resolveWorktreeProjectRoot(s.basePath, s.originalBasePath);
-  const mode = getIsolationMode(basePath);
+  const mode = opts.modeOverride ?? getIsolationMode(basePath);
 
   if (s.isolationDegraded) {
     if (mode === "worktree") {
@@ -1298,7 +1305,9 @@ export function mergeMilestoneStandalone(
     };
   }
 
-  const mode = getIsolationMode(originalBasePath || worktreeBasePath);
+  const mode =
+    mctx.isolationModeOverride ??
+    getIsolationMode(originalBasePath || worktreeBasePath);
   debugLog("WorktreeLifecycle", {
     action: "mergeAndExit",
     milestoneId,
@@ -1637,6 +1646,7 @@ export class WorktreeLifecycle {
         originalBasePath: this.s.originalBasePath,
         worktreeBasePath: this.s.basePath,
         milestoneId,
+        isolationModeOverride: this.s.strandedRecoveryIsolationMode ?? undefined,
         isolationDegraded: this.s.isolationDegraded,
         notify: ctx.notify,
       });
@@ -1740,6 +1750,7 @@ export class WorktreeLifecycle {
       // Rebuild GitService after merge (branch HEAD changed)
       rebuildGitService(this.s, this.deps);
     }
+    this.s.strandedRecoveryIsolationMode = null;
     return result;
   }
 
@@ -1876,6 +1887,30 @@ export class WorktreeLifecycle {
     this.s.basePath = resolvePausedResumeBasePath(base, persistedWorktreePath);
   }
 
+  /**
+   * Adopt in-progress stranded work during bootstrap.
+   *
+   * Unlike completed-orphan recovery, this does not merge, delete, or commit.
+   * It only moves the live session onto the branch/worktree proven by the
+   * audit evidence, while preserving that mode for the eventual merge.
+   */
+  adoptStrandedMilestone(
+    milestoneId: string,
+    base: string,
+    ctx: NotifyCtx,
+    opts: StrandedMilestoneAdoptionOptions,
+  ): EnterResult {
+    this.adoptSessionRoot(base);
+    this.s.strandedRecoveryIsolationMode = opts.mode;
+    const result = _enterMilestoneCore(this.s, this.deps, milestoneId, ctx, {
+      modeOverride: opts.mode,
+    });
+    if (!result.ok) {
+      this.s.strandedRecoveryIsolationMode = null;
+    }
+    return result;
+  }
+
   /**
    * Adopt an orphan worktree for a bootstrap-time merge (ADR-016 phase 2 / B4,
    * issue #5622).

package/src/resources/extensions/gsd/worktree-post-create-hook.ts

@@ -0,0 +1,127 @@
+// Project/App: gsd-pi
+// File Purpose: Lightweight worktree post-create hook runner.
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+
+import { parse as parseYaml } from "yaml";
+
+import { gsdHome } from "./gsd-home.js";
+import { gsdRoot } from "./paths.js";
+
+function readPreferencesObject(path: string): Record<string, unknown> | null {
+  if (!existsSync(path)) return null;
+
+  const content = readFileSync(path, "utf-8");
+  try {
+    const startMarker = content.startsWith("---\r\n") ? "---\r\n" : "---\n";
+    if (content.startsWith(startMarker)) {
+      const searchStart = startMarker.length;
+      const endIdx = content.indexOf("\n---", searchStart);
+      if (endIdx === -1) return null;
+
+      const parsed = parseYaml(content.slice(searchStart, endIdx).replace(/\r/g, ""));
+      return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+        ? parsed as Record<string, unknown>
+        : null;
+    }
+
+    const gitLines: string[] = [];
+    let inGitSection = false;
+    for (const rawLine of content.split("\n")) {
+      const line = rawLine.replace(/\r$/, "");
+      const heading = line.match(/^##\s+(.+)$/);
+      if (heading) {
+        inGitSection = heading[1].trim().toLowerCase().replace(/\s+/g, "_") === "git";
+        continue;
+      }
+      if (inGitSection && line.trim() && !line.trimStart().startsWith("#")) {
+        gitLines.push(line.replace(/^\s*-\s*/, ""));
+      }
+    }
+    if (gitLines.length === 0) return null;
+
+    const parsed = parseYaml(gitLines.join("\n"));
+    return parsed && typeof parsed === "object" && !Array.isArray(parsed)
+      ? { git: parsed as Record<string, unknown> }
+      : null;
+  } catch {
+    return null;
+  }
+}
+
+function extractHookPath(preferences: Record<string, unknown> | null): string | null {
+  const git = preferences?.git;
+  if (!git || typeof git !== "object" || Array.isArray(git)) return null;
+  const hookPath = (git as Record<string, unknown>).worktree_post_create;
+  return typeof hookPath === "string" && hookPath.trim() ? hookPath : null;
+}
+
+function resolveConfiguredHookPath(sourceDir: string): string | null {
+  const paths = [
+    join(homedir(), ".pi", "agent", "gsd-preferences.md"),
+    join(gsdHome(), "preferences.md"),
+    join(gsdHome(), "PREFERENCES.md"),
+    join(gsdRoot(sourceDir), "preferences.md"),
+    join(gsdRoot(sourceDir), "PREFERENCES.md"),
+  ];
+
+  let hookPath: string | null = null;
+  for (const path of paths) {
+    hookPath = extractHookPath(readPreferencesObject(path)) ?? hookPath;
+  }
+  return hookPath;
+}
+
+/**
+ * Run the user-configured post-create hook script after worktree creation.
+ * The script receives SOURCE_DIR and WORKTREE_DIR as environment variables.
+ * Failure is non-fatal -- returns the error message or null on success.
+ *
+ * Reads git.worktree_post_create from effective global/project preferences
+ * unless hookPath is provided directly.
+ */
+export function runWorktreePostCreateHook(
+  sourceDir: string,
+  worktreeDir: string,
+  hookPath?: string,
+): string | null {
+  if (hookPath === undefined) {
+    hookPath = resolveConfiguredHookPath(sourceDir) ?? undefined;
+  }
+  if (!hookPath) return null;
+
+  let resolved = isAbsolute(hookPath) ? hookPath : join(sourceDir, hookPath);
+  if (!existsSync(resolved)) {
+    return `Worktree post-create hook not found: ${resolved}`;
+  }
+  if (process.platform === "win32") {
+    try {
+      resolved = realpathSync.native(resolved);
+    } catch {
+      // Keep the original path; the exec error below will include the failure.
+    }
+  }
+
+  try {
+    const needsShell = process.platform === "win32" && /\.(bat|cmd)$/i.test(resolved);
+    execFileSync(resolved, [], {
+      cwd: worktreeDir,
+      env: {
+        ...process.env,
+        SOURCE_DIR: sourceDir,
+        WORKTREE_DIR: worktreeDir,
+      },
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+      timeout: 30_000,
+      shell: needsShell,
+    });
+    return null;
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return `Worktree post-create hook failed: ${msg}`;
+  }
+}

package/src/resources/extensions/search-the-web/native-search.ts

@@ -16,6 +16,47 @@ export const CUSTOM_SEARCH_TOOL_NAMES = ["search-the-web", "search_and_read", "g
 
 /** Thinking block types that require signature validation by the API */
 const THINKING_TYPES = new Set(["thinking", "redacted_thinking"]);
+const NATIVE_SERVER_TOOL_USE_TYPES = new Set([
+  "server_tool_use",
+  "serverToolUse",
+]);
+const NATIVE_WEB_SEARCH_RESULT_TYPES = new Set([
+  "web_search_tool_result",
+  "webSearchResult",
+]);
+
+function nativeServerToolId(block: any): string | undefined {
+  if (!NATIVE_SERVER_TOOL_USE_TYPES.has(block?.type)) return undefined;
+  return typeof block.id === "string" ? block.id : undefined;
+}
+
+function nativeWebSearchResultId(block: any): string | undefined {
+  if (!NATIVE_WEB_SEARCH_RESULT_TYPES.has(block?.type)) return undefined;
+  const id = block.type === "webSearchResult" ? block.toolUseId : block.tool_use_id;
+  return typeof id === "string" ? id : undefined;
+}
+
+function hasCompleteNativeServerToolReplay(content: any[]): boolean {
+  const pendingToolUseIds = new Set<string>();
+  let sawNativeServerToolUse = false;
+
+  for (const block of content) {
+    const toolUseId = nativeServerToolId(block);
+    if (toolUseId !== undefined) {
+      if (pendingToolUseIds.has(toolUseId)) return false;
+      sawNativeServerToolUse = true;
+      pendingToolUseIds.add(toolUseId);
+      continue;
+    }
+
+    const resultId = nativeWebSearchResultId(block);
+    if (resultId !== undefined) {
+      if (!pendingToolUseIds.delete(resultId)) return false;
+    }
+  }
+
+  return sawNativeServerToolUse && pendingToolUseIds.size === 0;
+}
 
 /**
  * Providers whose Anthropic-Messages endpoint is known to accept the native
@@ -36,6 +77,11 @@ const NATIVE_WEB_SEARCH_PROVIDERS = new Set([
   "vercel-ai-gateway",
 ]);
 
+function looksLikeAnthropicModelName(modelName: string): boolean {
+  const normalized = modelName.trim().toLowerCase();
+  return normalized.startsWith("claude-") || normalized.startsWith("anthropic/claude-");
+}
+
 /**
  * True when the model is an Anthropic-shaped transport AND the provider is
  * known to accept the native `web_search_20250305` tool. Gate both on api
@@ -89,11 +135,10 @@ export interface NativeSearchPI {
  * those blocks. The Anthropic API detects the modification and rejects the
  * request with "thinking blocks cannot be modified."
  *
- * Fix: Remove thinking blocks from all assistant messages in the history.
- * In Anthropic's Messages API, the messages array always ends with a user
- * message, so every assistant message is from a previous turn that has been
- * through a store/replay cycle. The model generates fresh thinking for the
- * current turn regardless.
+ * Fix: Remove thinking blocks only from assistant messages that do not carry
+ * native server-tool blocks. Complete native server-tool histories can be
+ * replayed as-is; stripping thinking from those messages is itself a latest
+ * assistant message modification.
  */
 export function stripThinkingFromHistory(
   messages: Array<Record<string, unknown>>
@@ -103,6 +148,9 @@ export function stripThinkingFromHistory(
 
     const content = msg.content;
     if (!Array.isArray(content)) continue;
+    if (hasCompleteNativeServerToolReplay(content)) {
+      continue;
+    }
 
     msg.content = content.filter(
       (block: any) => !THINKING_TYPES.has(block?.type)
@@ -180,6 +228,8 @@ export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic:
     // The model name heuristic is needed for session restores where
     // modelsAreEqual suppresses model_select AND the SDK doesn't pass model.
     const eventModel = event.model as { provider?: string; api?: string } | undefined;
+    const payloadModelName = typeof payload.model === "string" ? payload.model : "";
+    const payloadLooksAnthropic = payloadModelName ? looksLikeAnthropicModelName(payloadModelName) : undefined;
     let isAnthropic: boolean;
     if (eventModel?.api || eventModel?.provider) {
       // Preferred path: gate on api shape + provider allowlist. Both fields
@@ -188,12 +238,14 @@ export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic:
       // (#444 regression) or minimax-served Claude-compat as Anthropic (#4492).
       isAnthropic = supportsNativeWebSearch(eventModel);
     } else if (modelSelectFired) {
-      isAnthropic = isAnthropicProvider;
+      // The model_select flag can be stale if the next request omits event.model
+      // after a provider switch. A concrete non-Claude payload must win so an
+      // Anthropic-only tool never leaks into OpenAI Responses requests.
+      isAnthropic = isAnthropicProvider && payloadLooksAnthropic !== false;
     } else {
       // Last resort: session-restore paths where the SDK doesn't pass model.
       // The model-name prefix is best-effort and assumes direct Anthropic.
-      const modelName = typeof payload.model === "string" ? payload.model : "";
-      isAnthropic = modelName.startsWith("claude-");
+      isAnthropic = payloadLooksAnthropic === true;
     }
     if (!isAnthropic) return;
 

package/src/resources/shared/package-manager-detection.ts

@@ -0,0 +1,39 @@
+import { homedir } from 'node:os'
+import { join, resolve as resolvePath, sep } from 'node:path'
+
+function hasPnpmPath(value: string | undefined): boolean {
+  if (!value) return false
+  const normalized = value.replace(/\\/g, '/').toLowerCase()
+  return (
+    normalized.includes('/.pnpm/') ||
+    normalized.endsWith('/pnpm') ||
+    normalized.endsWith('/pnpm.cjs') ||
+    normalized.endsWith('/pnpm.js')
+  )
+}
+
+function pathStartsWith(pathValue: string | undefined, dir: string): boolean {
+  if (!pathValue) return false
+  const resolvedPath = resolvePath(pathValue)
+  const resolvedDir = resolvePath(dir)
+  return resolvedPath === resolvedDir || resolvedPath.startsWith(resolvedDir + sep)
+}
+
+// Shared by update-check.ts and gsd command handlers. The JS installer keeps a
+// parallel copy because it runs before TypeScript output exists.
+export function isPnpmInstall(
+  argv1: string | undefined = process.argv[1],
+  env: NodeJS.ProcessEnv = process.env,
+): boolean {
+  if (env.npm_config_user_agent?.startsWith('pnpm/')) return true
+  if (hasPnpmPath(env.npm_execpath)) return true
+  if (hasPnpmPath(argv1)) return true
+  if (!argv1) return false
+
+  const pnpmBinDirs: string[] = []
+  if (env.PNPM_HOME) pnpmBinDirs.push(env.PNPM_HOME)
+  pnpmBinDirs.push(join(homedir(), 'Library', 'pnpm'))
+  pnpmBinDirs.push(join(homedir(), '.local', 'share', 'pnpm'))
+
+  return pnpmBinDirs.some((dir) => pathStartsWith(argv1, dir) || pathStartsWith(env.npm_execpath, dir))
+}