gsd-pi 2.50.0-dev.d210a87 → 2.51.0-dev.7d435fe

package/dist/resources/extensions/gsd/auto-timers.js

@@ -9,7 +9,7 @@ import { readUnitRuntimeRecord, writeUnitRuntimeRecord } from "./unit-runtime.js
 import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { resolveAutoSupervisorConfig } from "./preferences.js";
 import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
-import { getInFlightToolCount, getOldestInFlightToolStart, } from "./auto-tool-tracking.js";
+import { getInFlightToolCount, getOldestInFlightToolStart, clearInFlightTools, hasInteractiveToolInFlight, } from "./auto-tool-tracking.js";
 import { detectWorkingTreeActivity } from "./auto-supervisor.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { saveActivityLog } from "./activity-log.js";
@@ -116,7 +116,17 @@ export function startUnitSupervision(sctx) {
                 return;
             // Agent has tool calls currently executing — not idle, just waiting.
             // But only suppress recovery if the tool started recently.
+            let stalledToolDetected = false;
             if (getInFlightToolCount() > 0) {
+                // User-interactive tools (ask_user_questions, secure_env_collect) block
+                // waiting for human input by design — never treat them as stalled (#2676).
+                if (hasInteractiveToolInFlight()) {
+                    writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
+                        lastProgressAt: Date.now(),
+                        lastProgressKind: "interactive-tool-waiting",
+                    });
+                    return;
+                }
                 const oldestStart = getOldestInFlightToolStart();
                 const toolAgeMs = Date.now() - oldestStart;
                 if (toolAgeMs < idleTimeoutMs) {
@@ -126,10 +136,18 @@ export function startUnitSupervision(sctx) {
                     });
                     return;
                 }
+                // Tool has been in-flight longer than idle timeout — treat as hung.
+                // Clear the stale entries so subsequent ticks don't re-detect them,
+                // and set the flag so the filesystem-activity check below does not
+                // override the stall verdict (#2527).
+                stalledToolDetected = true;
+                clearInFlightTools();
                 ctx.ui.notify(`Stalled tool detected: a tool has been in-flight for ${Math.round(toolAgeMs / 60000)}min. Treating as hung — attempting idle recovery.`, "warning");
             }
             // Check if the agent is producing work on disk.
-            if (detectWorkingTreeActivity(s.basePath)) {
+            // Skip this when a stalled tool was just detected — filesystem changes
+            // from earlier in the task should not override the stall verdict (#2527).
+            if (!stalledToolDetected && detectWorkingTreeActivity(s.basePath)) {
                 writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
                     lastProgressAt: Date.now(),
                     lastProgressKind: "filesystem-activity",
@@ -145,6 +163,10 @@ export function startUnitSupervision(sctx) {
             const recovery = await recoverTimedOutUnit(ctx, pi, unitType, unitId, "idle", buildRecoveryContext());
             if (recovery === "recovered")
                 return;
+            // Guard: recoverTimedOutUnit is async — pauseAuto/stopAuto may have
+            // set s.currentUnit = null during the await (#2527).
+            if (!s.currentUnit)
+                return;
             writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
                 phase: "paused",
             });

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -4,14 +4,20 @@
  * can distinguish "waiting for tool completion" from "truly idle".
  */
 const inFlightTools = new Map();
+/**
+ * Tools that block waiting for human input by design.
+ * The idle watchdog must not treat these as stalled.
+ */
+const INTERACTIVE_TOOLS = new Set(["ask_user_questions", "secure_env_collect"]);
 /**
  * Mark a tool execution as in-flight.
- * Records start time so the idle watchdog can detect tools hung longer than the idle timeout.
+ * Records start time and tool name so the idle watchdog can detect tools
+ * hung longer than the idle timeout while exempting interactive tools.
  */
-export function markToolStart(toolCallId, isActive) {
+export function markToolStart(toolCallId, isActive, toolName) {
     if (!isActive)
         return;
-    inFlightTools.set(toolCallId, Date.now());
+    inFlightTools.set(toolCallId, { startedAt: Date.now(), toolName: toolName ?? "unknown" });
 }
 /**
  * Mark a tool execution as completed.
@@ -27,8 +33,8 @@ export function getOldestInFlightToolAgeMs() {
         return 0;
     let oldestStart = Infinity;
     for (const t of inFlightTools.values()) {
-        if (t < oldestStart)
-            oldestStart = t;
+        if (t.startedAt < oldestStart)
+            oldestStart = t.startedAt;
     }
     return Date.now() - oldestStart;
 }
@@ -46,11 +52,23 @@ export function getOldestInFlightToolStart() {
         return undefined;
     let oldest = Infinity;
     for (const t of inFlightTools.values()) {
-        if (t < oldest)
-            oldest = t;
+        if (t.startedAt < oldest)
+            oldest = t.startedAt;
     }
     return oldest;
 }
+/**
+ * Returns true if any currently in-flight tool is a user-interactive tool
+ * (e.g. ask_user_questions, secure_env_collect) that blocks waiting for
+ * human input. These must be exempt from idle stall detection.
+ */
+export function hasInteractiveToolInFlight() {
+    for (const { toolName } of inFlightTools.values()) {
+        if (INTERACTIVE_TOOLS.has(toolName))
+            return true;
+    }
+    return false;
+}
 /**
  * Clear all in-flight tool tracking state.
  */

package/dist/resources/extensions/gsd/auto-worktree.js

@@ -37,6 +37,10 @@ const ROOT_STATE_FILES = [
     "QUEUE.md",
     "completed-units.json",
     "metrics.json",
+    // NOTE: preferences.md is intentionally NOT in ROOT_STATE_FILES.
+    // Forward-sync (main → worktree) is handled explicitly in syncGsdStateToWorktree().
+    // Back-sync (worktree → main) must NEVER overwrite the project root's copy
+    // because the project root is authoritative for preferences (#2684).
 ];
 /**
  * Check if two filesystem paths resolve to the same real location.
@@ -319,6 +323,22 @@ export function syncGsdStateToWorktree(mainBasePath, worktreePath_) {
             }
         }
     }
+    // Forward-sync preferences.md from project root to worktree (additive only).
+    // NOT in ROOT_STATE_FILES because syncWorktreeStateBack() must never overwrite
+    // the project root's preferences — the project root is authoritative (#2684).
+    {
+        const src = join(mainGsd, "preferences.md");
+        const dst = join(wtGsd, "preferences.md");
+        if (existsSync(src) && !existsSync(dst)) {
+            try {
+                cpSync(src, dst);
+                synced.push("preferences.md");
+            }
+            catch {
+                /* non-fatal */
+            }
+        }
+    }
     // Sync milestones: copy entire milestone directories that are missing
     const mainMilestonesDir = join(mainGsd, "milestones");
     const wtMilestonesDir = join(wtGsd, "milestones");
@@ -801,6 +821,7 @@ function copyPlanningArtifacts(srcBase, wtPath) {
         "STATE.md",
         "KNOWLEDGE.md",
         "OVERRIDES.md",
+        "preferences.md",
     ]) {
         safeCopy(join(srcGsd, file), join(dstGsd, file), { force: true });
     }

package/dist/resources/extensions/gsd/auto.js

@@ -34,6 +34,7 @@ import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
 import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, 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";
@@ -184,8 +185,8 @@ export function getAutoModeStartModel() {
     return s.autoModeStartModel;
 }
 // Tool tracking — delegates to auto-tool-tracking.ts
-export function markToolStart(toolCallId) {
-    _markToolStart(toolCallId, s.active);
+export function markToolStart(toolCallId, toolName) {
+    _markToolStart(toolCallId, s.active, toolName);
 }
 export function markToolEnd(toolCallId) {
     _markToolEnd(toolCallId);
@@ -815,6 +816,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         s.stepMode = requestedStepMode;
         s.cmdCtx = ctx;
         s.basePath = base;
+        setLogBasePath(base);
         s.unitDispatchCount.clear();
         s.unitLifetimeDispatches.clear();
         if (!getLedger())

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -1,12 +1,33 @@
 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";
-const networkRetryCounters = new Map();
+import { classifyError, createRetryState, resetRetryState, isTransient, } from "../error-classifier.js";
+const retryState = createRetryState();
+const MAX_NETWORK_RETRIES = 2;
 const MAX_TRANSIENT_AUTO_RESUMES = 3;
-let consecutiveTransientErrors = 0;
+async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit) {
+    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), {
+        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, event, ctx) {
     if (checkAutoStartAfterDiscuss()) {
         clearDiscussionFlowState();
@@ -24,93 +45,98 @@ export async function handleAgentEnd(pi, event, ctx) {
     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) : "";
-        if (isTransientNetworkError(errorMsg)) {
+        const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
+        // ── 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 }, { triggerTurn: true });
                 }, 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;
-        }
-        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");
+        // --- Transient fallback: pause with auto-resume ---
+        if (isTransient(cls)) {
+            await pauseTransientWithBackoff(cls, pi, ctx, errorDetail, false);
+            return;
         }
+        // --- Permanent / unknown: pause indefinitely ---
         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,
+            isRateLimit: false,
+            isTransient: false,
+            retryAfterMs: 0,
         });
         return;
     }
+    // ── Success path ─────────────────────────────────────────────────────────
     try {
-        consecutiveTransientErrors = 0;
-        networkRetryCounters.clear();
+        resetRetryState(retryState);
         resolveAgentEnd(event);
     }
     catch (err) {

package/dist/resources/extensions/gsd/bootstrap/dynamic-tools.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { join, sep } from "node:path";
 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.
  * If `basePath` is inside a `.gsd/worktrees/<MID>/` directory, returns
@@ -35,9 +36,14 @@ export async function ensureDbOpen() {
         const basePath = process.cwd();
         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
         if (existsSync(gsdDir)) {
@@ -47,6 +53,7 @@ export async function ensureDbOpen() {
             if (hasDecisions || hasRequirements || hasMilestones) {
                 const opened = db.openDatabase(dbPath);
                 if (opened) {
+                    setLogBasePath(projectRoot);
                     try {
                         const { migrateFromMarkdown } = await import("../md-importer.js");
                         migrateFromMarkdown(basePath);
@@ -58,7 +65,10 @@ export async function ensureDbOpen() {
                 return opened;
             }
             // .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/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -227,7 +227,7 @@ export function registerHooks(pi) {
     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) => {
         markToolEnd(event.toolCallId);

package/dist/resources/extensions/gsd/claude-import.js

@@ -79,16 +79,50 @@ function isMarketplacePath(pluginPath) {
 }
 /**
  * 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) {
+export function categorizePluginRoots(pluginRoots) {
     const marketplaces = [];
     const flat = [];
+    const seen = new Set();
     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);
+            }
         }
     }
     return { marketplaces, flat };
@@ -145,20 +179,37 @@ export function discoverClaudePlugins(cwd) {
     const seen = new Set();
     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))
+            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;
-            try {
-                const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
-                packageName = pkg.name;
+            if (hasPkg) {
+                try {
+                    const pkg = JSON.parse(readFileSync(pkgPath, "utf8"));
+                    packageName = pkg.name;
+                }
+                catch {
+                    packageName = undefined;
+                }
             }
-            catch {
-                packageName = undefined;
+            else if (hasClaudePlugin) {
+                try {
+                    const manifest = JSON.parse(readFileSync(claudePluginPath, "utf8"));
+                    packageName = manifest.name;
+                }
+                catch {
+                    packageName = undefined;
+                }
             }
             results.push({
                 type: "plugin",