@dyyz1993/pi-coding-agent 0.74.28 → 0.74.31

package/dist/extensions/bash-ext/index.ts

@@ -73,6 +73,7 @@ type BashToolDetails = _BashToolDetails & {
 };
 
 const DEFAULT_TIMEOUT_SECONDS = 300;
+const DEFAULT_BACKGROUND_AFTER_SECONDS = 120;
 
 const bashSchema = Type.Object({
 	command: Type.String({ description: "Bash command to execute" }),
@@ -179,83 +180,105 @@ export default function (pi: ExtensionAPI) {
 		});
 
 		channel.handle("kill", ({ toolCallId }) => {
-			if (!toolCallId) return;
+			if (!toolCallId) return { ok: false, reason: "not_found" };
 			const m = managed.get(toolCallId);
-			if (m?.proc.pid) {
-				killProcessTree(m.proc.pid);
-				m.proc.status = "terminated";
-				m.proc.endedAt = Date.now();
-				m.resolved = true;
-				m.killedByUser = true;
-				const durationMs = m.proc.endedAt - m.proc.startedAt;
-				if (m.logStream) m.logStream.end();
+			if (!m) {
+				// Process already exited — emit terminated event so frontend can sync state
 				channel?.emit("terminated", {
 					type: "terminated",
 					toolCallId,
-					pid: m.proc.pid,
+					pid: undefined,
 					processes: Array.from(managed.values()).map((x) => x.proc),
 					timestamp: Date.now(),
 				});
-				m.resolve({
-					content: [
-						{
-							type: "text",
-							text: `${m.proc.output || "(no output)"}\n\n[User cancelled after ${formatDuration(durationMs)}, PID: ${m.proc.pid}${m.proc.logPath ? `. Log: ${m.proc.logPath}` : ""}]`,
-						},
-					],
-					details: {
-						terminated: {
-							reason: "user_cancel",
-							pid: m.proc.pid,
-							command: m.proc.command,
-							startedAt: m.proc.startedAt,
-							endedAt: m.proc.endedAt,
-							durationMs,
-							logPath: m.proc.logPath,
-						},
-					},
-				});
+				return { ok: true, alreadyExited: true };
 			}
+			if (m.proc.pid) {
+				killProcessTree(m.proc.pid);
+			}
+			m.proc.status = "terminated";
+			m.proc.endedAt = Date.now();
+			m.resolved = true;
+			m.killedByUser = true;
+			const durationMs = m.proc.endedAt - m.proc.startedAt;
+			if (m.logStream) m.logStream.end();
+			channel?.emit("terminated", {
+				type: "terminated",
+				toolCallId,
+				pid: m.proc.pid,
+				processes: Array.from(managed.values()).map((x) => x.proc),
+				timestamp: Date.now(),
+			});
+			m.resolve({
+				content: [
+					{
+						type: "text",
+						text: `${m.proc.output || "(no output)"}\n\n[User cancelled after ${formatDuration(durationMs)}, PID: ${m.proc.pid ?? "unknown"}${m.proc.logPath ? `. Log: ${m.proc.logPath}` : ""}]`,
+					},
+				],
+				details: {
+					terminated: {
+						reason: "user_cancel",
+						pid: m.proc.pid,
+						command: m.proc.command,
+						startedAt: m.proc.startedAt,
+						endedAt: m.proc.endedAt,
+						durationMs,
+						logPath: m.proc.logPath,
+					},
+				},
+			});
+			return { ok: true };
 		});
 
 		channel.handle("background", ({ toolCallId }) => {
-			if (!toolCallId) return;
+			if (!toolCallId) return { ok: false, reason: "not_found" };
 			const m = managed.get(toolCallId);
-			if (m) {
-				m.proc.status = "background";
-				m.resolved = true;
-				m.backgrounded = true;
-				m.outputSubscribed = false;
-				createLogStream(m);
-				const durationMs = Date.now() - m.proc.startedAt;
-				channel?.emit("background", {
-					type: "background",
+			if (!m) {
+				// Process already exited — emit terminated event so frontend can sync state
+				channel?.emit("terminated", {
+					type: "terminated",
 					toolCallId,
-					pid: m.proc.pid,
-					data: m.proc.output.slice(-2000),
+					pid: undefined,
 					processes: Array.from(managed.values()).map((x) => x.proc),
 					timestamp: Date.now(),
 				});
-						const outputPreview = m.proc.output ? takeLastLines(m.proc.output, BG_PREVIEW_LINES) : "(no output yet)";
-						m.resolve({
-							content: [
-								{
-									type: "text",
-									text: `${outputPreview}\n\n[Moved to background after ${formatDuration(durationMs)}, PID: ${m.proc.pid ?? "unknown"}. <bashId>${m.proc.bashId}</bashId>. Log: ${m.proc.logPath}. Use get_background_process with <bashId>${m.proc.bashId}</bashId> to check progress.]`,
-								},
-							],
-					details: {
-						background: {
-							pid: m.proc.pid,
-							command: m.proc.command,
-							startedAt: m.proc.startedAt,
-							durationMs,
-							logPath: m.proc.logPath,
-							detached: false,
-						},
-					},
-				});
+				return { ok: true, alreadyExited: true };
 			}
+			m.proc.status = "background";
+			m.resolved = true;
+			m.backgrounded = true;
+			m.outputSubscribed = false;
+			createLogStream(m);
+			const durationMs = Date.now() - m.proc.startedAt;
+			channel?.emit("background", {
+				type: "background",
+				toolCallId,
+				pid: m.proc.pid,
+				data: m.proc.output.slice(-2000),
+				processes: Array.from(managed.values()).map((x) => x.proc),
+				timestamp: Date.now(),
+			});
+			const outputPreview = m.proc.output ? takeLastLines(m.proc.output, BG_PREVIEW_LINES) : "(no output yet)";
+			m.resolve({
+				content: [
+					{
+						type: "text",
+						text: `${outputPreview}\n\n[Moved to background after ${formatDuration(durationMs)}, PID: ${m.proc.pid ?? "unknown"}. <bashId>${m.proc.bashId}</bashId>. Log: ${m.proc.logPath}. Use get_background_process with <bashId>${m.proc.bashId}</bashId> to check progress.]`,
+					},
+				],
+				details: {
+					background: {
+						pid: m.proc.pid,
+						command: m.proc.command,
+						startedAt: m.proc.startedAt,
+						durationMs,
+						logPath: m.proc.logPath,
+						detached: false,
+					},
+				},
+			});
+			return { ok: true };
 		});
 
 		channel.handle("subscribe_output", ({ toolCallId }) => {
@@ -318,8 +341,9 @@ export default function (pi: ExtensionAPI) {
 			_ctx?: ExtensionContext,
 		): Promise<AgentToolResult<BashToolDetails>> {
 			return new Promise((resolve, reject) => {
-				const effectiveTimeout = timeout ?? DEFAULT_TIMEOUT_SECONDS;
-				const effectiveBackgroundAfter = backgroundAfter !== undefined && backgroundAfter < effectiveTimeout ? backgroundAfter : undefined;
+			const effectiveTimeout = timeout ?? DEFAULT_TIMEOUT_SECONDS;
+			const rawBackgroundAfter = backgroundAfter ?? DEFAULT_BACKGROUND_AFTER_SECONDS;
+			const effectiveBackgroundAfter = rawBackgroundAfter < effectiveTimeout ? rawBackgroundAfter : undefined;
 				const cwd = cwdParam ?? _ctx?.cwd ?? process.cwd();
 				const bashId = generateBashId();
 

package/dist/extensions/file-snapshot/index.ts

@@ -4,7 +4,10 @@ export default function fileSnapshot(pi: ExtensionAPI) {
 	const channel = pi.registerChannel("file-snapshot");
 
 	channel.onReceive(async (msg) => {
-		const ctx = msg.context as ExtensionContext;
+		const ctx = msg.context as ExtensionContext | undefined;
+		if (!ctx) {
+			return { error: "Extension context not available in channel message. This operation is not supported via RPC client channel calls." };
+		}
 		const mgr = ctx.fileSnapshotManager;
 		if (!mgr) {
 			return { error: "fileSnapshotManager not available" };

package/dist/extensions/lsp/lsp/index.ts

@@ -11,6 +11,7 @@ import { createDependencyResolver } from "./utils/dependency-resolver.js";
 import { createWriteThroughHooks } from "./hooks/writethrough.js";
 import { createLspToolRouter } from "./tools/lsp-tool.js";
 import { createServerMetricsCollector } from "./monitoring/server-metrics.js";
+import { scanProjectFileTypes, filterServersByProject } from "./utils/project-scanner.js";
 
 export interface LspChannelEvent {
 	event:
@@ -143,14 +144,31 @@ export default function lspExtension(pi: ExtensionAPI): void {
 
 		const config = configResolver.resolve();
 
+		// Scan project for file types and filter servers
+		const cwd = process.cwd();
+		const scanResult = scanProjectFileTypes(cwd);
+		const filteredServers = filterServersByProject(config.servers, scanResult);
+		const skippedNames = config.servers
+			.filter((s) => !filteredServers.some((f) => f.name === s.name))
+			.map((s) => s.name);
+		const discoveredExts = [...scanResult.discoveredExtensions].sort();
+
+		if (skippedNames.length > 0) {
+			console.log(
+				`[lsp] Project scan found [${discoveredExts.join(", ")}], starting ${filteredServers.length}/${config.servers.length} servers (skipped: ${skippedNames.join(", ")})`,
+			);
+		}
+
+		const filteredConfig = { ...config, servers: filteredServers };
+
 		lspChannel?.emit("startup_begin", {
 			event: "startup_begin",
 			timestamp: Date.now(),
-			servers: config.servers.map((s) => ({ name: s.name, state: "starting", fileTypes: s.fileTypes })),
-			totalServers: config.servers.length,
+			servers: filteredConfig.servers.map((s) => ({ name: s.name, state: "starting", fileTypes: s.fileTypes })),
+			totalServers: filteredConfig.servers.length,
 		});
 
-		await runtime.start(config);
+		await runtime.start(filteredConfig);
 		const status = runtime.getStatus();
 
 		for (const srv of status.servers) {

package/dist/extensions/lsp/lsp/utils/project-scanner.ts

@@ -0,0 +1,102 @@
+import { execSync } from "node:child_process";
+import { existsSync } from "node:fs";
+import { extname, join } from "node:path";
+import type { ResolvedLspServerConfig } from "../config/resolver.js";
+
+export interface ProjectScanResult {
+	discoveredExtensions: Set<string>;
+}
+
+/**
+ * Scan the project for file types present on disk.
+ * Uses `git ls-files` when available (fast, respects .gitignore),
+ * falls back to a shallow `find` otherwise.
+ */
+export function scanProjectFileTypes(cwd: string): ProjectScanResult {
+	const extensions = new Set<string>();
+
+	// Strategy 1: git ls-files (fast, respects gitignore)
+	const gitFiles = tryGitLsFiles(cwd);
+	if (gitFiles.length > 0) {
+		for (const file of gitFiles) {
+			const ext = extname(file).toLowerCase();
+			if (ext) {
+				extensions.add(ext);
+			}
+		}
+		return { discoveredExtensions: extensions };
+	}
+
+	// Strategy 2: shallow find (maxdepth 3, skip node_modules etc.)
+	try {
+		const output = execSync(
+			'find . -maxdepth 3 -type f -not -path "*/node_modules/*" -not -path "*/.git/*" -not -path "*/target/*" -not -path "*/dist/*" -not -path "*/.pi/*" 2>/dev/null | head -2000',
+			{ cwd, timeout: 3000, encoding: "utf8" },
+		);
+		for (const line of output.split("\n")) {
+			const trimmed = line.trim();
+			if (!trimmed) continue;
+			const ext = extname(trimmed).toLowerCase();
+			if (ext) {
+				extensions.add(ext);
+			}
+		}
+	} catch {
+		// If scan fails, return empty — will fall back to starting all servers
+	}
+
+	return { discoveredExtensions: extensions };
+}
+
+function tryGitLsFiles(cwd: string): string[] {
+	// Check if we're in a git repo
+	if (!existsSync(join(cwd, ".git"))) {
+		return [];
+	}
+
+	try {
+		const output = execSync("git ls-files --cached --others --exclude-standard 2>/dev/null | head -2000", {
+			cwd,
+			timeout: 3000,
+			encoding: "utf8",
+		});
+		const files = output.split("\n").filter(Boolean);
+		return files.length > 0 ? files : [];
+	} catch {
+		return [];
+	}
+}
+
+/**
+ * Filter server configs to only those whose fileTypes match files in the project.
+ * Servers WITHOUT fileTypes (catch-all) are always included.
+ * If the project has no discoverable files, all servers are started (safe fallback).
+ */
+export function filterServersByProject(
+	servers: ResolvedLspServerConfig[],
+	scanResult: ProjectScanResult,
+): ResolvedLspServerConfig[] {
+	const { discoveredExtensions } = scanResult;
+
+	// Safe fallback: if scan found nothing, start everything
+	if (discoveredExtensions.size === 0) {
+		return servers;
+	}
+
+	const filtered: ResolvedLspServerConfig[] = [];
+	for (const server of servers) {
+		// No fileTypes = catch-all server, always include
+		if (!server.fileTypes || server.fileTypes.length === 0) {
+			filtered.push(server);
+			continue;
+		}
+
+		// Include if ANY of the server's fileTypes exist in the project
+		const hasMatch = server.fileTypes.some((ft) => discoveredExtensions.has(ft.toLowerCase()));
+		if (hasMatch) {
+			filtered.push(server);
+		}
+	}
+
+	return filtered;
+}

package/dist/extensions/session-supervisor/config.ts

@@ -15,7 +15,9 @@ const DEFAULT_CONFIG: SupervisorConfig = {
     maxContinueCount: 5,
     defaultDelayMs: 30_000,
     pauseThresholdMs: 300_000,
-    guards: [],
+    guards: [
+        { name: "incomplete-keywords", type: "keyword", enable: true, keywords: ["TODO", "FIXME", "WIP", "HACK"] },
+    ],
 };
 
 export function loadConfig(sessionDataDir: string, projectDataDir: string): SupervisorConfig {

package/dist/extensions/session-supervisor/index.ts

@@ -36,6 +36,10 @@ function log(msg: string) {
     appendFileSync(LOG_FILE, line);
 }
 
+const DEFAULT_GUARDS: GuardConfig[] = [
+    { name: "incomplete-keywords", type: "keyword", enable: true, keywords: ["TODO", "FIXME", "WIP", "HACK"] },
+];
+
 export default function sessionSupervisorExtension(pi: ExtensionAPI) {
     let config: SupervisorConfig;
     let enabled = false;
@@ -72,8 +76,8 @@ export default function sessionSupervisorExtension(pi: ExtensionAPI) {
     const { server: channel } =
         createTypedChannel<SupervisorChannelContract>(rawChannel);
 
-    channel.handle("supervisor.getStatus", async () => getStatus());
-    channel.handle("supervisor.requestPause", async (params) => {
+    channel.handle("getStatus", async () => getStatus());
+    channel.handle("requestPause", async (params) => {
         const delayMs = params.delayMs ?? config.defaultDelayMs;
         const result = schedulerInstance.scheduleContinue(
             "manual-pause",
@@ -90,7 +94,7 @@ export default function sessionSupervisorExtension(pi: ExtensionAPI) {
         return result;
     });
 
-    channel.handle("supervisor.cancelPause", async () => {
+    channel.handle("cancelPause", async () => {
         const cancelled = schedulerInstance.cancelTimer("manual-pause");
         if (cancelled) {
             channel.emit("supervisor.pauseCancelled", { reason: "Cancelled via channel" });
@@ -98,7 +102,7 @@ export default function sessionSupervisorExtension(pi: ExtensionAPI) {
         return { cancelled };
     });
 
-    channel.handle("supervisor.forceContinue", async (params) => {
+    channel.handle("forceContinue", async (params) => {
         schedulerInstance.cancelAll();
         currentState = "continuing";
         emitStatusChanged();
@@ -106,7 +110,7 @@ export default function sessionSupervisorExtension(pi: ExtensionAPI) {
         return { triggered: true };
     });
 
-    channel.handle("supervisor.disable", async () => {
+    channel.handle("disable", async () => {
         enabled = false;
         schedulerInstance.cancelAll();
         currentState = "disabled";
@@ -114,16 +118,16 @@ export default function sessionSupervisorExtension(pi: ExtensionAPI) {
         return { disabled: true };
     });
 
-    channel.handle("supervisor.enable", async () => {
+    channel.handle("enable", async () => {
         enabled = true;
         currentState = "idle";
         emitStatusChanged();
         return { enabled: true };
     });
 
-    channel.handle("supervisor.getTaskReport", async () => ({ tasks: lastTaskReports }));
+    channel.handle("getTaskReport", async () => ({ tasks: lastTaskReports }));
 
-    channel.handle("supervisor.checkToolStatus", async (params) => {
+    channel.handle("checkToolStatus", async (params) => {
         const targetChannelName = params.channelName ?? params.toolName;
         try {
             const result = await rawChannel.call(
@@ -222,8 +226,8 @@ export default function sessionSupervisorExtension(pi: ExtensionAPI) {
             config.smallModel = modelFlag;
         }
 
-        // Determine project root for specs file resolution
-        projectRoot = ctx.projectDataDir ?? process.cwd();
+        // projectRoot is the git root (worktree-aware), correct for specs file resolution
+        projectRoot = ctx.projectRoot ?? ctx.cwd;
 
         schedulerInstance = new Scheduler(
             config.maxContinueCount,
@@ -276,7 +280,29 @@ export default function sessionSupervisorExtension(pi: ExtensionAPI) {
                 log(`guard[${guard.name}] completed=${result.completed}, remaining=${result.remainingItems.length}`);
             }
 
-            // Also run the generic model-based check as fallback (if no custom guards or as additional check)
+            lastTaskReports = reports;
+            channel.emit("supervisor.taskReport", { tasks: reports });
+
+            // Phase 2: If any guard says incomplete → continue immediately
+            const hasIncompleteGuards = guardResults.some((r) => !r.completed && r.remainingItems.length > 0);
+
+            if (hasIncompleteGuards) {
+                log(`Guards detected incomplete tasks`);
+                specsIterationCount++;
+
+                const continueMessage = generateContinueMessage(
+                    activeGuards,
+                    guardResults,
+                    null,
+                );
+
+                lastCheckResult = { completed: false, confidence: 0.9, incompleteTasks: [], guardResults };
+
+                scheduleContinue(continueMessage);
+                return;
+            }
+
+            // Phase 3: All guards passed → run fallback model check
             const modelCheck = await checkWithSmallModel(
                 event.messages as Array<{ role: string; content: unknown }>,
                 config,
@@ -284,14 +310,9 @@ export default function sessionSupervisorExtension(pi: ExtensionAPI) {
                 ctx.sessionSignal,
             );
 
-            lastTaskReports = reports;
-            channel.emit("supervisor.taskReport", { tasks: reports });
-
-            // Phase 2: Determine if we should continue
-            const hasIncompleteGuards = guardResults.some((r) => !r.completed && r.remainingItems.length > 0);
             const hasModelIncomplete = modelCheck.completed === false || modelCheck.incompleteTasks.length > 0;
 
-            if (!hasIncompleteGuards && !hasModelIncomplete) {
+            if (!hasModelIncomplete) {
                 log(`All guards passed + model check passed → idle`);
                 currentState = "idle";
                 lastCheckResult = { ...modelCheck, guardResults };
@@ -299,10 +320,8 @@ export default function sessionSupervisorExtension(pi: ExtensionAPI) {
                 return;
             }
 
-            // Phase 3: Generate continue message from first incomplete guard
-            log(`Incomplete tasks detected, scheduling continue...`);
-            specsIterationCount++;
-
+            // Phase 4: Model detected incompleteness → continue with model's assessment
+            log(`Model detected incomplete tasks`);
             const continueMessage = generateContinueMessage(
                 activeGuards,
                 guardResults,
@@ -310,41 +329,7 @@ export default function sessionSupervisorExtension(pi: ExtensionAPI) {
             );
 
             lastCheckResult = { ...modelCheck, guardResults };
-
-            // Phase 4: Schedule continue
-            const delayMs = config.defaultDelayMs;
-
-            if (schedulerInstance.shouldPause(delayMs)) {
-                currentState = "paused";
-                emitStatusChanged();
-                channel.emit("supervisor.pauseRequested", {
-                    delayMs,
-                    reason: continueMessage.slice(0, 200),
-                });
-            }
-
-            pi.background(async (signal) => {
-                await new Promise<void>((resolve) => {
-                    const timer = setTimeout(resolve, delayMs);
-                    signal.addEventListener("abort", () => {
-                        clearTimeout(timer);
-                        resolve();
-                    });
-                });
-
-                if (signal.aborted) return;
-
-                currentState = "continuing";
-                emitStatusChanged();
-                pi.sendMessage(
-                    {
-                        customType: "supervisor_continue",
-                        content: continueMessage,
-                        display: true,
-                    },
-                    { triggerTurn: true },
-                );
-            });
+            scheduleContinue(continueMessage);
         } catch (err) {
             log(`agent_end error: ${err instanceof Error ? err.message : String(err)}`);
             currentState = "idle";
@@ -359,8 +344,46 @@ export default function sessionSupervisorExtension(pi: ExtensionAPI) {
 
     // ── Guard Check Functions ──
 
+    function scheduleContinue(continueMessage: string): void {
+        const delayMs = config.defaultDelayMs;
+
+        if (schedulerInstance.shouldPause(delayMs)) {
+            currentState = "paused";
+            emitStatusChanged();
+            channel.emit("supervisor.pauseRequested", {
+                delayMs,
+                reason: continueMessage.slice(0, 200),
+            });
+        }
+
+        pi.background(async (signal) => {
+            await new Promise<void>((resolve) => {
+                const timer = setTimeout(resolve, delayMs);
+                signal.addEventListener("abort", () => {
+                    clearTimeout(timer);
+                    resolve();
+                });
+            });
+
+            if (signal.aborted) return;
+
+            currentState = "continuing";
+            emitStatusChanged();
+            pi.sendMessage(
+                {
+                    customType: "supervisor_continue",
+                    content: continueMessage,
+                    display: true,
+                },
+                { triggerTurn: true },
+            );
+        });
+    }
+
     function getActiveGuards(): GuardConfig[] {
-        return (config.guards ?? []).filter((g) => g.enable !== false);
+        const guards = config.guards ?? [];
+        const source = guards.length > 0 ? guards : DEFAULT_GUARDS;
+        return source.filter((g) => g.enable !== false);
     }
 
     async function runGuardCheck(
@@ -599,7 +622,7 @@ export default function sessionSupervisorExtension(pi: ExtensionAPI) {
     function generateContinueMessage(
         guards: GuardConfig[],
         results: GuardCheckResult[],
-        modelCheck: CheckResult,
+        modelCheck: CheckResult | null,
     ): string {
         // Priority: first incomplete guard generates the message
         for (let i = 0; i < guards.length; i++) {
@@ -640,11 +663,15 @@ export default function sessionSupervisorExtension(pi: ExtensionAPI) {
         }
 
         // Fallback: generic continue from model check
-        const tasks = modelCheck.incompleteTasks.map((t) => `[${t.severity}] ${t.description}`);
-        return CONTINUE_PROMPT(
-            modelCheck.modelResponse ?? "Model detected incomplete tasks",
-            tasks.length > 0 ? tasks : ["Continue working"],
-        );
+        if (modelCheck) {
+            const tasks = modelCheck.incompleteTasks.map((t) => `[${t.severity}] ${t.description}`);
+            return CONTINUE_PROMPT(
+                modelCheck.modelResponse ?? "Model detected incomplete tasks",
+                tasks.length > 0 ? tasks : ["Continue working"],
+            );
+        }
+
+        return CONTINUE_PROMPT("Incomplete tasks detected", ["Please continue working on remaining items."]);
     }
 
     function generateBlockMessage(