@sayknow-cli/coding-agent 0.3.16 → 0.4.1

package/src/tools/resource-gc.ts

@@ -75,12 +75,31 @@ const defaultDeps: ResourceGcDeps = {
 
 // ── Controller state (process-global; tabs/browsers are module-global too) ──────────────────
 const activeSessions = new Map<string, Settings>();
-let timer: ReturnType<typeof setTimeout> | null = null;
+
+interface ScheduleOwner {
+	generation: number;
+	token: number;
+}
+
+interface DeferredSchedule {
+	generation: number;
+	deadline: number;
+}
+
+interface WorkOwner {
+	generation: number;
+	source: "timer" | "external";
+}
+
+let pendingTimer: NodeJS.Timeout | null = null;
+let pendingDeadline: number | null = null;
+let pendingOwner: ScheduleOwner | null = null;
+let deferredSchedule: DeferredSchedule | null = null;
+let inProgressOwner: WorkOwner | null = null;
 let stopped = false;
-// Bumped on every stop so an in-flight tick from a previous schedule cannot reschedule after a
-// stop+re-register and leak a duplicate timer.
 let timerGeneration = 0;
-let inProgress = false;
+let nextTimerToken = 0;
+let schedulerNow = (): number => performance.now();
 let rssWarningActive = false;
 let lastScreenshotScanAt = 0;
 let deps: ResourceGcDeps = defaultDeps;
@@ -96,8 +115,20 @@ export interface ResourceGcRegistration {
  * session unregisters.
  */
 export function registerResourceGcSession(reg: ResourceGcRegistration): () => void {
+	const isNewSession = !activeSessions.has(reg.sessionId);
 	activeSessions.set(reg.sessionId, reg.settings);
-	ensureTimerStarted();
+	stopped = false;
+	if (isNewSession) {
+		const deadline = schedulerNow() + resolveSweepIntervalMs(reg.settings);
+		if (
+			inProgressOwner?.generation === timerGeneration &&
+			(pendingDeadline === null || pendingDeadline <= deadline)
+		) {
+			deferSchedule(timerGeneration, deadline);
+		} else {
+			requestSchedule(deadline);
+		}
+	}
 	let unregistered = false;
 	return () => {
 		if (unregistered) return;
@@ -113,51 +144,78 @@ function currentSweepIntervalMs(): number {
 	return Number.isFinite(min) ? min : DEFAULT_SWEEP_INTERVAL_MS;
 }
 
-function ensureTimerStarted(): void {
-	if (timer) return;
-	stopped = false;
-	scheduleNextSweep();
+function clearPendingSchedule(): void {
+	if (pendingTimer) clearTimeout(pendingTimer);
+	pendingTimer = null;
+	pendingDeadline = null;
+	pendingOwner = null;
 }
 
-// Recursive setTimeout (not setInterval) so the cadence is recomputed every cycle and later
-// session register/unregister changes to resourceGc.sweepIntervalMs are honored live.
-function scheduleNextSweep(): void {
-	if (stopped || activeSessions.size === 0) {
-		timer = null;
+function requestSchedule(deadline: number): void {
+	if (stopped || activeSessions.size === 0) return;
+	if (pendingDeadline !== null && pendingDeadline <= deadline) return;
+	clearPendingSchedule();
+	const owner = { generation: timerGeneration, token: ++nextTimerToken };
+	pendingDeadline = deadline;
+	pendingOwner = owner;
+	pendingTimer = setTimeout(
+		() => {
+			void handleTimerCallback(owner, deadline);
+		},
+		Math.max(0, deadline - schedulerNow()),
+	);
+	pendingTimer.unref?.();
+}
+
+function deferSchedule(generation: number, deadline: number): void {
+	if (generation !== timerGeneration) return;
+	if (deferredSchedule?.generation === generation) {
+		deferredSchedule.deadline = Math.min(deferredSchedule.deadline, deadline);
 		return;
 	}
-	const generation = timerGeneration;
-	timer = setTimeout(() => {
-		void tickAndReschedule(generation);
-	}, currentSweepIntervalMs());
-	timer.unref?.();
+	deferredSchedule = { generation, deadline };
 }
 
-async function tickAndReschedule(generation: number): Promise<void> {
-	await runTick();
-	// A stop (and possible re-register) happened during the tick: a newer cycle owns the timer now.
-	if (generation !== timerGeneration) return;
-	scheduleNextSweep();
+async function handleTimerCallback(owner: ScheduleOwner, deadline: number): Promise<void> {
+	if (pendingOwner?.generation !== owner.generation || pendingOwner.token !== owner.token) return;
+	pendingTimer = null;
+	pendingDeadline = null;
+	pendingOwner = null;
+	if (inProgressOwner) {
+		deferSchedule(owner.generation, deadline);
+		return;
+	}
+	await runTick(owner.generation, "timer");
+}
+
+function reconcileCurrentSchedule(): void {
+	if (stopped || activeSessions.size === 0 || inProgressOwner) return;
+	const normalDeadline = schedulerNow() + currentSweepIntervalMs();
+	const deferredDeadline = deferredSchedule?.generation === timerGeneration ? deferredSchedule.deadline : null;
+	if (deferredDeadline !== null) deferredSchedule = null;
+	requestSchedule(deferredDeadline === null ? normalDeadline : Math.min(deferredDeadline, normalDeadline));
 }
 
 function stopTimer(): void {
 	stopped = true;
 	timerGeneration++;
-	if (timer) {
-		clearTimeout(timer);
-		timer = null;
-	}
+	clearPendingSchedule();
+	deferredSchedule = null;
 }
 
-async function runTick(): Promise<void> {
-	if (inProgress) return;
-	inProgress = true;
+async function runTick(generation = timerGeneration, source: WorkOwner["source"] = "external"): Promise<void> {
+	if (inProgressOwner || activeSessions.size === 0) return;
+	const owner: WorkOwner = { generation, source };
+	inProgressOwner = owner;
 	try {
 		await sweepOnce(deps);
 	} catch (err) {
 		logger.debug("resource GC sweep failed", { error: (err as Error).message });
 	} finally {
-		inProgress = false;
+		if (inProgressOwner === owner) inProgressOwner = null;
+		// A stale completion only releases its own work lock. Once that lock is released, current
+		// generation demand (which may have deferred behind it) can be reconciled independently.
+		reconcileCurrentSchedule();
 	}
 }
 
@@ -177,7 +235,7 @@ function ownerBrowserPolicy(snapshot: TabGcSnapshot): BrowserGcPolicy | null {
 /** Coarse, ordering-only eligibility; the live recheck in releaseTabIfGcEligible is authoritative. */
 function isCoarselyEligible(snapshot: TabGcSnapshot): boolean {
 	return (
-		snapshot.state === "alive" &&
+		(snapshot.state === "alive" || snapshot.state === "dead") &&
 		snapshot.pendingCount === 0 &&
 		(snapshot.kindTag === "headless" || snapshot.kindTag === "spawned")
 	);
@@ -230,7 +288,7 @@ function evaluateRssPressureWarning(d: ResourceGcDeps): void {
 		return;
 	}
 	const reclaimableRemains = collectIdleCandidates(d).some(
-		c => c.snapshot.ownerId !== undefined && pressured.has(c.snapshot.ownerId),
+		c => c.snapshot.state === "alive" && c.snapshot.ownerId !== undefined && pressured.has(c.snapshot.ownerId),
 	);
 	if (reclaimableRemains) {
 		rssWarningActive = false;
@@ -268,24 +326,55 @@ export function __setResourceGcDepsForTest(overrides: Partial<ResourceGcDeps>):
 	deps = { ...defaultDeps, ...overrides };
 }
 
+export function __setResourceGcSchedulerNowForTest(now: () => number): void {
+	schedulerNow = now;
+}
+
 export async function __runResourceGcTickForTest(): Promise<void> {
 	await runTick();
 }
 
+export async function __runResourceGcTimerCallbackForTest(
+	owner: { generation: number; token: number },
+	deadline: number,
+): Promise<void> {
+	await handleTimerCallback(owner, deadline);
+}
+
 export function __getResourceGcStateForTest(): {
 	timerActive: boolean;
 	sessionCount: number;
 	rssWarningActive: boolean;
 	inProgress: boolean;
+	generation: number;
+	pendingDeadline: number | null;
+	pendingOwner: { generation: number; token: number } | null;
+	deferredDeadline: number | null;
+	deferredGeneration: number | null;
+	activeGeneration: number | null;
 } {
-	return { timerActive: timer !== null, sessionCount: activeSessions.size, rssWarningActive, inProgress };
+	return {
+		timerActive: pendingTimer !== null,
+		sessionCount: activeSessions.size,
+		rssWarningActive,
+		inProgress: inProgressOwner !== null,
+		generation: timerGeneration,
+		pendingDeadline,
+		pendingOwner: pendingOwner ? { ...pendingOwner } : null,
+		deferredDeadline: deferredSchedule?.deadline ?? null,
+		deferredGeneration: deferredSchedule?.generation ?? null,
+		activeGeneration: inProgressOwner?.generation ?? null,
+	};
 }
 
 export function __resetResourceGcForTest(): void {
 	stopTimer();
 	activeSessions.clear();
-	inProgress = false;
+	inProgressOwner = null;
+	deferredSchedule = null;
 	rssWarningActive = false;
 	lastScreenshotScanAt = 0;
+	nextTimerToken = 0;
+	schedulerNow = (): number => performance.now();
 	deps = defaultDeps;
 }

package/src/tools/search-tool-bm25.ts

@@ -10,21 +10,13 @@ import {
 	buildDiscoverableToolSearchIndex,
 	type DiscoverableTool,
 	type DiscoverableToolSearchIndex,
-	formatDiscoverableToolServerSummary,
 	searchDiscoverableTools,
-	summarizeDiscoverableTools,
 } from "../tool-discovery/tool-index";
 import { renderStatusLine, renderTreeList, truncateToWidth } from "../tui";
 import type { ToolSession } from ".";
 import { formatCount, replaceTabs, TRUNCATE_LENGTHS } from "./render-utils";
 import { ToolError } from "./tool-errors";
 
-// Re-export legacy MCP types for back-compat (tests and external callers may reference them)
-export type {
-	DiscoverableMCPSearchIndex,
-	DiscoverableMCPTool,
-} from "../runtime-mcp/discoverable-tool-metadata";
-
 const DEFAULT_LIMIT = 8;
 const TOOL_DISCOVERY_TITLE = "Tool Discovery";
 const COLLAPSED_MATCH_LIMIT = 5;
@@ -78,24 +70,9 @@ function buildSearchToolBm25Content(details: SearchToolBm25Details): string {
 	});
 }
 
-/** Get discoverable tools for description rendering. Falls back to empty array on error. */
 function getDiscoverableToolsForDescription(session: ToolSession): DiscoverableTool[] {
 	try {
-		// Prefer generic method; fall back to legacy MCP-only
-		if (session.getDiscoverableTools) {
-			return session.getDiscoverableTools();
-		}
-		// Legacy MCP path — adapt DiscoverableMCPTool (with `description`) → DiscoverableTool.
-		const legacy = session.getDiscoverableMCPTools?.() ?? [];
-		return legacy.map(t => ({
-			name: t.name,
-			label: t.label,
-			summary: t.description,
-			source: "mcp" as const,
-			serverName: t.serverName,
-			mcpToolName: t.mcpToolName,
-			schemaKeys: t.schemaKeys,
-		}));
+		return session.getDiscoverableTools?.() ?? [];
 	} catch {
 		return [];
 	}
@@ -103,36 +80,18 @@ function getDiscoverableToolsForDescription(session: ToolSession): DiscoverableT
 
 function getDiscoverableToolSearchIndexForExecution(session: ToolSession): DiscoverableToolSearchIndex {
 	try {
-		// Prefer generic cached index
-		if (session.getDiscoverableToolSearchIndex) {
-			const cached = session.getDiscoverableToolSearchIndex();
-			if (cached) return cached;
-		}
-		// Legacy MCP: use cached MCP index. Its documents expose `tool.description` as well as
-		// `tool.summary`, so it is structurally compatible with DiscoverableToolSearchIndex.
-		const mcpCached = session.getDiscoverableMCPSearchIndex?.();
-		if (mcpCached) return mcpCached as unknown as DiscoverableToolSearchIndex;
+		const cached = session.getDiscoverableToolSearchIndex?.();
+		if (cached) return cached;
 	} catch {}
 	return buildDiscoverableToolSearchIndex(getDiscoverableToolsForDescription(session));
 }
 
-/** Resolve the effective selected tool names (generic or legacy MCP). */
 function getSelectedToolNames(session: ToolSession): string[] {
-	if (session.getSelectedDiscoveredToolNames) {
-		return session.getSelectedDiscoveredToolNames();
-	}
-	return session.getSelectedMCPToolNames?.() ?? [];
+	return session.getSelectedDiscoveredToolNames?.() ?? [];
 }
 
-/** Activate tools (generic or legacy MCP fallback). */
 async function activateTools(session: ToolSession, toolNames: string[]): Promise<string[]> {
-	if (session.activateDiscoveredTools) {
-		return session.activateDiscoveredTools(toolNames);
-	}
-	if (session.activateDiscoveredMCPTools) {
-		return session.activateDiscoveredMCPTools(toolNames);
-	}
-	return [];
+	return (await session.activateDiscoveredTools?.(toolNames)) ?? [];
 }
 
 type DiscoveryExecutionSession = ToolSession & {
@@ -140,39 +99,19 @@ type DiscoveryExecutionSession = ToolSession & {
 };
 
 function supportsToolDiscoveryExecution(session: ToolSession): session is DiscoveryExecutionSession {
-	// Supports generic discovery
-	if (
+	return (
 		typeof session.isToolDiscoveryEnabled === "function" &&
 		typeof session.getSelectedDiscoveredToolNames === "function" &&
 		typeof session.activateDiscoveredTools === "function"
-	) {
-		return true;
-	}
-	// Supports legacy MCP discovery
-	if (
-		typeof session.isMCPDiscoveryEnabled === "function" &&
-		typeof session.getSelectedMCPToolNames === "function" &&
-		typeof session.activateDiscoveredMCPTools === "function"
-	) {
-		return true;
-	}
-	return false;
+	);
 }
 
 function isDiscoveryEnabled(session: ToolSession): boolean {
-	if (typeof session.isToolDiscoveryEnabled === "function") {
-		return session.isToolDiscoveryEnabled();
-	}
-	return session.isMCPDiscoveryEnabled?.() ?? false;
+	return session.isToolDiscoveryEnabled?.() ?? false;
 }
 
-export function renderSearchToolBm25Description(discoverableTools: DiscoverableTool[] = []): string {
-	const summary = summarizeDiscoverableTools(discoverableTools);
-	return prompt.render(searchToolBm25Description, {
-		discoverableMCPToolCount: summary.toolCount,
-		discoverableMCPServerSummaries: summary.servers.map(formatDiscoverableToolServerSummary),
-		hasDiscoverableMCPServers: summary.servers.length > 0,
-	});
+export function renderSearchToolBm25Description(): string {
+	return prompt.render(searchToolBm25Description, {});
 }
 
 function renderMatchLines(match: SearchToolBm25Match, theme: Theme): string[] {
@@ -209,9 +148,7 @@ export class SearchToolBm25Tool implements AgentTool<typeof searchToolBm25Schema
 	readonly name = "search_tool_bm25";
 	readonly label = "SearchTools";
 	readonly loadMode = "essential";
-	get description(): string {
-		return renderSearchToolBm25Description(getDiscoverableToolsForDescription(this.session));
-	}
+	readonly description = renderSearchToolBm25Description();
 	readonly parameters = searchToolBm25Schema;
 	readonly strict = true;
 

package/src/tools/sqlite-reader.ts

@@ -12,6 +12,7 @@ const MAX_QUERY_LIMIT = 500;
 const MAX_RENDER_WIDTH = 120;
 const MAX_COLUMN_WIDTH = 40;
 const MIN_COLUMN_WIDTH = 1;
+const SQLITE_USER_TABLE_PREDICATE = "name NOT LIKE 'sqlite!_%' ESCAPE '!'";
 
 type SqliteBinding = Exclude<SQLQueryBindings, Record<string, unknown>>;
 
@@ -182,7 +183,7 @@ function getTableMasterRow(db: Database, table: string): SqliteMasterRow {
 	const row =
 		db
 			.prepare<SqliteMasterRow, [string]>(
-				"SELECT name, sql FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' AND name = ?",
+				`SELECT name, sql FROM sqlite_master WHERE type = 'table' AND ${SQLITE_USER_TABLE_PREDICATE} AND name = ?`,
 			)
 			.get(table) ?? null;
 	if (!row) {
@@ -502,7 +503,7 @@ export function parseSqliteSelector(subPath: string, queryString: string): Sqlit
 export function listTables(db: Database): { name: string; rowCount: number }[] {
 	const names = db
 		.prepare<Pick<SqliteMasterRow, "name">, []>(
-			"SELECT name FROM sqlite_master WHERE type = 'table' AND name NOT LIKE 'sqlite_%' ORDER BY name COLLATE NOCASE",
+			`SELECT name FROM sqlite_master WHERE type = 'table' AND ${SQLITE_USER_TABLE_PREDICATE} ORDER BY name COLLATE NOCASE`,
 		)
 		.all();
 

package/src/tools/subagent-render.ts

@@ -23,6 +23,8 @@ import {
 } from "./render-utils";
 import { type SubagentSnapshot, type SubagentToolDetails, subagentAwaitRenderedStateSignature } from "./subagent";
 
+export { subagentAwaitRenderedStateSignature } from "./subagent";
+
 const PREVIEW_LINES_COLLAPSED = 1;
 const PREVIEW_LINES_EXPANDED = 4;
 const PREVIEW_LINE_WIDTH = 80;
@@ -128,7 +130,7 @@ function renderSubagentStatusLine(snapshot: SubagentSnapshot, theme: Theme, spin
 		theme,
 		snapshot.status === "running" ? spinnerFrame : undefined,
 	);
-	const id = theme.fg("muted", snapshot.id);
+	const id = theme.fg("muted", truncateToWidth(replaceTabs(snapshot.id), PREVIEW_LINE_WIDTH, Ellipsis.Unicode));
 	const status = theme.fg("dim", snapshot.status);
 	const duration = theme.fg("dim", formatDuration(snapshot.durationMs));
 	return `${icon} ${id} ${status} ${duration}`;
@@ -195,7 +197,12 @@ function renderSubagentSnapshotBody(snapshot: SubagentSnapshot, expanded: boolea
 		}
 	}
 
-	if (snapshot.guidance) lines.push(`  ${theme.fg("dim", snapshot.guidance)}`);
+	if (snapshot.guidance) {
+		for (const line of getPreviewLines(snapshot.guidance, 1, PREVIEW_LINE_WIDTH, Ellipsis.Unicode)) {
+			lines.push(`  ${theme.fg("dim", replaceTabs(line))}`);
+		}
+	}
+
 	return lines;
 }
 
@@ -218,6 +225,7 @@ export const subagentToolRenderer = {
 		}
 
 		const runningCount = subagents.filter(s => s.status === "running").length;
+		const interrupted = result.details?.interrupted === true;
 
 		// Each snapshot's rendered-state signature is constant for this component
 		// instance, so compute them at most once; the heavy per-subagent bodies are
@@ -232,11 +240,12 @@ export const subagentToolRenderer = {
 				// it is never gated by the heavy body cache.
 				const header = renderStatusLine(
 					{
-						icon: runningCount > 0 ? "info" : "success",
-						spinnerFrame: runningCount > 0 ? options.spinnerFrame : undefined,
-						title: "Subagent",
-						description:
-							runningCount > 0
+						icon: interrupted ? "warning" : runningCount > 0 ? "info" : "success",
+						spinnerFrame: !interrupted && runningCount > 0 ? options.spinnerFrame : undefined,
+						title: interrupted ? "Subagent await interrupted" : "Subagent",
+						description: interrupted
+							? "child subagents continue"
+							: runningCount > 0
 								? `awaiting ${runningCount} of ${subagents.length}`
 								: `${subagents.length} ${subagents.length === 1 ? "subagent" : "subagents"}`,
 					},
@@ -249,7 +258,9 @@ export const subagentToolRenderer = {
 					out.push(truncateToWidth(`  ${theme.fg("dim", "(ctrl+s to observe sessions)")}`, width, Ellipsis.Omit));
 				}
 
-				snapshotSignatures ??= subagents.map(snapshot => subagentAwaitRenderedStateSignature([snapshot]));
+				snapshotSignatures ??= subagents.map(snapshot =>
+					subagentAwaitRenderedStateSignature([snapshot], result.details),
+				);
 				subagents.forEach((snapshot, index) => {
 					// Fresh per-subagent status line (cheap), then the cached heavy body.
 					out.push(