gsd-pi 2.50.0 → 2.51.0-dev.859cedb

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

@@ -17,6 +17,7 @@ import type {
 } from "@gsd/pi-coding-agent";
 
 import { deriveState } from "./state.js";
+import { parseUnitId } from "./unit-id.js";
 import type { GSDState } from "./types.js";
 import { getManifestStatus } from "./files.js";
 export { inlinePriorMilestoneSummary } from "./files.js";
@@ -72,6 +73,7 @@ import {
   getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs,
   getInFlightToolCount,
   getOldestInFlightToolStart,
+  hasInteractiveToolInFlight,
   clearInFlightTools,
 } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
@@ -104,6 +106,7 @@ import {
   captureAvailableSkills,
   resetSkillTelemetry,
 } from "./skill-telemetry.js";
+import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import {
   initMetrics,
   resetMetrics,
@@ -112,6 +115,7 @@ import {
   formatCost,
   formatTokenCount,
 } from "./metrics.js";
+import { setLogBasePath } from "./workflow-logger.js";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -182,7 +186,7 @@ import {
   postUnitPostVerification,
 } from "./auto-post-unit.js";
 import { bootstrapAutoSession, type BootstrapDeps } from "./auto-start.js";
-import { autoLoop, resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight, type LoopDeps } from "./auto-loop.js";
+import { autoLoop, resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight, type LoopDeps, type ErrorContext } from "./auto-loop.js";
 import {
   WorktreeResolver,
   type WorktreeResolverDeps,
@@ -301,6 +305,11 @@ export { type AutoDashboardData } from "./auto-dashboard.js";
 export function getAutoDashboardData(): AutoDashboardData {
   const ledger = getLedger();
   const totals = ledger ? getProjectTotals(ledger.units) : null;
+  const sessionId = s.cmdCtx?.sessionManager?.getSessionId?.() ?? null;
+  const rtkSavings = sessionId && s.basePath
+    ? getRtkSessionSavings(s.basePath, sessionId)
+    : null;
+  const rtkEnabled = loadEffectiveGSDPreferences()?.preferences.experimental?.rtk === true;
   // Pending capture count — lazy check, non-fatal
   let pendingCaptureCount = 0;
   try {
@@ -323,6 +332,8 @@ export function getAutoDashboardData(): AutoDashboardData {
     totalCost: totals?.cost ?? 0,
     totalTokens: totals?.tokens.total ?? 0,
     pendingCaptureCount,
+    rtkSavings,
+    rtkEnabled,
   };
 }
 
@@ -365,8 +376,8 @@ export function getAutoModeStartModel(): {
 }
 
 // Tool tracking — delegates to auto-tool-tracking.ts
-export function markToolStart(toolCallId: string): void {
-  _markToolStart(toolCallId, s.active);
+export function markToolStart(toolCallId: string, toolName?: string): void {
+  _markToolStart(toolCallId, s.active, toolName);
 }
 
 export function markToolEnd(toolCallId: string): void {
@@ -590,8 +601,11 @@ export async function stopAuto(
     // When the milestone is complete (has a SUMMARY), merge the worktree branch
     // back to main so code isn't stranded on the worktree branch (#2317).
     // For incomplete milestones, preserve the branch for later resumption.
+    //
+    // Skip if phases.ts already merged this milestone — avoids the double
+    // mergeAndExit that fails because the branch was already deleted (#2645).
     try {
-      if (s.currentMilestoneId) {
+      if (s.currentMilestoneId && !s.milestoneMergedInPhases) {
         const notifyCtx = ctx
           ? { notify: ctx.ui.notify.bind(ctx.ui) }
           : { notify: () => {} };
@@ -786,11 +800,14 @@ export async function stopAuto(
 export async function pauseAuto(
   ctx?: ExtensionContext,
   _pi?: ExtensionAPI,
+  _errorContext?: ErrorContext,
 ): Promise<void> {
   if (!s.active) return;
   clearUnitTimeout();
   // Unblock any pending unit promise so the auto-loop is not orphaned.
-  resolveAgentEndCancelled();
+  // Pass errorContext so runUnitPhase can distinguish user-initiated pause
+  // from provider-error pause and avoid hard-stopping (#2762).
+  resolveAgentEndCancelled(_errorContext);
 
   s.pausedSessionFile = ctx?.sessionManager?.getSessionFile() ?? null;
 
@@ -1090,6 +1107,7 @@ export async function startAuto(
     s.stepMode = requestedStepMode;
     s.cmdCtx = ctx;
     s.basePath = base;
+    setLogBasePath(base);
     s.unitDispatchCount.clear();
     s.unitLifetimeDispatches.clear();
     if (!getLedger()) initMetrics(base);
@@ -1277,8 +1295,7 @@ function ensurePreconditions(
   base: string,
   state: GSDState,
 ): void {
-  const parts = unitId.split("/");
-  const mid = parts[0]!;
+  const { milestone: mid, slice: sid } = parseUnitId(unitId);
 
   const mDir = resolveMilestonePath(base, mid);
   if (!mDir) {
@@ -1286,8 +1303,7 @@ function ensurePreconditions(
     mkdirSync(join(newDir, "slices"), { recursive: true });
   }
 
-  if (parts.length >= 2) {
-    const sid = parts[1]!;
+  if (sid !== undefined) {
 
     const mDirResolved = resolveMilestonePath(base, mid);
     if (mDirResolved) {

package/src/resources/extensions/gsd/bootstrap/agent-end-recovery.ts

@@ -2,14 +2,56 @@ import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 
 import { checkAutoStartAfterDiscuss } from "../guided-flow.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto } from "../auto.js";
-import { getNextFallbackModel, isTransientNetworkError, resolveModelWithFallbacksForUnit } from "../preferences.js";
-import { classifyProviderError, pauseAutoForProviderError } from "../provider-error-pause.js";
+import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
+import { pauseAutoForProviderError } from "../provider-error-pause.js";
 import { isSessionSwitchInFlight, resolveAgentEnd } from "../auto-loop.js";
+import { resolveModelId } from "../auto-model-selection.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
+import {
+  classifyError,
+  createRetryState,
+  resetRetryState,
+  isTransient,
+  type ErrorClass,
+} from "../error-classifier.js";
 
-const networkRetryCounters = new Map<string, number>();
+const retryState = createRetryState();
+const MAX_NETWORK_RETRIES = 2;
 const MAX_TRANSIENT_AUTO_RESUMES = 3;
-let consecutiveTransientErrors = 0;
+
+async function pauseTransientWithBackoff(
+  cls: ErrorClass,
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  errorDetail: string,
+  isRateLimit: boolean,
+): Promise<void> {
+  retryState.consecutiveTransientCount += 1;
+  const baseRetryAfterMs = "retryAfterMs" in cls ? cls.retryAfterMs : 15_000;
+  const retryAfterMs = baseRetryAfterMs * 2 ** Math.max(0, retryState.consecutiveTransientCount - 1);
+  const allowAutoResume = retryState.consecutiveTransientCount <= MAX_TRANSIENT_AUTO_RESUMES;
+  if (!allowAutoResume) {
+    ctx.ui.notify(`Transient provider errors persisted after ${MAX_TRANSIENT_AUTO_RESUMES} auto-resume attempts. Pausing for manual review.`, "warning");
+  }
+  await pauseAutoForProviderError(ctx.ui, errorDetail, () => pauseAuto(ctx, pi, {
+    message: `Provider error: ${errorDetail}`,
+    category: "provider",
+    isTransient: allowAutoResume,
+    retryAfterMs,
+  }), {
+    isRateLimit,
+    isTransient: allowAutoResume,
+    retryAfterMs,
+    resume: allowAutoResume
+      ? () => {
+        pi.sendMessage(
+          { customType: "gsd-auto-timeout-recovery", content: "Continue execution — provider error recovery delay elapsed.", display: false },
+          { triggerTurn: true },
+        );
+      }
+      : undefined,
+  });
+}
 
 export async function handleAgentEnd(
   pi: ExtensionAPI,
@@ -31,17 +73,26 @@ export async function handleAgentEnd(
   if (lastMsg && "stopReason" in lastMsg && lastMsg.stopReason === "error") {
     const errorDetail = "errorMessage" in lastMsg && lastMsg.errorMessage ? `: ${lastMsg.errorMessage}` : "";
     const errorMsg = ("errorMessage" in lastMsg && lastMsg.errorMessage) ? String(lastMsg.errorMessage) : "";
+    const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
 
-    if (isTransientNetworkError(errorMsg)) {
+    // ── 1. Classify ──────────────────────────────────────────────────────
+    const cls = classifyError(errorMsg, explicitRetryAfterMs);
+
+    // ── 2. Decide & Act ──────────────────────────────────────────────────
+
+    // --- Network errors: same-model retry with backoff ---
+    if (cls.kind === "network") {
       const currentModelId = ctx.model?.id ?? "unknown";
-      const retryKey = `network-retry:${currentModelId}`;
-      const currentRetries = networkRetryCounters.get(retryKey) ?? 0;
-      const maxRetries = 2;
-      if (currentRetries < maxRetries) {
-        networkRetryCounters.set(retryKey, currentRetries + 1);
-        const attempt = currentRetries + 1;
-        const delayMs = attempt * 3000;
-        ctx.ui.notify(`Network error on ${currentModelId}${errorDetail}. Retry ${attempt}/${maxRetries} in ${delayMs / 1000}s...`, "warning");
+      if (retryState.currentRetryModelId !== currentModelId) {
+        retryState.networkRetryCount = 0;
+        retryState.currentRetryModelId = currentModelId;
+      }
+      if (retryState.networkRetryCount < MAX_NETWORK_RETRIES) {
+        retryState.networkRetryCount += 1;
+        retryState.consecutiveTransientCount += 1;
+        const attempt = retryState.networkRetryCount;
+        const delayMs = attempt * cls.retryAfterMs;
+        ctx.ui.notify(`Network error on ${currentModelId}${errorDetail}. Retry ${attempt}/${MAX_NETWORK_RETRIES} in ${delayMs / 1000}s...`, "warning");
         setTimeout(() => {
           pi.sendMessage(
             { customType: "gsd-auto-timeout-recovery", content: "Continue execution — retrying after transient network error.", display: false },
@@ -50,84 +101,86 @@ export async function handleAgentEnd(
         }, delayMs);
         return;
       }
-      networkRetryCounters.delete(retryKey);
+      // Network retries exhausted — fall through to model fallback
+      retryState.networkRetryCount = 0;
+      retryState.currentRetryModelId = undefined;
       ctx.ui.notify(`Network retries exhausted for ${currentModelId}. Attempting model fallback.`, "warning");
     }
 
-    const dash = getAutoDashboardData();
-    if (dash.currentUnit) {
-      const modelConfig = resolveModelWithFallbacksForUnit(dash.currentUnit.type);
-      if (modelConfig && modelConfig.fallbacks.length > 0) {
-        const availableModels = ctx.modelRegistry.getAvailable();
-        const nextModelId = getNextFallbackModel(ctx.model?.id, modelConfig);
-        if (nextModelId) {
-          networkRetryCounters.clear();
-          const slashIdx = nextModelId.indexOf("/");
-          const modelToSet = slashIdx !== -1
-            ? availableModels.find((m) => m.provider.toLowerCase() === nextModelId.substring(0, slashIdx).toLowerCase() && m.id.toLowerCase() === nextModelId.substring(slashIdx + 1).toLowerCase())
-            : (availableModels.find((m) => m.id === nextModelId && m.provider === ctx.model?.provider) ?? availableModels.find((m) => m.id === nextModelId));
-          if (modelToSet) {
-            const ok = await pi.setModel(modelToSet, { persist: false });
-            if (ok) {
-              ctx.ui.notify(`Model error${errorDetail}. Switched to fallback: ${nextModelId} and resuming.`, "warning");
-              pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
-              return;
+    // --- Rate limit: skip model fallback, go straight to pause ---
+    // Rate-limiting is a provider issue, not a model issue.
+    // Switching models won't help if the provider is throttling you.
+    if (cls.kind === "rate-limit") {
+      await pauseTransientWithBackoff(cls, pi, ctx, errorDetail, true);
+      return;
+    }
+
+    // --- Server/connection/stream errors: try model fallback first ---
+    if (cls.kind === "network" || cls.kind === "server" || cls.kind === "connection" || cls.kind === "stream") {
+      // Try model fallback
+      const dash = getAutoDashboardData();
+      if (dash.currentUnit) {
+        const modelConfig = resolveModelWithFallbacksForUnit(dash.currentUnit.type);
+        if (modelConfig && modelConfig.fallbacks.length > 0) {
+          const availableModels = ctx.modelRegistry.getAvailable();
+          const nextModelId = getNextFallbackModel(ctx.model?.id, modelConfig);
+          if (nextModelId) {
+            retryState.networkRetryCount = 0;
+            retryState.currentRetryModelId = undefined;
+            const modelToSet = resolveModelId(nextModelId, availableModels, ctx.model?.provider);
+            if (modelToSet) {
+              const ok = await pi.setModel(modelToSet, { persist: false });
+              if (ok) {
+                ctx.ui.notify(`Model error${errorDetail}. Switched to fallback: ${nextModelId} and resuming.`, "warning");
+                pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
+                return;
+              }
             }
           }
         }
       }
-    }
 
-    const sessionModel = getAutoModeStartModel();
-    if (sessionModel) {
-      if (ctx.model?.id !== sessionModel.id || ctx.model?.provider !== sessionModel.provider) {
-        const startModel = ctx.modelRegistry.getAvailable().find((m) => m.provider === sessionModel.provider && m.id === sessionModel.id);
-        if (startModel) {
-          const ok = await pi.setModel(startModel, { persist: false });
-          if (ok) {
-            networkRetryCounters.clear();
-            ctx.ui.notify(`Model error${errorDetail}. Restored session model: ${sessionModel.provider}/${sessionModel.id} and resuming.`, "warning");
-            pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
-            return;
+      // Try restoring session model
+      const sessionModel = getAutoModeStartModel();
+      if (sessionModel) {
+        if (ctx.model?.id !== sessionModel.id || ctx.model?.provider !== sessionModel.provider) {
+          const startModel = ctx.modelRegistry.getAvailable().find((m) => m.provider === sessionModel.provider && m.id === sessionModel.id);
+          if (startModel) {
+            const ok = await pi.setModel(startModel, { persist: false });
+            if (ok) {
+              retryState.networkRetryCount = 0;
+              retryState.currentRetryModelId = undefined;
+              ctx.ui.notify(`Model error${errorDetail}. Restored session model: ${sessionModel.provider}/${sessionModel.id} and resuming.`, "warning");
+              pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
+              return;
+            }
           }
         }
       }
     }
 
-    const classification = classifyProviderError(errorMsg);
-    const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
-    if (classification.isTransient) {
-      consecutiveTransientErrors += 1;
-    } else {
-      consecutiveTransientErrors = 0;
+    // --- Transient fallback: pause with auto-resume ---
+    if (isTransient(cls)) {
+      await pauseTransientWithBackoff(cls, pi, ctx, errorDetail, false);
+      return;
     }
-    const baseRetryAfterMs = explicitRetryAfterMs ?? classification.suggestedDelayMs;
-    const retryAfterMs = classification.isTransient
-      ? baseRetryAfterMs * 2 ** Math.max(0, consecutiveTransientErrors - 1)
-      : baseRetryAfterMs;
-    const allowAutoResume = classification.isTransient && consecutiveTransientErrors <= MAX_TRANSIENT_AUTO_RESUMES;
-    if (classification.isTransient && !allowAutoResume) {
-      ctx.ui.notify(`Transient provider errors persisted after ${MAX_TRANSIENT_AUTO_RESUMES} auto-resume attempts. Pausing for manual review.`, "warning");
-    }
-    await pauseAutoForProviderError(ctx.ui, errorDetail, () => pauseAuto(ctx, pi), {
-      isRateLimit: classification.isRateLimit,
-      isTransient: allowAutoResume,
-      retryAfterMs,
-      resume: allowAutoResume
-        ? () => {
-          pi.sendMessage(
-            { customType: "gsd-auto-timeout-recovery", content: "Continue execution — provider error recovery delay elapsed.", display: false },
-            { triggerTurn: true },
-          );
-        }
-        : undefined,
+
+    // --- Permanent / unknown: pause indefinitely ---
+    await pauseAutoForProviderError(ctx.ui, errorDetail, () => pauseAuto(ctx, pi, {
+      message: `Provider error: ${errorDetail}`,
+      category: "provider",
+      isTransient: false,
+    }), {
+      isRateLimit: false,
+      isTransient: false,
+      retryAfterMs: 0,
     });
     return;
   }
 
+  // ── Success path ─────────────────────────────────────────────────────────
   try {
-    consecutiveTransientErrors = 0;
-    networkRetryCounters.clear();
+    resetRetryState(retryState);
     resolveAgentEnd(event);
   } catch (err) {
     const message = err instanceof Error ? err.message : String(err);
@@ -139,4 +192,3 @@ export async function handleAgentEnd(
     }
   }
 }
-

package/src/resources/extensions/gsd/bootstrap/dynamic-tools.ts

@@ -5,6 +5,7 @@ import type { ExtensionAPI } from "@gsd/pi-coding-agent";
 import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@gsd/pi-coding-agent";
 
 import { DEFAULT_BASH_TIMEOUT_SECS } from "../constants.js";
+import { setLogBasePath } from "../workflow-logger.js";
 
 /**
  * Resolve the correct DB path for the current working directory.
@@ -43,9 +44,14 @@ export async function ensureDbOpen(): Promise<boolean> {
     const dbPath = resolveProjectRootDbPath(basePath);
     const gsdDir = join(basePath, ".gsd");
 
+    // Derive the project root from the DB path (strip .gsd/gsd.db)
+    const projectRoot = join(dbPath, "..", "..");
+
     // Open existing DB file (may be at project root for worktrees)
     if (existsSync(dbPath)) {
-      return db.openDatabase(dbPath);
+      const opened = db.openDatabase(dbPath);
+      if (opened) setLogBasePath(projectRoot);
+      return opened;
     }
 
     // No DB file — create + migrate from Markdown if .gsd/ has content
@@ -56,6 +62,7 @@ export async function ensureDbOpen(): Promise<boolean> {
       if (hasDecisions || hasRequirements || hasMilestones) {
         const opened = db.openDatabase(dbPath);
         if (opened) {
+          setLogBasePath(projectRoot);
           try {
             const { migrateFromMarkdown } = await import("../md-importer.js");
             migrateFromMarkdown(basePath);
@@ -69,7 +76,9 @@ export async function ensureDbOpen(): Promise<boolean> {
       }
 
       // .gsd/ exists but has no Markdown content (fresh project) — create empty DB
-      return db.openDatabase(dbPath);
+      const opened = db.openDatabase(dbPath);
+      if (opened) setLogBasePath(projectRoot);
+      return opened;
     }
 
     return false;

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

@@ -16,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).
@@ -27,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 {
@@ -75,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) => {
@@ -123,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());
@@ -228,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/claude-import.ts

@@ -103,16 +103,47 @@ function isMarketplacePath(pluginPath: string): boolean {
 
 /**
  * Detect which plugin roots are marketplaces and which are legacy flat paths.
+ *
+ * Claude Code stores marketplace sources under ~/.claude/plugins/marketplaces/.
+ * Each subdirectory (e.g. marketplaces/confluent/) is a marketplace repo that
+ * contains .claude-plugin/marketplace.json. The parent directory itself does not
+ * have a marketplace.json, so we scan one level deeper when the root isn't
+ * directly a marketplace.
  */
-function categorizePluginRoots(pluginRoots: string[]): { marketplaces: string[]; flat: string[] } {
+export function categorizePluginRoots(pluginRoots: string[]): { marketplaces: string[]; flat: string[] } {
   const marketplaces: string[] = [];
   const flat: string[] = [];
+  const seen = new Set<string>();
 
   for (const root of pluginRoots) {
     if (isMarketplacePath(root)) {
-      marketplaces.push(root);
+      if (!seen.has(root)) {
+        marketplaces.push(root);
+        seen.add(root);
+      }
     } else {
-      flat.push(root);
+      // The root itself isn't a marketplace — check if it's a container of
+      // marketplaces (e.g. ~/.claude/plugins/marketplaces/ contains subdirs
+      // like confluent/, claude-hud/, each with their own marketplace.json).
+      let foundChild = false;
+      try {
+        const entries = readdirSync(root, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) continue;
+          if (SKIP_DIRS.has(entry.name)) continue;
+          const childPath = join(root, entry.name);
+          if (isMarketplacePath(childPath) && !seen.has(childPath)) {
+            marketplaces.push(childPath);
+            seen.add(childPath);
+            foundChild = true;
+          }
+        }
+      } catch {
+        // Can't read directory — fall through to flat
+      }
+      if (!foundChild) {
+        flat.push(root);
+      }
     }
   }
 
@@ -170,18 +201,36 @@ export function discoverClaudePlugins(cwd: string): ClaudePluginCandidate[] {
 
   for (const root of pluginRoots) {
     walkDirs(root, (dir) => {
+      // Recognize both npm-style plugins (package.json) and Claude Code plugins
+      // (.claude-plugin/plugin.json). Claude marketplace-installed plugins use
+      // the latter format exclusively.
       const pkgPath = join(dir, "package.json");
-      if (!existsSync(pkgPath)) return;
+      const claudePluginPath = join(dir, ".claude-plugin", "plugin.json");
+      const hasPkg = existsSync(pkgPath);
+      const hasClaudePlugin = existsSync(claudePluginPath);
+      if (!hasPkg && !hasClaudePlugin) return;
+
       const resolvedDir = resolve(dir);
       if (seen.has(resolvedDir)) return;
       seen.add(resolvedDir);
+
       let packageName: string | undefined;
-      try {
-        const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as { name?: string };
-        packageName = pkg.name;
-      } catch {
-        packageName = undefined;
+      if (hasPkg) {
+        try {
+          const pkg = JSON.parse(readFileSync(pkgPath, "utf8")) as { name?: string };
+          packageName = pkg.name;
+        } catch {
+          packageName = undefined;
+        }
+      } else if (hasClaudePlugin) {
+        try {
+          const manifest = JSON.parse(readFileSync(claudePluginPath, "utf8")) as { name?: string };
+          packageName = manifest.name;
+        } catch {
+          packageName = undefined;
+        }
       }
+
       results.push({
         type: "plugin",
         name: packageName || basename(dir),