gsd-pi 2.58.0-dev.778d6ac → 2.58.0-dev.d63175c

package/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -6,9 +6,8 @@ import { isToolCallEventType } from "@gsd/pi-coding-agent";
 import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolveSlicePath } from "../paths.js";
 import { buildBeforeAgentStartResult } from "./system-context.js";
 import { handleAgentEnd } from "./agent-end-recovery.js";
-import { clearDiscussionFlowState, isDepthVerified, isQueuePhaseActive, markDepthVerified, resetWriteGateState, shouldBlockContextWrite, shouldBlockQueueExecution } from "./write-gate.js";
+import { clearDiscussionFlowState, isDepthVerified, isQueuePhaseActive, markDepthVerified, resetWriteGateState, shouldBlockContextWrite } from "./write-gate.js";
 import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from "../write-intercept.js";
-import { cleanupQuickBranch } from "../quick.js";
 import { getDiscussionMilestoneId } from "../guided-flow.js";
 import { loadToolApiKeys } from "../commands-config.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
@@ -17,6 +16,8 @@ import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markTool
 import { isParallelActive, shutdownParallel } from "../parallel-orchestrator.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { saveActivityLog } from "../activity-log.js";
+import { startRtkStatusUpdates, stopRtkStatusUpdates } from "../rtk-status.js";
+import { rewriteCommandWithRtk } from "../../shared/rtk.js";
 
 // Skip the welcome screen on the very first session_start — cli.ts already
 // printed it before the TUI launched. Only re-print on /clear (subsequent sessions).
@@ -28,10 +29,19 @@ async function syncServiceTierStatus(ctx: ExtensionContext): Promise<void> {
 }
 
 export function registerHooks(pi: ExtensionAPI): void {
+  // Route all agent bash tool commands through RTK rewrite when opted in.
+  // This is a no-op when RTK is disabled or not installed.
+  pi.on("bash_transform", async (event) => {
+    const rewritten = rewriteCommandWithRtk(event.command);
+    if (rewritten === event.command) return undefined;
+    return { command: rewritten };
+  });
+
   pi.on("session_start", async (_event, ctx) => {
     resetWriteGateState();
     resetToolCallLoopGuard();
     await syncServiceTierStatus(ctx);
+    startRtkStatusUpdates(ctx);
 
     // Apply show_token_cost preference (#1515)
     try {
@@ -76,6 +86,11 @@ export function registerHooks(pi: ExtensionAPI): void {
     clearDiscussionFlowState();
     await syncServiceTierStatus(ctx);
     loadToolApiKeys();
+    startRtkStatusUpdates(ctx);
+  });
+
+  pi.on("session_fork", async (_event, ctx) => {
+    startRtkStatusUpdates(ctx);
   });
 
   pi.on("before_agent_start", async (event, ctx: ExtensionContext) => {
@@ -87,17 +102,6 @@ export function registerHooks(pi: ExtensionAPI): void {
     await handleAgentEnd(pi, event, ctx);
   });
 
-  // Squash-merge quick-task branch back to the original branch after the
-  // agent turn completes (#2668). cleanupQuickBranch is a no-op when no
-  // quick-return state is pending, so this is safe to call on every turn.
-  pi.on("turn_end", async () => {
-    try {
-      cleanupQuickBranch();
-    } catch {
-      // Best-effort: don't break the turn lifecycle if cleanup fails.
-    }
-  });
-
   pi.on("session_before_compact", async () => {
     if (isAutoActive() || isAutoPaused()) {
       return { cancel: true };
@@ -135,6 +139,7 @@ export function registerHooks(pi: ExtensionAPI): void {
   });
 
   pi.on("session_shutdown", async (_event, ctx: ExtensionContext) => {
+    stopRtkStatusUpdates(ctx);
     if (isParallelActive()) {
       try {
         await shutdownParallel(process.cwd());
@@ -156,23 +161,6 @@ export function registerHooks(pi: ExtensionAPI): void {
       return { block: true, reason: loopCheck.reason };
     }
 
-    // ── Queue-mode execution guard (#2545): block source-code mutations ──
-    // When /gsd queue is active, the agent should only create milestones,
-    // not execute work. Block write/edit to non-.gsd/ paths and bash commands
-    // that would modify files.
-    if (isQueuePhaseActive()) {
-      let queueInput = "";
-      if (isToolCallEventType("write", event)) {
-        queueInput = event.input.path;
-      } else if (isToolCallEventType("edit", event)) {
-        queueInput = event.input.path;
-      } else if (isToolCallEventType("bash", event)) {
-        queueInput = event.input.command;
-      }
-      const queueGuard = shouldBlockQueueExecution(event.toolName, queueInput, true);
-      if (queueGuard.block) return queueGuard;
-    }
-
     // ── Single-writer engine: block direct writes to STATE.md ──────────
     // Covers write, edit, and bash tools to prevent bypass vectors.
     if (isToolCallEventType("write", event)) {
@@ -257,7 +245,7 @@ export function registerHooks(pi: ExtensionAPI): void {
 
   pi.on("tool_execution_start", async (event) => {
     if (!isAutoActive()) return;
-    markToolStart(event.toolCallId);
+    markToolStart(event.toolCallId, event.toolName);
   });
 
   pi.on("tool_execution_end", async (event) => {

package/src/resources/extensions/gsd/bootstrap/system-context.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { existsSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 
@@ -6,7 +6,6 @@ import type { ExtensionContext } from "@gsd/pi-coding-agent";
 
 import { debugTime } from "../debug-logger.js";
 import { loadPrompt } from "../prompt-loader.js";
-import { readForensicsMarker } from "../forensics.js";
 import { resolveAllSkillReferences, renderPreferencesForSystemPrompt, loadEffectiveGSDPreferences } from "../preferences.js";
 import { resolveGsdRootFile, resolveSliceFile, resolveSlicePath, resolveTaskFile, resolveTaskFiles, resolveTasksDir, relSliceFile, relSlicePath, relTaskFile } from "../paths.js";
 import { hasSkillSnapshot, detectNewSkills, formatSkillsXml } from "../skill-discovery.js";
@@ -98,30 +97,27 @@ export async function buildBeforeAgentStartResult(
   warnDeprecatedAgentInstructions();
 
   const injection = await buildGuidedExecuteContextInjection(event.prompt, process.cwd());
-
-  // Re-inject forensics context on follow-up turns (#2941)
-  const forensicsInjection = !injection ? buildForensicsContextInjection(process.cwd()) : null;
-
   const worktreeBlock = buildWorktreeContextBlock();
   const fullSystem = `${event.systemPrompt}\n\n[SYSTEM CONTEXT — GSD]\n\n${systemContent}${preferenceBlock}${knowledgeBlock}${memoryBlock}${newSkillsBlock}${worktreeBlock}`;
 
   stopContextTimer({
     systemPromptSize: fullSystem.length,
-    injectionSize: injection?.length ?? forensicsInjection?.length ?? 0,
+    injectionSize: injection?.length ?? 0,
     hasPreferences: preferenceBlock.length > 0,
     hasNewSkills: newSkillsBlock.length > 0,
   });
 
-  // Determine which context message to inject (guided execute takes priority)
-  const contextMessage = injection
-    ? { customType: "gsd-guided-context", content: injection, display: false as const }
-    : forensicsInjection
-      ? { customType: "gsd-forensics", content: forensicsInjection, display: false as const }
-      : null;
-
   return {
     systemPrompt: fullSystem,
-    ...(contextMessage ? { message: contextMessage } : {}),
+    ...(injection
+      ? {
+        message: {
+          customType: "gsd-guided-context",
+          content: injection,
+          display: false as const,
+        },
+      }
+      : {}),
   };
 }
 
@@ -379,38 +375,3 @@ function oneLine(text: string): string {
   return text.replace(/\s+/g, " ").trim();
 }
 
-// ─── Forensics Context Re-injection (#2941) ──────────────────────────────────
-
-/**
- * Check for an active forensics session and return the prompt content
- * so it can be re-injected on follow-up turns.
- */
-function buildForensicsContextInjection(basePath: string): string | null {
-  const marker = readForensicsMarker(basePath);
-  if (!marker) return null;
-
-  // Expire markers older than 2 hours to avoid stale context
-  const age = Date.now() - new Date(marker.createdAt).getTime();
-  if (age > 2 * 60 * 60 * 1000) {
-    clearForensicsMarker(basePath);
-    return null;
-  }
-
-  return marker.promptContent;
-}
-
-/**
- * Remove the active forensics marker file, e.g. when the investigation
- * is complete or the session expires.
- */
-export function clearForensicsMarker(basePath: string): void {
-  const markerPath = join(basePath, ".gsd", "runtime", "active-forensics.json");
-  if (existsSync(markerPath)) {
-    try {
-      unlinkSync(markerPath);
-    } catch {
-      // non-fatal
-    }
-  }
-}
-

package/src/resources/extensions/gsd/bootstrap/write-gate.ts

@@ -1,31 +1,5 @@
 const MILESTONE_CONTEXT_RE = /M\d+(?:-[a-z0-9]{6})?-CONTEXT\.md$/;
 
-/**
- * Path segment that identifies .gsd/ planning artifacts.
- * Writes to these paths are allowed during queue mode.
- */
-const GSD_DIR_RE = /(^|[/\\])\.gsd([/\\]|$)/;
-
-/**
- * Read-only tool names that are always safe during queue mode.
- */
-const QUEUE_SAFE_TOOLS = new Set([
-  "read", "grep", "find", "ls", "glob",
-  // Discussion & planning tools
-  "ask_user_questions",
-  "gsd_milestone_generate_id",
-  "gsd_summary_save",
-  // Web research tools used during queue discussion
-  "search-the-web", "resolve_library", "get_library_docs", "fetch_page",
-  "search_and_read",
-]);
-
-/**
- * Bash commands that are read-only / investigative — safe during queue mode.
- * Matches the leading command in a bash invocation.
- */
-const BASH_READ_ONLY_RE = /^\s*(cat|head|tail|less|more|wc|file|stat|du|df|which|type|echo|printf|ls|find|grep|rg|awk|sed\b(?!.*-i)|sort|uniq|diff|comm|tr|cut|tee\s+-a\s+\/dev\/null|git\s+(log|show|diff|status|branch|tag|remote|rev-parse|ls-files|blame|shortlog|describe|stash\s+list|config\s+--get|cat-file)|gh\s+(issue|pr|api|repo|release)\s+(view|list|diff|status|checks)|mkdir\s+-p\s+\.gsd|rtk\s)/;
-
 let depthVerificationDone = false;
 let activeQueuePhase = false;
 
@@ -75,52 +49,3 @@ export function shouldBlockContextWrite(
   };
 }
 
-/**
- * Queue-mode execution guard (#2545).
- *
- * When the queue phase is active, the agent should only create planning
- * artifacts (milestones, CONTEXT.md, QUEUE.md, etc.) — never execute work.
- * This function blocks write/edit/bash tool calls that would modify source
- * code outside of .gsd/.
- *
- * @param toolName  The tool being called (write, edit, bash, etc.)
- * @param input     For write/edit: the file path. For bash: the command string.
- * @param queuePhaseActive  Whether the queue phase is currently active.
- * @returns { block, reason } — block=true if the call should be rejected.
- */
-export function shouldBlockQueueExecution(
-  toolName: string,
-  input: string,
-  queuePhaseActive: boolean,
-): { block: boolean; reason?: string } {
-  if (!queuePhaseActive) return { block: false };
-
-  // Always-safe tools (read-only, discussion, planning)
-  if (QUEUE_SAFE_TOOLS.has(toolName)) return { block: false };
-
-  // write/edit — allow if targeting .gsd/ planning artifacts
-  if (toolName === "write" || toolName === "edit") {
-    if (GSD_DIR_RE.test(input)) return { block: false };
-    return {
-      block: true,
-      reason: `Blocked: /gsd queue is a planning tool — it creates milestones, not executes work. ` +
-        `Cannot ${toolName} to "${input}" during queue mode. ` +
-        `Write CONTEXT.md files and update PROJECT.md/QUEUE.md instead.`,
-    };
-  }
-
-  // bash — allow read-only/investigative commands, block everything else
-  if (toolName === "bash") {
-    if (BASH_READ_ONLY_RE.test(input)) return { block: false };
-    return {
-      block: true,
-      reason: `Blocked: /gsd queue is a planning tool — it creates milestones, not executes work. ` +
-        `Cannot run "${input.slice(0, 80)}${input.length > 80 ? "…" : ""}" during queue mode. ` +
-        `Use read-only commands (cat, grep, git log, etc.) to investigate, then write planning artifacts.`,
-    };
-  }
-
-  // Unknown tools — allow by default (custom extension tools, etc.)
-  return { block: false };
-}
-

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

@@ -26,7 +26,6 @@ export interface CaptureEntry {
   resolution?: string;
   rationale?: string;
   resolvedAt?: string;
-  resolvedInMilestone?: string;
   executed?: boolean;
 }
 
@@ -177,7 +176,6 @@ export function markCaptureResolved(
   classification: Classification,
   resolution: string,
   rationale: string,
-  milestoneId?: string,
 ): void {
   const filePath = resolveCapturesPath(basePath);
   if (!existsSync(filePath)) return;
@@ -208,17 +206,13 @@ export function markCaptureResolved(
     `**Rationale:** ${rationale}`,
     `**Resolved:** ${resolvedAt}`,
   ];
-  if (milestoneId) {
-    newFields.push(`**Milestone:** ${milestoneId}`);
-  }
 
-  // Remove any existing classification/resolution/rationale/resolved/milestone fields
+  // Remove any existing classification/resolution/rationale/resolved fields
   // (in case of re-triage)
   section = section.replace(/\*\*Classification:\*\*\s*.+\n?/g, "");
   section = section.replace(/\*\*Resolution:\*\*\s*.+\n?/g, "");
   section = section.replace(/\*\*Rationale:\*\*\s*.+\n?/g, "");
   section = section.replace(/\*\*Resolved:\*\*\s*.+\n?/g, "");
-  section = section.replace(/\*\*Milestone:\*\*\s*.+\n?/g, "");
 
   // Add new fields after Status line
   section = section.trimEnd() + "\n" + newFields.join("\n") + "\n";
@@ -261,68 +255,16 @@ export function markCaptureExecuted(basePath: string, captureId: string): void {
  * Load resolved captures that have actionable classifications (inject, replan,
  * quick-task) but have NOT yet been executed.
  * These are captures whose resolutions need to be carried out.
- *
- * When `currentMilestoneId` is provided, captures resolved in a *different*
- * milestone are treated as stale and excluded.  This prevents quick-task
- * captures from a prior milestone re-executing after the underlying issues
- * were already fixed by planned milestone work (#2872).
- *
- * Captures that have no `resolvedInMilestone` (legacy captures resolved before
- * this field was introduced) are always included for backward compatibility.
  */
-export function loadActionableCaptures(basePath: string, currentMilestoneId?: string): CaptureEntry[] {
+export function loadActionableCaptures(basePath: string): CaptureEntry[] {
   return loadAllCaptures(basePath).filter(
     c =>
       c.status === "resolved" &&
       !c.executed &&
       (c.classification === "inject" ||
         c.classification === "replan" ||
-        c.classification === "quick-task") &&
-      // Staleness gate: exclude captures resolved in a different milestone (#2872)
-      (!currentMilestoneId ||
-        !c.resolvedInMilestone ||
-        c.resolvedInMilestone === currentMilestoneId),
-  );
-}
-
-/**
- * Retroactively stamp a capture with a milestone ID.
- *
- * Used by executeTriageResolutions() as a safety net when the triage LLM
- * resolves a capture without writing the **Milestone:** field.  This ensures
- * the staleness gate in loadActionableCaptures() works correctly even for
- * captures resolved before the prompt was updated (#2872).
- */
-export function stampCaptureMilestone(basePath: string, captureId: string, milestoneId: string): void {
-  const filePath = resolveCapturesPath(basePath);
-  if (!existsSync(filePath)) return;
-
-  const content = readFileSync(filePath, "utf-8");
-
-  const sectionRegex = new RegExp(
-    `(### ${escapeRegex(captureId)}\\n(?:(?!### ).)*?)(?=### |$)`,
-    "s",
+        c.classification === "quick-task"),
   );
-  const match = sectionRegex.exec(content);
-  if (!match) return;
-
-  let section = match[1];
-
-  // Only stamp if not already present
-  if (/\*\*Milestone:\*\*/.test(section)) return;
-
-  // Insert after the Resolved field (or at end of section)
-  const resolvedFieldEnd = section.search(/\*\*Resolved:\*\*\s*.+\n?/);
-  if (resolvedFieldEnd !== -1) {
-    const resolvedMatch = section.match(/\*\*Resolved:\*\*\s*.+\n?/);
-    const insertPos = resolvedFieldEnd + (resolvedMatch?.[0]?.length ?? 0);
-    section = section.slice(0, insertPos) + `**Milestone:** ${milestoneId}\n` + section.slice(insertPos);
-  } else {
-    section = section.trimEnd() + "\n" + `**Milestone:** ${milestoneId}` + "\n";
-  }
-
-  const updated = content.replace(sectionRegex, section);
-  writeFileSync(filePath, updated, "utf-8");
 }
 
 // ─── Parser ───────────────────────────────────────────────────────────────────
@@ -349,7 +291,6 @@ function parseCapturesContent(content: string): CaptureEntry[] {
     const resolution = extractBoldField(body, "Resolution");
     const rationale = extractBoldField(body, "Rationale");
     const resolvedAt = extractBoldField(body, "Resolved");
-    const milestoneId = extractBoldField(body, "Milestone");
     const executedAt = extractBoldField(body, "Executed");
 
     if (!text || !timestamp) continue;
@@ -367,7 +308,6 @@ function parseCapturesContent(content: string): CaptureEntry[] {
       ...(resolution ? { resolution } : {}),
       ...(rationale ? { rationale } : {}),
       ...(resolvedAt ? { resolvedAt } : {}),
-      ...(milestoneId ? { resolvedInMilestone: milestoneId } : {}),
       ...(executedAt ? { executed: true } : {}),
     });
   }

package/src/resources/extensions/gsd/db-writer.ts

@@ -227,122 +227,6 @@ export async function nextDecisionId(): Promise<string> {
   }
 }
 
-// ─── Next Requirement ID ─────────────────────────────────────────────────
-
-/**
- * Compute the next requirement ID from the current DB state.
- * Queries MAX(CAST(SUBSTR(id, 2) AS INTEGER)) from requirements table.
- * Returns R001 if no requirements exist. Zero-pads to 3 digits.
- */
-export async function nextRequirementId(): Promise<string> {
-  try {
-    const db = await import('./gsd-db.js');
-    const adapter = db._getAdapter();
-    if (!adapter) return 'R001';
-
-    const row = adapter
-      .prepare('SELECT MAX(CAST(SUBSTR(id, 2) AS INTEGER)) as max_num FROM requirements')
-      .get();
-
-    const maxNum = row ? (row['max_num'] as number | null) : null;
-    if (maxNum == null || isNaN(maxNum)) return 'R001';
-
-    const next = maxNum + 1;
-    return `R${String(next).padStart(3, '0')}`;
-  } catch (err) {
-    logError('manifest', 'nextRequirementId failed', { fn: 'nextRequirementId', error: String((err as Error).message) });
-    return 'R001';
-  }
-}
-
-// ─── Save Requirement to DB + Regenerate Markdown ────────────────────────
-
-export interface SaveRequirementFields {
-  class: string;
-  status?: string;
-  description: string;
-  why: string;
-  source: string;
-  primary_owner?: string;
-  supporting_slices?: string;
-  validation?: string;
-  notes?: string;
-}
-
-/**
- * Save a new requirement to DB and regenerate REQUIREMENTS.md.
- * Auto-assigns the next ID via nextRequirementId().
- * Returns the assigned ID.
- */
-export async function saveRequirementToDb(
-  fields: SaveRequirementFields,
-  basePath: string,
-): Promise<{ id: string }> {
-  try {
-    const db = await import('./gsd-db.js');
-
-    const id = await nextRequirementId();
-
-    const requirement: Requirement = {
-      id,
-      class: fields.class,
-      status: fields.status ?? 'active',
-      description: fields.description,
-      why: fields.why,
-      source: fields.source,
-      primary_owner: fields.primary_owner ?? '',
-      supporting_slices: fields.supporting_slices ?? '',
-      validation: fields.validation ?? '',
-      notes: fields.notes ?? '',
-      full_content: '',
-      superseded_by: null,
-    };
-
-    db.upsertRequirement(requirement);
-
-    // Fetch all requirements for full file regeneration
-    const adapter = db._getAdapter();
-    let allRequirements: Requirement[] = [];
-    if (adapter) {
-      const rows = adapter.prepare('SELECT * FROM requirements ORDER BY id').all();
-      allRequirements = rows.map(row => ({
-        id: row['id'] as string,
-        class: row['class'] as string,
-        status: row['status'] as string,
-        description: row['description'] as string,
-        why: row['why'] as string,
-        source: row['source'] as string,
-        primary_owner: row['primary_owner'] as string,
-        supporting_slices: row['supporting_slices'] as string,
-        validation: row['validation'] as string,
-        notes: row['notes'] as string,
-        full_content: row['full_content'] as string,
-        superseded_by: (row['superseded_by'] as string) ?? null,
-      }));
-    }
-
-    const nonSuperseded = allRequirements.filter(r => r.superseded_by == null);
-    const md = generateRequirementsMd(nonSuperseded);
-    const filePath = resolveGsdRootFile(basePath, 'REQUIREMENTS');
-    try {
-      await saveFile(filePath, md);
-    } catch (diskErr) {
-      logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveRequirementToDb', error: String((diskErr as Error).message) });
-      const rollbackAdapter = db._getAdapter();
-      rollbackAdapter?.prepare('DELETE FROM requirements WHERE id = :id').run({ ':id': id });
-      throw diskErr;
-    }
-    invalidateStateCache();
-    clearPathCache();
-    clearParseCache();
-
-    return { id };
-  } catch (err) {
-    logError('manifest', 'saveRequirementToDb failed', { fn: 'saveRequirementToDb', error: String((err as Error).message) });
-    throw err;
-  }
-}
-
 // ─── Save Decision to DB + Regenerate Markdown ────────────────────────────
 
 export interface SaveDecisionFields {
@@ -460,30 +344,15 @@ export async function updateRequirementInDb(
     const db = await import('./gsd-db.js');
 
     const existing = db.getRequirementById(id);
+    if (!existing) {
+      throw new GSDError(GSD_STALE_STATE, `Requirement ${id} not found`);
+    }
 
-    // If requirement doesn't exist in DB, create a skeleton and merge updates.
-    // This handles the case where requirements were written to REQUIREMENTS.md
-    // but never imported into the database (see #2919).
-    const base: Requirement = existing ?? {
-      id,
-      class: '',
-      status: 'active',
-      description: '',
-      why: '',
-      source: '',
-      primary_owner: '',
-      supporting_slices: '',
-      validation: '',
-      notes: '',
-      full_content: '',
-      superseded_by: null,
-    };
-
-    // Merge updates into existing (or skeleton)
+    // Merge updates into existing
     const merged: Requirement = {
-      ...base,
+      ...existing,
       ...updates,
-      id: base.id, // ID cannot be changed
+      id: existing.id, // ID cannot be changed
     };
 
     db.upsertRequirement(merged);
@@ -519,9 +388,7 @@ export async function updateRequirementInDb(
       await saveFile(filePath, md);
     } catch (diskErr) {
       logError('manifest', 'disk write failed, reverting DB row', { fn: 'updateRequirementInDb', error: String((diskErr as Error).message) });
-      if (existing) {
-        db.upsertRequirement(existing);
-      }
+      db.upsertRequirement(existing);
       throw diskErr;
     }
     // Invalidate file-read caches so deriveState() sees the updated markdown.

package/src/resources/extensions/gsd/doctor-git-checks.ts

@@ -14,28 +14,6 @@ import { nativeIsRepo, nativeWorktreeList, nativeWorktreeRemove, nativeBranchLis
 import { getAllWorktreeHealth } from "./worktree-health.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 
-/**
- * Returns true if the directory contains only doctor artifacts
- * (e.g. `.gsd/doctor-history.jsonl`). These dirs are created by
- * appendDoctorHistory() writing to worktree-scoped paths during the audit
- * and should not be flagged as orphaned worktrees (#3105).
- */
-function isDoctorArtifactOnly(dirPath: string): boolean {
-  try {
-    const entries = readdirSync(dirPath);
-    // Empty dir — not a doctor artifact, still orphaned
-    if (entries.length === 0) return false;
-    // Only a .gsd subdirectory
-    if (entries.length === 1 && entries[0] === ".gsd") {
-      const gsdEntries = readdirSync(join(dirPath, ".gsd"));
-      return gsdEntries.length <= 1 && gsdEntries.every(e => e === "doctor-history.jsonl");
-    }
-    return false;
-  } catch {
-    return false;
-  }
-}
-
 export async function checkGitHealth(
   basePath: string,
   issues: DoctorIssue[],
@@ -336,10 +314,6 @@ export async function checkGitHealth(
         } catch { continue; }
         const normalizedFullPath = normalizePath(fullPath);
         if (!registeredPaths.has(normalizedFullPath)) {
-          // Skip directories that only contain doctor artifacts (.gsd/doctor-history.jsonl).
-          // appendDoctorHistory() can recreate these dirs during the audit itself,
-          // causing a circular false positive (#3105 Bug 1).
-          if (isDoctorArtifactOnly(fullPath)) continue;
           issues.push({
             severity: "warning",
             code: "worktree_directory_orphaned",

package/src/resources/extensions/gsd/doctor-providers.ts

@@ -181,8 +181,7 @@ function resolveKey(providerId: string): KeyLookup {
  */
 const PROVIDER_ROUTES: Record<string, string[]> = {
   anthropic: ["github-copilot"],
-  openai: ["github-copilot", "openai-codex"],
-  google: ["google-gemini-cli"],
+  openai: ["github-copilot"],
 };
 
 function checkLlmProviders(): ProviderCheckResult[] {

package/src/resources/extensions/gsd/doctor-runtime-checks.ts

@@ -119,11 +119,10 @@ export async function checkRuntimeHealth(
 
       for (const key of keys) {
         // Key format: "unitType/unitId" e.g. "execute-task/M001/S01/T01"
-        // Hook units have compound types: "hook/<hookName>/unitId"
-        const { splitCompletedKey } = await import("./forensics.js");
-        const parsed = splitCompletedKey(key);
-        if (!parsed) continue;
-        const { unitType, unitId } = parsed;
+        const slashIdx = key.indexOf("/");
+        if (slashIdx === -1) continue;
+        const unitType = key.slice(0, slashIdx);
+        const unitId = key.slice(slashIdx + 1);
 
         // Only validate artifact-producing unit types
         const { verifyExpectedArtifact } = await import("./auto-recovery.js");

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

@@ -729,10 +729,8 @@ export async function runGSDDoctor(basePath: string, options?: { fix?: boolean;
       }
 
       // Blocker-without-replan detection
-      // Skip when all tasks are done — the blocker was implicitly resolved
-      // within the task and the slice is not stuck (#3105 Bug 2).
       const replanPath = resolveSliceFile(basePath, milestoneId, slice.id, "REPLAN");
-      if (!replanPath && !allTasksDone) {
+      if (!replanPath) {
         for (const task of plan.tasks) {
           if (!task.done) continue;
           const summaryPath = resolveTaskFile(basePath, milestoneId, slice.id, task.id, "SUMMARY");