gsd-pi 2.20.0 → 2.22.0

package/dist/resources/extensions/gsd/tests/preferences-git.test.ts

@@ -1,7 +1,7 @@
 // GSD Git Preferences Tests — validates git.isolation and git.merge_to_main handling
 
 import { createTestContext } from "./test-helpers.ts";
-import { validatePreferences } from "../preferences.ts";
+import { validatePreferences, getIsolationMode } from "../preferences.ts";
 
 const { assertEq, assertTrue, report } = createTestContext();
 
@@ -21,12 +21,18 @@ async function main(): Promise<void> {
     assertEq(warnings.length, 0, "isolation: branch — no warnings");
     assertEq(preferences.git?.isolation, "branch", "isolation: branch — value preserved");
   }
+  {
+    const { preferences, warnings, errors } = validatePreferences({ git: { isolation: "none" } });
+    assertEq(errors.length, 0, "isolation: none — no errors");
+    assertEq(warnings.length, 0, "isolation: none — no warnings");
+    assertEq(preferences.git?.isolation, "none", "isolation: none — value preserved");
+  }
 
   // Invalid values produce errors
   {
     const { errors } = validatePreferences({ git: { isolation: "invalid" as any } });
     assertTrue(errors.length > 0, "isolation: invalid — produces error");
-    assertTrue(errors[0].includes("worktree, branch"), "isolation: invalid — error mentions valid values");
+    assertTrue(errors[0].includes("worktree, branch, none"), "isolation: invalid — error mentions valid values");
   }
 
   // Undefined passes through without warning
@@ -95,6 +101,19 @@ async function main(): Promise<void> {
     assertEq(preferences.git?.commit_docs, undefined, "commit_docs: undefined — not set");
   }
 
+  console.log("\n=== getIsolationMode() ===");
+
+  // Returns "none" when set to "none"
+  // Note: getIsolationMode() reads from disk via loadEffectiveGSDPreferences,
+  // so we test it indirectly by verifying the function is exported and callable.
+  // The validation tests above prove the preference value is stored correctly.
+  // Direct mode tests require mocking the filesystem, so we test the function's
+  // default return value (no preferences file in test context).
+  {
+    const mode = getIsolationMode();
+    assertEq(mode, "worktree", "getIsolationMode: returns worktree as default when no prefs file");
+  }
+
   report();
 }
 

package/dist/resources/extensions/gsd/tests/preferences-schema-validation.test.ts

@@ -155,7 +155,7 @@ async function main(): Promise<void> {
 
   console.log("\n=== existing behavior preserved ===");
 
-  // git.isolation is a valid active setting (worktree | branch) — no warnings or errors
+  // git.isolation is a valid active setting (worktree | branch | none) — no warnings or errors
   {
     const { warnings, errors, preferences } = validatePreferences({ git: { isolation: "worktree" } } as GSDPreferences);
     const unknownWarnings = warnings.filter(w => w.includes("unknown"));
@@ -163,6 +163,13 @@ async function main(): Promise<void> {
     assertEq(errors.length, 0, "valid git.isolation produces no errors");
     assertEq(preferences.git?.isolation, "worktree", "git.isolation value passes through");
   }
+  {
+    const { warnings, errors, preferences } = validatePreferences({ git: { isolation: "none" } } as GSDPreferences);
+    const unknownWarnings = warnings.filter(w => w.includes("unknown"));
+    assertEq(unknownWarnings.length, 0, "git.isolation none — no unknown-key warning");
+    assertEq(errors.length, 0, "git.isolation none produces no errors");
+    assertEq(preferences.git?.isolation, "none", "git.isolation none value passes through");
+  }
 
   // git.merge_to_main is deprecated — still produces deprecation warning
   {

package/dist/resources/extensions/gsd/tests/visualizer-data.test.ts

@@ -165,6 +165,17 @@ assertTrue(
   "VisualizerData has changelog field",
 );
 
+// completedAt must be coerced to String() to handle YAML Date objects (issue #644)
+assertTrue(
+  dataSrc.includes("String(summary.frontmatter.completed_at"),
+  "completedAt assignment coerces to String() for YAML Date safety",
+);
+
+assertTrue(
+  dataSrc.includes("String(b.completedAt") && dataSrc.includes("String(a.completedAt"),
+  "changelog sort coerces completedAt to String() for YAML Date safety",
+);
+
 // Verify overlay source exists and imports data module
 const overlayPath = join(__dirname, "..", "visualizer-overlay.ts");
 const overlaySrc = readFileSync(overlayPath, "utf-8");

package/dist/resources/extensions/gsd/tests/worktree-bugfix.test.ts

@@ -0,0 +1,120 @@
+/**
+ * Tests for worktree edge-case bugfixes:
+ *
+ *   1. resolveGitDir() follows gitdir: pointer in worktrees
+ *   2. captureIntegrationBranch() is a no-op in worktrees
+ *   3. detectWorktreeName() correctly identifies worktree paths
+ */
+
+import {
+  mkdtempSync, mkdirSync, writeFileSync, rmSync,
+  existsSync, readFileSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+import { describe, it, after } from "node:test";
+
+import { resolveGitDir } from "../worktree-manager.ts";
+import { detectWorktreeName, captureIntegrationBranch } from "../worktree.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertEq, assertTrue, report } = createTestContext();
+
+// ─── Helpers ──────────────────────────────────────────────────────────────
+
+function run(cmd: string, cwd: string): void {
+  execSync(cmd, { cwd, stdio: "ignore" });
+}
+
+function initRepo(dir: string): void {
+  run("git init", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  run("git commit --allow-empty -m init", dir);
+}
+
+// ─── Tests ────────────────────────────────────────────────────────────────
+
+describe("worktree-bugfix", () => {
+  const dirs: string[] = [];
+  after(() => {
+    for (const d of dirs) rmSync(d, { recursive: true, force: true });
+    report();
+  });
+
+  it("resolveGitDir returns .git directory in normal repo", () => {
+    const repo = mkdtempSync(join(tmpdir(), "gsd-wt-fix-"));
+    dirs.push(repo);
+    initRepo(repo);
+    const gitDir = resolveGitDir(repo);
+    assertTrue(gitDir.endsWith(".git"), "ends with .git");
+    assertTrue(existsSync(gitDir), ".git dir exists");
+  });
+
+  it("resolveGitDir follows gitdir: pointer in worktree", () => {
+    const repo = mkdtempSync(join(tmpdir(), "gsd-wt-fix-"));
+    dirs.push(repo);
+    initRepo(repo);
+
+    // Simulate a worktree .git file (git worktree add creates these)
+    const wtDir = mkdtempSync(join(tmpdir(), "gsd-wt-fix-wt-"));
+    dirs.push(wtDir);
+    const realGitDir = join(repo, ".git", "worktrees", "test-wt");
+    mkdirSync(realGitDir, { recursive: true });
+    writeFileSync(join(wtDir, ".git"), `gitdir: ${realGitDir}\n`);
+
+    const resolved = resolveGitDir(wtDir);
+    assertEq(resolved, realGitDir, "resolves to real git dir");
+  });
+
+  it("resolveGitDir returns default when .git doesn't exist", () => {
+    const noGit = mkdtempSync(join(tmpdir(), "gsd-wt-fix-"));
+    dirs.push(noGit);
+    const gitDir = resolveGitDir(noGit);
+    assertTrue(gitDir.endsWith(".git"), "returns default .git path");
+  });
+
+  it("detectWorktreeName returns name for worktree path", () => {
+    assertEq(
+      detectWorktreeName("/project/.gsd/worktrees/M005"),
+      "M005",
+      "detects worktree name",
+    );
+  });
+
+  it("detectWorktreeName returns null for normal repo", () => {
+    assertEq(
+      detectWorktreeName("/project"),
+      null,
+      "null for non-worktree path",
+    );
+  });
+
+  it("captureIntegrationBranch is a no-op when in a worktree", () => {
+    const repo = mkdtempSync(join(tmpdir(), "gsd-wt-fix-"));
+    dirs.push(repo);
+    initRepo(repo);
+
+    // Create a fake worktree path structure
+    const wtPath = join(repo, ".gsd", "worktrees", "M005");
+    mkdirSync(wtPath, { recursive: true });
+    mkdirSync(join(wtPath, ".gsd", "milestones", "M005"), { recursive: true });
+    // Initialize git in the worktree so getService doesn't fail
+    initRepo(wtPath);
+
+    // captureIntegrationBranch should be a no-op — no META.json written
+    const metaPath = join(wtPath, ".gsd", "milestones", "M005", "M005-META.json");
+    captureIntegrationBranch(wtPath, "M005");
+    assertTrue(!existsSync(metaPath), "no META.json written in worktree");
+  });
+
+  it("detectWorktreeName prevents pull in worktree context", () => {
+    // Verifies the guard pattern: if detectWorktreeName returns non-null,
+    // the caller should skip pull/fetch operations
+    const inWorktree = detectWorktreeName("/project/.gsd/worktrees/M006");
+    const inNormal = detectWorktreeName("/project");
+    assertTrue(inWorktree !== null, "worktree detected → skip pull");
+    assertTrue(inNormal === null, "normal repo → allow pull");
+  });
+});

package/dist/resources/extensions/gsd/token-counter.ts

@@ -0,0 +1,45 @@
+interface TokenEncoder {
+	encode(text: string): Uint32Array | number[];
+}
+
+let encoder: TokenEncoder | null = null;
+let encoderFailed = false;
+
+async function getEncoder(): Promise<TokenEncoder | null> {
+	if (encoder) return encoder;
+	if (encoderFailed) return null;
+	try {
+		// @ts-ignore — tiktoken may not have type declarations in extensions tsconfig
+		const tiktoken = await import("tiktoken");
+		encoder = tiktoken.encoding_for_model("gpt-4o") as TokenEncoder;
+		return encoder;
+	} catch {
+		encoderFailed = true;
+		return null;
+	}
+}
+
+export async function countTokens(text: string): Promise<number> {
+	const enc = await getEncoder();
+	if (enc) {
+		const tokens = enc.encode(text);
+		return tokens.length;
+	}
+	return Math.ceil(text.length / 4);
+}
+
+export function countTokensSync(text: string): number {
+	if (encoder) {
+		return encoder.encode(text).length;
+	}
+	return Math.ceil(text.length / 4);
+}
+
+export async function initTokenCounter(): Promise<boolean> {
+	const enc = await getEncoder();
+	return enc !== null;
+}
+
+export function isAccurateCountingAvailable(): boolean {
+	return encoder !== null;
+}

package/dist/resources/extensions/gsd/visualizer-data.ts

@@ -379,7 +379,7 @@ async function loadChangelog(basePath: string, milestones: VisualizerMilestone[]
           path: f.path,
           description: f.description,
         })),
-        completedAt: summary.frontmatter.completed_at ?? '',
+        completedAt: String(summary.frontmatter.completed_at ?? ''),
       };
 
       changelogCache.set(cacheKey, { mtime, entry });
@@ -388,7 +388,7 @@ async function loadChangelog(basePath: string, milestones: VisualizerMilestone[]
   }
 
   // Sort by completedAt descending
-  entries.sort((a, b) => (b.completedAt || '').localeCompare(a.completedAt || ''));
+  entries.sort((a, b) => String(b.completedAt || '').localeCompare(String(a.completedAt || '')));
 
   return { entries };
 }

package/dist/resources/extensions/gsd/worktree-manager.ts

@@ -15,7 +15,7 @@
  *   4. remove()  — git worktree remove + branch cleanup
  */
 
-import { existsSync, mkdirSync, realpathSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, realpathSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
 import {
   nativeBranchDelete,
@@ -74,6 +74,34 @@ export function getMainBranch(basePath: string): string {
   return nativeDetectMainBranch(basePath);
 }
 
+// ─── resolveGitDir ─────────────────────────────────────────────────────────
+
+/**
+ * Resolve the actual git directory for a given repository path.
+ *
+ * In a normal repo, .git is a directory → returns `<basePath>/.git`.
+ * In a worktree, .git is a file containing `gitdir: <path>` → resolves
+ * and returns that path.
+ *
+ * This is critical for operations that reference git metadata files like
+ * MERGE_HEAD, SQUASH_MSG, etc. — these live in the git directory, not
+ * in the working tree root. Without this, worktree merges fail because
+ * they look for MERGE_HEAD in the wrong location.
+ */
+export function resolveGitDir(basePath: string): string {
+  const gitPath = join(basePath, ".git");
+  if (!existsSync(gitPath)) return join(basePath, ".git");
+  try {
+    const content = readFileSync(gitPath, "utf-8").trim();
+    if (content.startsWith("gitdir: ")) {
+      return resolve(basePath, content.slice(8));
+    }
+  } catch {
+    // Not a file or unreadable — fall through to default
+  }
+  return join(basePath, ".git");
+}
+
 export function worktreesDir(basePath: string): string {
   return join(basePath, ".gsd", "worktrees");
 }

package/dist/resources/extensions/gsd/worktree.ts

@@ -55,6 +55,9 @@ export function setActiveMilestoneId(basePath: string, milestoneId: string | nul
  * if on a GSD slice branch.
  */
 export function captureIntegrationBranch(basePath: string, milestoneId: string, options?: { commitDocs?: boolean }): void {
+  // In a worktree, the base branch is implicit (worktree/<name>).
+  // Writing it to META.json would leave stale metadata after merge back to main.
+  if (detectWorktreeName(basePath)) return;
   const svc = getService(basePath);
   const current = svc.getCurrentBranch();
   writeIntegrationBranch(basePath, milestoneId, current, options);

package/dist/resources/extensions/mcporter/index.ts

@@ -26,6 +26,8 @@ import { Text } from "@gsd/pi-tui";
 import { Type } from "@sinclair/typebox";
 import { execFile, exec } from "node:child_process";
 import { promisify } from "node:util";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
 
 const execFileAsync = promisify(execFile);
 const execAsync = promisify(exec);
@@ -99,6 +101,37 @@ async function runMcporter(
 	return stdout;
 }
 
+/**
+ * Read .mcp.json from the project root (cwd) and return servers not already
+ * discovered by mcporter. This bridges the gap where mcporter doesn't scan
+ * the standard .mcp.json config used by Claude Code, Cursor, etc.
+ */
+function readProjectMcpJson(knownNames: Set<string>): McpServer[] {
+	const servers: McpServer[] = [];
+	try {
+		const mcpJsonPath = join(process.cwd(), ".mcp.json");
+		if (!existsSync(mcpJsonPath)) return servers;
+		const raw = readFileSync(mcpJsonPath, "utf-8");
+		const data = JSON.parse(raw) as Record<string, unknown>;
+		const mcpServers = (data.mcpServers ?? data.servers) as Record<string, Record<string, unknown>> | undefined;
+		if (!mcpServers || typeof mcpServers !== "object") return servers;
+
+		for (const [name, config] of Object.entries(mcpServers)) {
+			if (knownNames.has(name)) continue; // Already discovered by mcporter
+			const transport = (config.type as string) ?? (config.command ? "stdio" : config.url ? "http" : "unknown");
+			servers.push({
+				name,
+				status: "ok",
+				transport,
+				tools: [], // Tools unknown until mcp_discover is called
+			});
+		}
+	} catch {
+		// Non-fatal — .mcp.json may not exist or be malformed
+	}
+	return servers;
+}
+
 async function getServerList(signal?: AbortSignal): Promise<McpServer[]> {
 	if (serverListCache) return serverListCache;
 
@@ -112,6 +145,14 @@ async function getServerList(signal?: AbortSignal): Promise<McpServer[]> {
 	if (!Array.isArray(data.servers)) {
 		throw new Error(`Unexpected mcporter response shape: ${JSON.stringify(Object.keys(data))}`);
 	}
+
+	// Merge servers from project-root .mcp.json that mcporter didn't discover
+	const knownNames = new Set(data.servers.map((s) => s.name));
+	const projectServers = readProjectMcpJson(knownNames);
+	if (projectServers.length > 0) {
+		data.servers.push(...projectServers);
+	}
+
 	serverListCache = data.servers;
 	return serverListCache;
 }
@@ -122,12 +163,39 @@ async function getServerDetail(
 ): Promise<McpServerDetail> {
 	if (serverDetailCache.has(serverName)) return serverDetailCache.get(serverName)!;
 
-	const raw = await runMcporter(["list", serverName, "--schema", "--json"], signal);
+	// Check if this server came from .mcp.json (not known to mcporter natively)
+	const mcpJsonUrl = getMcpJsonServerUrl(serverName);
+	const args = mcpJsonUrl
+		? ["list", mcpJsonUrl, "--schema", "--json"]
+		: ["list", serverName, "--schema", "--json"];
+
+	const raw = await runMcporter(args, signal);
 	const data = JSON.parse(raw) as McpServerDetail;
+	// Preserve the user-facing name from .mcp.json
+	if (mcpJsonUrl) data.name = serverName;
 	serverDetailCache.set(serverName, data);
 	return data;
 }
 
+/**
+ * Look up a server's URL from .mcp.json if it's an HTTP server not known to mcporter.
+ */
+function getMcpJsonServerUrl(serverName: string): string | null {
+	try {
+		const mcpJsonPath = join(process.cwd(), ".mcp.json");
+		if (!existsSync(mcpJsonPath)) return null;
+		const raw = readFileSync(mcpJsonPath, "utf-8");
+		const data = JSON.parse(raw) as Record<string, unknown>;
+		const mcpServers = (data.mcpServers ?? data.servers) as Record<string, Record<string, unknown>> | undefined;
+		if (!mcpServers?.[serverName]) return null;
+		const config = mcpServers[serverName];
+		if (config.type === "http" && typeof config.url === "string") return config.url;
+		return null;
+	} catch {
+		return null;
+	}
+}
+
 function formatServerList(servers: McpServer[]): string {
 	if (servers.length === 0) return "No MCP servers found.";
 
@@ -328,7 +396,10 @@ export default function (pi: ExtensionAPI) {
 
 		async execute(_id, params, signal) {
 			// Build mcporter call command: mcporter call server.tool key:value ...
-			const callTarget = `${params.server}.${params.tool}`;
+			// For HTTP servers from .mcp.json, use the URL directly as the server identifier
+			const mcpJsonUrl = getMcpJsonServerUrl(params.server);
+			const serverRef = mcpJsonUrl ?? params.server;
+			const callTarget = `${serverRef}.${params.tool}`;
 			const cliArgs = ["call", callTarget, "--output", "raw"];
 
 			if (params.args && Object.keys(params.args).length > 0) {
@@ -418,12 +489,24 @@ export default function (pi: ExtensionAPI) {
 	pi.on("session_start", async (_event, ctx) => {
 		try {
 			const ver = (await runMcporter(["--version"], undefined, 5000)).trim();
-		ctx.ui.notify(`MCPorter ${ver} ready`, "info");
+			ctx.ui.notify(`MCPorter ${ver} ready`, "info");
 		} catch {
-			ctx.ui.notify(
-				"MCPorter not found. Install with: npm i -g mcporter",
-				"error",
-			);
+			ctx.ui.notify("MCPorter not found — attempting auto-install…", "warning");
+			try {
+				await new Promise<void>((resolve, reject) => {
+					exec("npm install -g mcporter", { timeout: 60000 }, (err) => {
+						if (err) reject(err);
+						else resolve();
+					});
+				});
+				const ver = (await runMcporter(["--version"], undefined, 5000)).trim();
+				ctx.ui.notify(`MCPorter ${ver} auto-installed ✓`, "info");
+			} catch {
+				ctx.ui.notify(
+					"MCPorter auto-install failed. Install manually: npm i -g mcporter",
+					"error",
+				);
+			}
 		}
 	});
 }

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

@@ -157,11 +157,13 @@ export function registerNativeSearchHooks(pi: NativeSearchPI): { getIsAnthropic:
     const hasBrave = !!process.env.BRAVE_API_KEY;
     const hasJina = !!process.env.JINA_API_KEY;
     const hasAnswers = !!process.env.BRAVE_ANSWERS_KEY;
+    const hasTavily = !!process.env.TAVILY_API_KEY;
 
     const parts: string[] = ["Web search v4 loaded"];
     if (hasBrave) parts.push("Brave ✓");
     if (hasAnswers) parts.push("Answers ✓");
     if (hasJina) parts.push("Jina ✓");
+    if (hasTavily) parts.push("Tavily ✓");
 
     ctx.ui.notify(parts.join(" · "), "info");
   });

package/dist/resources/extensions/search-the-web/tool-fetch-page.ts

@@ -15,7 +15,7 @@ import { Type } from "@sinclair/typebox";
 
 import { LRUTTLCache } from "./cache.js";
 import { fetchSimple, HttpError } from "./http.js";
-import { extractDomain } from "./url-utils.js";
+import { extractDomain, isBlockedUrl } from "./url-utils.js";
 import { formatPageContent, type FormatPageOptions } from "./format.js";
 import { getOllamaApiKey } from "./provider.js";
 
@@ -416,6 +416,14 @@ export function registerFetchPageTool(pi: ExtensionAPI) {
         };
       }
 
+      if (isBlockedUrl(url)) {
+        return {
+          content: [{ type: "text", text: `Blocked URL: requests to private/internal addresses are not allowed.` }],
+          isError: true,
+          details: { error: "SSRF blocked", url } satisfies Partial<FetchPageDetails>,
+        };
+      }
+
       // ------------------------------------------------------------------
       // Cache lookup (full content cached, offset/truncation applied after)
       // ------------------------------------------------------------------

package/dist/resources/extensions/search-the-web/url-utils.ts

@@ -1,7 +1,41 @@
 /**
- * URL normalization and query utilities.
+ * URL normalization, query utilities, and SSRF protection.
  */
 
+const BLOCKED_HOSTNAMES = new Set([
+  "localhost",
+  "metadata.google.internal",
+  "instance-data",
+]);
+
+const PRIVATE_IP_PATTERNS = [
+  /^127\./,
+  /^10\./,
+  /^172\.(1[6-9]|2\d|3[01])\./,
+  /^192\.168\./,
+  /^169\.254\./,
+  /^0\./,
+  /^::1$/,
+  /^fc00:/i,
+  /^fd/i,
+  /^fe80:/i,
+];
+
+export function isBlockedUrl(url: string): boolean {
+  try {
+    const parsed = new URL(url);
+    if (parsed.protocol !== "https:" && parsed.protocol !== "http:") return true;
+    const hostname = parsed.hostname.toLowerCase();
+    if (BLOCKED_HOSTNAMES.has(hostname)) return true;
+    for (const pattern of PRIVATE_IP_PATTERNS) {
+      if (pattern.test(hostname)) return true;
+    }
+    return false;
+  } catch {
+    return true;
+  }
+}
+
 /** Normalize a search query into a stable cache key. */
 export function normalizeQuery(query: string): string {
   return query.trim().toLowerCase().replace(/\s+/g, " ").normalize("NFC");

package/dist/resources/extensions/shared/terminal.ts

@@ -5,7 +5,7 @@
  * Terminals that lack this support silently swallow the key combos.
  */
 
-const UNSUPPORTED_TERMS = ["apple_terminal"];
+const UNSUPPORTED_TERMS = ["apple_terminal", "warpterm"];
 
 export function supportsCtrlAltShortcuts(): boolean {
   const term = (process.env.TERM_PROGRAM || "").toLowerCase();

package/dist/resources/extensions/universal-config/discovery.ts

@@ -58,6 +58,8 @@ export async function discoverAllConfigs(
   const rules = allItems.filter((i) => i.type === "rule").length;
   const contextFiles = allItems.filter((i) => i.type === "context-file").length;
   const settings = allItems.filter((i) => i.type === "settings").length;
+  const claudeSkills = allItems.filter((i) => i.type === "claude-skill").length;
+  const claudePlugins = allItems.filter((i) => i.type === "claude-plugin").length;
   const toolsWithConfig = toolResults.filter((r) => r.items.length > 0).length;
 
   return {
@@ -68,6 +70,8 @@ export async function discoverAllConfigs(
       rules,
       contextFiles,
       settings,
+      claudeSkills,
+      claudePlugins,
       totalItems: allItems.length,
       toolsScanned: TOOLS.length,
       toolsWithConfig,

package/dist/resources/extensions/universal-config/format.ts

@@ -23,7 +23,7 @@ export function formatDiscoveryForTool(result: DiscoveryResult): string {
     return lines.join("\n");
   }
 
-  lines.push(`Found: ${summary.mcpServers} MCP server(s), ${summary.rules} rule(s), ${summary.contextFiles} context file(s), ${summary.settings} settings file(s)`);
+  lines.push(`Found: ${summary.mcpServers} MCP server(s), ${summary.rules} rule(s), ${summary.contextFiles} context file(s), ${summary.settings} settings file(s), ${summary.claudeSkills} Claude skill(s), ${summary.claudePlugins} Claude plugin(s)`);
   lines.push("");
 
   for (const toolResult of result.tools) {
@@ -70,9 +70,24 @@ export function formatDiscoveryForTool(result: DiscoveryResult): string {
       lines.push(`  Settings (${byType.settings.length}):`);
       for (const item of byType.settings) {
         if (item.type !== "settings") continue;
-        const keys = Object.keys(item.data).slice(0, 5);
-        const suffix = Object.keys(item.data).length > 5 ? ` +${Object.keys(item.data).length - 5} more` : "";
-        lines.push(`    - ${item.source.path} (${item.source.level}): keys: ${keys.join(", ")}${suffix}`);
+        lines.push(`    - ${item.source.path} (${item.source.level})`);
+      }
+    }
+
+    if (byType["claude-skill"]?.length) {
+      lines.push(`  Claude Skills (${byType["claude-skill"].length}):`);
+      for (const item of byType["claude-skill"]) {
+        if (item.type !== "claude-skill") continue;
+        lines.push(`    - ${item.name} (${item.source.level}) ${item.path}`);
+      }
+    }
+
+    if (byType["claude-plugin"]?.length) {
+      lines.push(`  Claude Plugins (${byType["claude-plugin"].length}):`);
+      for (const item of byType["claude-plugin"]) {
+        if (item.type !== "claude-plugin") continue;
+        const label = item.packageName ? `${item.name} [${item.packageName}]` : item.name;
+        lines.push(`    - ${label} (${item.source.level}) ${item.path}`);
       }
     }
 
@@ -111,6 +126,8 @@ export function formatDiscoveryForCommand(result: DiscoveryResult): string[] {
   lines.push(`  Rules:       ${summary.rules}`);
   lines.push(`  Context:     ${summary.contextFiles}`);
   lines.push(`  Settings:    ${summary.settings}`);
+  lines.push(`  Claude skills: ${summary.claudeSkills}`);
+  lines.push(`  Claude plugins: ${summary.claudePlugins}`);
   lines.push("");
 
   for (const toolResult of result.tools) {
@@ -122,6 +139,8 @@ export function formatDiscoveryForCommand(result: DiscoveryResult): string[] {
     if (counts.rule) parts.push(`${counts.rule} rules`);
     if (counts["context-file"]) parts.push(`${counts["context-file"]} context`);
     if (counts.settings) parts.push(`${counts.settings} settings`);
+    if (counts["claude-skill"]) parts.push(`${counts["claude-skill"]} Claude skills`);
+    if (counts["claude-plugin"]) parts.push(`${counts["claude-plugin"]} Claude plugins`);
 
     lines.push(`  ${toolResult.tool.name}: ${parts.join(", ")}`);
 
@@ -131,6 +150,18 @@ export function formatDiscoveryForCommand(result: DiscoveryResult): string[] {
       if (server.type !== "mcp-server") continue;
       lines.push(`    MCP: ${server.name} (${server.source.level})`);
     }
+
+    const claudeSkills = toolResult.items.filter((i) => i.type === "claude-skill");
+    for (const skill of claudeSkills) {
+      if (skill.type !== "claude-skill") continue;
+      lines.push(`    Skill: ${skill.name} (${skill.source.level})`);
+    }
+
+    const claudePlugins = toolResult.items.filter((i) => i.type === "claude-plugin");
+    for (const plugin of claudePlugins) {
+      if (plugin.type !== "claude-plugin") continue;
+      lines.push(`    Plugin: ${plugin.name} (${plugin.source.level})`);
+    }
   }
 
   if (result.warnings.length > 0) {