gsd-pi 2.72.0-dev.de4c4b3 → 2.73.0-dev.1cfd50c

package/src/resources/extensions/gsd/tests/prompt-loader-working-directory.test.ts

@@ -0,0 +1,19 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { loadPrompt } from "../prompt-loader.ts";
+
+test("loadPrompt normalizes workingDirectory backslashes for bash-friendly prompts (#4048)", () => {
+  const prompt = loadPrompt("research-milestone", {
+    milestoneId: "M001",
+    milestoneTitle: "Windows path fix",
+    workingDirectory: "C:\\Dev\\NB\\TR",
+    inlinedContext: "context",
+    skillActivation: "skill activation",
+    skillDiscoveryMode: "off",
+    skillDiscoveryInstructions: " disabled",
+  });
+
+  assert.match(prompt, /Your working directory is `C:\/Dev\/NB\/TR`/);
+  assert.doesNotMatch(prompt, /C:\\Dev\\NB\\TR/);
+});

package/src/resources/extensions/gsd/tests/register-hooks-depth-verification.test.ts

@@ -0,0 +1,97 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { registerHooks } from "../bootstrap/register-hooks.ts";
+import {
+  getPendingGate,
+  resetWriteGateState,
+  shouldBlockContextArtifactSave,
+} from "../bootstrap/write-gate.ts";
+
+function makeTempDir(prefix: string): string {
+  const dir = join(
+    tmpdir(),
+    `gsd-depth-gate-${prefix}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+  );
+  mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+test("register-hooks unlocks milestone depth verification from question id without guided-flow state (#4047)", async (t) => {
+  const dir = makeTempDir("manual");
+  const originalCwd = process.cwd();
+  process.chdir(dir);
+  resetWriteGateState();
+
+  t.after(() => {
+    resetWriteGateState();
+    process.chdir(originalCwd);
+    rmSync(dir, { recursive: true, force: true });
+  });
+
+  const handlers = new Map<string, Array<(event: any, ctx?: any) => Promise<void> | void>>();
+  const pi = {
+    on(event: string, handler: (event: any, ctx?: any) => Promise<void> | void) {
+      const existing = handlers.get(event) ?? [];
+      existing.push(handler);
+      handlers.set(event, existing);
+    },
+  } as any;
+
+  registerHooks(pi);
+
+  const questionId = "depth_verification_M001_confirm";
+  const questions = [
+    {
+      id: questionId,
+      question: "Do you agree?",
+      options: [
+        { label: "Yes, you got it (Recommended)" },
+        { label: "Needs adjustment" },
+      ],
+    },
+  ];
+
+  const toolCallHandlers = handlers.get("tool_call");
+  const toolResultHandlers = handlers.get("tool_result");
+  assert.ok(toolCallHandlers?.length, "tool_call handler should be registered");
+  assert.ok(toolResultHandlers?.length, "tool_result handler should be registered");
+
+  for (const handler of toolCallHandlers ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+    });
+  }
+
+  assert.equal(getPendingGate(), questionId, "gate should be set even without guided-flow state");
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M001").block,
+    true,
+    "milestone context should still be blocked before confirmation",
+  );
+
+  for (const handler of toolResultHandlers ?? []) {
+    await handler({
+      toolName: "ask_user_questions",
+      input: { questions },
+      details: {
+        response: {
+          answers: {
+            [questionId]: { selected: "Yes, you got it (Recommended)" },
+          },
+        },
+      },
+    });
+  }
+
+  assert.equal(getPendingGate(), null, "confirming the depth question should clear the pending gate");
+  assert.equal(
+    shouldBlockContextArtifactSave("CONTEXT", "M001").block,
+    false,
+    "question-id milestone inference should unlock the matching milestone context write",
+  );
+});

package/src/resources/extensions/gsd/tests/stale-slice-rows.test.ts

@@ -0,0 +1,41 @@
+/**
+ * stale-slice-rows.test.ts — #3658
+ *
+ * Verify that state.ts contains slice-level status reconciliation that
+ * updates stale DB rows (status "pending") when disk artifacts (SUMMARY)
+ * prove the slice is complete. Without this, the dependency resolver builds
+ * doneSliceIds from stale DB rows and downstream slices stay blocked.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const sourceFile = join(__dirname, "..", "state.ts");
+
+describe("stale slice row reconciliation (#3658)", () => {
+  const source = readFileSync(sourceFile, "utf-8");
+
+  test("imports updateSliceStatus from gsd-db", () => {
+    assert.match(source, /import\s*\{[^}]*updateSliceStatus[^}]*\}\s*from/);
+  });
+
+  test("checks isStatusDone before reconciling slice rows", () => {
+    assert.match(source, /isStatusDone\(dbSlice\.status\)/);
+  });
+
+  test("resolves SUMMARY file to detect completed slices on disk", () => {
+    assert.match(source, /resolveSliceFile\(basePath,\s*mid,\s*dbSlice\.id,\s*["']SUMMARY["']\)/);
+  });
+
+  test("calls updateSliceStatus to reconcile stale rows", () => {
+    assert.match(source, /updateSliceStatus\(mid,\s*dbSlice\.id,\s*["']complete["']\)/);
+  });
+
+  test("references issue #3599 in reconciliation comment", () => {
+    assert.match(source, /#3599/);
+  });
+});

package/src/resources/extensions/gsd/workflow-projections.ts

@@ -180,6 +180,14 @@ export function renderSummaryContent(
   milestoneId: string,
   evidence?: Array<{ command: string; exitCode?: number; exit_code?: number; verdict: string; durationMs?: number; duration_ms?: number }>,
 ): string {
+  // If the task already has a fully rendered summary (written by handleCompleteTask's
+  // renderSummaryMarkdown), use it as-is. That content already includes frontmatter,
+  // heading, and all sections. Re-wrapping it inside a second frontmatter/heading
+  // envelope produces double frontmatter and duplicate sections.
+  if (taskRow.full_summary_md && taskRow.full_summary_md.trimStart().startsWith("---")) {
+    return taskRow.full_summary_md;
+  }
+
   // ── Frontmatter (YAML list format, matches parseSummary() expectations) ──
   const keyFilesYaml = taskRow.key_files && taskRow.key_files.length > 0
     ? taskRow.key_files.map(f => `  - ${f}`).join("\n")

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

@@ -548,13 +548,39 @@ export function removeWorktree(
   }
 }
 
-/** Paths to skip in all worktree diffs (internal/runtime artifacts). */
-const SKIP_PATHS = [".gsd/worktrees/", ".gsd/runtime/", ".gsd/activity/"];
-const SKIP_EXACT = [".gsd/STATE.md", ".gsd/auto.lock", ".gsd/metrics.json"];
+/**
+ * Paths to skip in all worktree diffs (internal/runtime artifacts).
+ *
+ * NOTE: These arrays must stay synchronized with GSD_RUNTIME_PATTERNS in gitignore.ts.
+ * That file is the canonical source of truth for runtime ignore patterns.
+ * This module uses a split representation (paths/exact/prefixes) for efficient matching.
+ */
+const SKIP_PATHS = [
+  ".gsd/worktrees/",
+  ".gsd/runtime/",
+  ".gsd/activity/",
+  ".gsd/forensics/",
+  ".gsd/parallel/",
+  ".gsd/journal/",
+];
+const SKIP_EXACT = [
+  ".gsd/STATE.md",
+  ".gsd/auto.lock",
+  ".gsd/metrics.json",
+  ".gsd/state-manifest.json",
+  ".gsd/doctor-history.jsonl",
+  ".gsd/event-log.jsonl",
+];
+/** File prefixes to skip (for wildcard patterns like completed-units*.json, gsd.db*). */
+const SKIP_PREFIXES = [
+  ".gsd/completed-units",
+  ".gsd/gsd.db",
+];
 
 function shouldSkipPath(filePath: string): boolean {
   if (SKIP_PATHS.some(p => filePath.startsWith(p))) return true;
   if (SKIP_EXACT.includes(filePath)) return true;
+  if (SKIP_PREFIXES.some(p => filePath.startsWith(p))) return true;
   return false;
 }
 

package/src/resources/extensions/gsd/write-intercept.ts

@@ -24,6 +24,9 @@ const BLOCKED_PATTERNS: RegExp[] = [
   /(^|[/\\])\.gsd[/\\]STATE\.md$/i,
   // Also match resolved symlink paths under ~/.gsd/projects/ (Pitfall #6)
   /(^|[/\\])\.gsd[/\\]projects[/\\][^/\\]+[/\\]STATE\.md$/i,
+  // gsd.db and WAL/SHM files — single-writer WAL connection managed by engine (#3625)
+  /(^|[/\\])\.gsd[/\\]gsd\.db(-wal|-shm)?$/i,
+  /(^|[/\\])\.gsd[/\\]projects[/\\][^/\\]+[/\\]gsd\.db(-wal|-shm)?$/i,
 ];
 
 /**
@@ -41,6 +44,12 @@ const BASH_STATE_PATTERNS: RegExp[] = [
   /\bsed\b.*-i.*STATE\.md/i,
   // dd output to STATE.md
   /\bdd\b.*of=\S*STATE\.md/i,
+  // Direct DB access via sqlite3/sql.js/better-sqlite3 targeting gsd.db (#3625)
+  /\b(sqlite3|sql\.js|better-sqlite3|node:sqlite)\b.*gsd\.db/i,
+  /\bgsd\.db\b.*\b(sqlite3|sql\.js|better-sqlite3)\b/i,
+  // Shell writes targeting gsd.db files
+  /[>|]+\s*\S*gsd\.db/i,
+  /\b(cp|mv|dd)\b.*gsd\.db/i,
 ];
 
 /**
@@ -81,7 +90,7 @@ function matchesBlockedPattern(path: string): boolean {
  * Error message returned when an agent attempts to directly write an authoritative .gsd/ state file.
  * Directs the agent to use engine tool calls instead.
  */
-export const BLOCKED_WRITE_ERROR = `Direct writes to .gsd/STATE.md are blocked. Use engine tool calls instead:
+export const BLOCKED_WRITE_ERROR = `Direct writes to .gsd/STATE.md and .gsd/gsd.db are blocked. Use engine tool calls instead:
 - To complete a task: call gsd_complete_task(milestone_id, slice_id, task_id, summary)
 - To complete a slice: call gsd_complete_slice(milestone_id, slice_id, summary, uat_result)
 - To save a decision: call gsd_save_decision(scope, decision, choice, rationale)

package/src/resources/extensions/ollama/index.ts

@@ -69,13 +69,12 @@ async function probeAndRegister(pi: ExtensionAPI): Promise<boolean> {
 
 	const baseUrl = client.getOllamaHost();
 
-	// Use authMode "apiKey" with a dummy key (#3440).
-	// authMode "none" requires a custom streamSimple handler, but Ollama uses
-	// the standard OpenAI-compatible streaming endpoint. Ollama ignores the
-	// Authorization header so the dummy key is harmless.
+	// Use authMode "apiKey" (#3440). Local Ollama ignores the Authorization header,
+	// so the "ollama" fallback is harmless. For cloud endpoints (OLLAMA_HOST pointing
+	// to ollama.com or a remote instance), OLLAMA_API_KEY is picked up here.
 	pi.registerProvider("ollama", {
 		authMode: "apiKey",
-		apiKey: "ollama",
+		apiKey: process.env.OLLAMA_API_KEY ?? "ollama",
 		baseUrl,
 		api: "ollama-chat",
 		streamSimple: streamOllamaChat,

package/src/resources/extensions/ollama/ollama-client.ts

@@ -34,11 +34,34 @@ export function getOllamaHost(): string {
 	return `http://${host}`;
 }
 
+/**
+ * Get auth headers for Ollama API requests.
+ * For cloud endpoints (OLLAMA_HOST pointing to ollama.com or remote instances),
+ * OLLAMA_API_KEY is used as a Bearer token. Local Ollama ignores the header.
+ */
+function getAuthHeaders(): Record<string, string> {
+	const apiKey = process.env.OLLAMA_API_KEY;
+	if (!apiKey) return {};
+	return { Authorization: `Bearer ${apiKey}` };
+}
+
+/**
+ * Merge auth headers into request options.
+ */
+function withAuth(options: RequestInit = {}): RequestInit {
+	const authHeaders = getAuthHeaders();
+	if (Object.keys(authHeaders).length === 0) return options;
+	return {
+		...options,
+		headers: { ...authHeaders, ...(options.headers as Record<string, string> || {}) },
+	};
+}
+
 async function fetchWithTimeout(url: string, options: RequestInit = {}, timeoutMs = REQUEST_TIMEOUT_MS): Promise<Response> {
 	const controller = new AbortController();
 	const timeout = setTimeout(() => controller.abort(), timeoutMs);
 	try {
-		return await fetch(url, { ...options, signal: controller.signal });
+		return await fetch(url, withAuth({ ...options, signal: controller.signal }));
 	} finally {
 		clearTimeout(timeout);
 	}
@@ -46,10 +69,16 @@ async function fetchWithTimeout(url: string, options: RequestInit = {}, timeoutM
 
 /**
  * Check if Ollama is running and reachable.
+ * For cloud endpoints (OLLAMA_HOST pointing to ollama.com), uses /api/tags
+ * as the probe since the root endpoint may not be available.
  */
 export async function isRunning(): Promise<boolean> {
 	try {
-		const response = await fetchWithTimeout(`${getOllamaHost()}/`, {}, PROBE_TIMEOUT_MS);
+		const host = getOllamaHost();
+		const isCloud = host.includes("ollama.com") || host.includes("cloud");
+		const probeUrl = isCloud ? `${host}/api/tags` : `${host}/`;
+		const timeout = isCloud ? REQUEST_TIMEOUT_MS : PROBE_TIMEOUT_MS;
+		const response = await fetchWithTimeout(probeUrl, isCloud ? { method: "GET" } : {}, timeout);
 		return response.ok;
 	} catch {
 		return false;
@@ -117,12 +146,12 @@ export async function pullModel(
 	onProgress?: (progress: OllamaPullProgress) => void,
 	signal?: AbortSignal,
 ): Promise<void> {
-	const response = await fetch(`${getOllamaHost()}/api/pull`, {
+	const response = await fetch(`${getOllamaHost()}/api/pull`, withAuth({
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify({ name, stream: true }),
 		signal,
-	});
+	}));
 
 	if (!response.ok) {
 		const text = await response.text();
@@ -146,12 +175,12 @@ export async function* chat(
 	request: OllamaChatRequest,
 	signal?: AbortSignal,
 ): AsyncGenerator<OllamaChatResponse> {
-	const response = await fetch(`${getOllamaHost()}/api/chat`, {
+	const response = await fetch(`${getOllamaHost()}/api/chat`, withAuth({
 		method: "POST",
 		headers: { "Content-Type": "application/json" },
 		body: JSON.stringify(request),
 		signal,
-	});
+	}));
 
 	if (!response.ok) {
 		const text = await response.text();

package/src/resources/extensions/ollama/ollama-discovery.ts

@@ -8,7 +8,7 @@
  * Returns models in the format expected by pi.registerProvider().
  */
 
-import { listModels } from "./ollama-client.js";
+import { listModels, showModel } from "./ollama-client.js";
 import {
 	estimateContextFromParams,
 	formatModelSize,
@@ -17,6 +17,24 @@ import {
 } from "./model-capabilities.js";
 import type { OllamaChatOptions, OllamaModelInfo } from "./types.js";
 
+/**
+ * Extract context window from /api/show model_info.
+ * Keys follow the pattern "{architecture}.context_length" (e.g. "llama.context_length").
+ */
+function extractContextFromModelInfo(modelInfo: Record<string, unknown>): number | undefined {
+	for (const [key, value] of Object.entries(modelInfo)) {
+		if (key.endsWith(".context_length") && typeof value === "number" && value > 0) {
+			return value;
+		}
+	}
+	return undefined;
+}
+
+type ClientDeps = {
+	listModels: typeof listModels;
+	showModel: typeof showModel;
+};
+
 export interface DiscoveredOllamaModel {
 	id: string;
 	name: string;
@@ -35,13 +53,26 @@ export interface DiscoveredOllamaModel {
 
 const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
 
-function enrichModel(info: OllamaModelInfo): DiscoveredOllamaModel {
+async function enrichModel(info: OllamaModelInfo, deps: ClientDeps): Promise<DiscoveredOllamaModel> {
 	const caps = getModelCapabilities(info.name);
 	const parameterSize = info.details?.parameter_size ?? "";
 
-	// Determine context window: known table > estimate from param size > default
+	// /api/tags doesn't include context length; /api/show does via "{arch}.context_length" in model_info.
+	let showContextWindow: number | undefined;
+	if (caps.contextWindow === undefined) {
+		try {
+			const showData = await deps.showModel(info.name);
+			showContextWindow = extractContextFromModelInfo(showData.model_info);
+		} catch (err) {
+			// non-fatal: fall through to estimate
+			if (process.env.GSD_DEBUG) console.warn(`[ollama] /api/show failed for ${info.name}:`, err instanceof Error ? err.message : String(err));
+		}
+	}
+
+	// Determine context window: known table > /api/show > estimate from param size > default
 	const contextWindow =
 		caps.contextWindow ??
+		showContextWindow ??
 		(parameterSize ? estimateContextFromParams(parameterSize) : 8192);
 
 	// Determine max tokens: known table > fraction of context > default
@@ -73,11 +104,11 @@ function enrichModel(info: OllamaModelInfo): DiscoveredOllamaModel {
 /**
  * Discover all locally available Ollama models with enriched capabilities.
  */
-export async function discoverModels(): Promise<DiscoveredOllamaModel[]> {
-	const tags = await listModels();
+export async function discoverModels(deps: ClientDeps = { listModels, showModel }): Promise<DiscoveredOllamaModel[]> {
+	const tags = await deps.listModels();
 	if (!tags.models || tags.models.length === 0) return [];
 
-	return tags.models.map(enrichModel);
+	return Promise.all(tags.models.map((m) => enrichModel(m, deps)));
 }
 
 /**

package/src/resources/extensions/ollama/tests/ollama-discovery.test.ts

@@ -1 +1,55 @@
 // GSD2 — Tests for Ollama model discovery and enrichment
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { discoverModels } from "../ollama-discovery.js";
+import type { OllamaTagsResponse, OllamaShowResponse } from "../types.js";
+
+const EMPTY_DETAILS = { parent_model: "", format: "", family: "", families: null, parameter_size: "", quantization_level: "" };
+
+function modelStub(name: string, parameterSize = "") {
+	return { name, model: name, modified_at: "", size: 0, digest: "", details: { ...EMPTY_DETAILS, parameter_size: parameterSize } };
+}
+
+function tagsStub(name: string, parameterSize = ""): OllamaTagsResponse {
+	return { models: [modelStub(name, parameterSize)] };
+}
+
+function showStub(modelInfo: Record<string, unknown>): OllamaShowResponse {
+	return { modelfile: "", parameters: "", template: "", details: EMPTY_DETAILS, model_info: modelInfo };
+}
+
+describe("discoverModels — context window resolution", () => {
+	it("uses known table context window without calling /api/show", async () => {
+		let showCalled = false;
+		const models = await discoverModels({
+			listModels: async () => tagsStub("llama3.2:latest", "3B"),
+			showModel: async () => { showCalled = true; throw new Error("should not be called"); },
+		});
+		assert.equal(models[0].contextWindow, 131072);
+		assert.equal(showCalled, false);
+	});
+
+	it("uses context_length from /api/show model_info for unknown model", async () => {
+		const models = await discoverModels({
+			listModels: async () => tagsStub("gemini-3-flash-preview:latest"),
+			showModel: async () => showStub({ "gemini.context_length": 1048576 }),
+		});
+		assert.equal(models[0].contextWindow, 1048576);
+	});
+
+	it("falls back to 8192 when /api/show model_info has no context_length key", async () => {
+		const models = await discoverModels({
+			listModels: async () => tagsStub("unknown-model:latest"),
+			showModel: async () => showStub({}),
+		});
+		assert.equal(models[0].contextWindow, 8192);
+	});
+
+	it("falls back to 8192 when /api/show throws", async () => {
+		const models = await discoverModels({
+			listModels: async () => tagsStub("unknown-model:latest"),
+			showModel: async () => { throw new Error("network error"); },
+		});
+		assert.equal(models[0].contextWindow, 8192);
+	});
+});

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

@@ -1,54 +0,0 @@
-/**
- * Pre-dispatch observability checks for auto-mode units.
- * Validates plan/summary file quality and builds repair instructions
- * for the agent to fix gaps before proceeding with the unit.
- */
-import { validatePlanBoundary, validateExecuteBoundary, validateCompleteBoundary, formatValidationIssues, } from "./observability-validator.js";
-import { parseUnitId } from "./unit-id.js";
-export async function collectObservabilityWarnings(ctx, basePath, unitType, unitId) {
-    // Hook units have custom artifacts — skip standard observability checks
-    if (unitType.startsWith("hook/"))
-        return [];
-    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-    if (!mid || !sid)
-        return [];
-    let issues = [];
-    if (unitType === "plan-slice") {
-        issues = await validatePlanBoundary(basePath, mid, sid);
-    }
-    else if (unitType === "execute-task" && tid) {
-        issues = await validateExecuteBoundary(basePath, mid, sid, tid);
-    }
-    else if (unitType === "complete-slice") {
-        issues = await validateCompleteBoundary(basePath, mid, sid);
-    }
-    if (issues.length > 0) {
-        ctx.ui.notify(`Observability check (${unitType}) found ${issues.length} warning${issues.length === 1 ? "" : "s"}:\n${formatValidationIssues(issues)}`, "warning");
-    }
-    return issues;
-}
-export function buildObservabilityRepairBlock(issues) {
-    if (issues.length === 0)
-        return "";
-    const items = issues.map(issue => {
-        const fileName = issue.file.split("/").pop() || issue.file;
-        let line = `- **${fileName}**: ${issue.message}`;
-        if (issue.suggestion)
-            line += ` → ${issue.suggestion}`;
-        return line;
-    });
-    return [
-        "",
-        "---",
-        "",
-        "## Pre-flight: Observability gaps to fix FIRST",
-        "",
-        "The following issues were detected in plan/summary files for this unit.",
-        "**Read each flagged file, apply the fix described, then proceed with the unit.**",
-        "",
-        ...items,
-        "",
-        "---",
-        "",
-    ].join("\n");
-}

package/dist/resources/extensions/gsd/file-watcher.js

@@ -1,80 +0,0 @@
-import { relative } from "node:path";
-let watcher = null;
-let pending = new Map();
-const EVENT_MAP = {
-    "settings.json": "settings-changed",
-    "auth.json": "auth-changed",
-    "models.json": "models-changed",
-};
-const EXTENSIONS_DIR = "extensions";
-const IGNORED_PATTERNS = [
-    "**/sessions/**",
-    "**/*.tmp",
-    "**/*.swp",
-    "**/*~",
-    "**/.DS_Store",
-];
-const DEBOUNCE_MS = 300;
-/**
- * Start watching `agentDir` (e.g. `~/.gsd/agent/`) for config changes.
- * Emits events on the supplied EventBus when watched files are modified.
- */
-export async function startFileWatcher(agentDir, eventBus) {
-    if (watcher) {
-        await watcher.close();
-    }
-    const { watch } = await import("chokidar");
-    pending = new Map();
-    function debounceEmit(event) {
-        const existing = pending.get(event);
-        if (existing)
-            clearTimeout(existing);
-        pending.set(event, setTimeout(() => {
-            pending.delete(event);
-            eventBus.emit(event, { timestamp: Date.now() });
-        }, DEBOUNCE_MS));
-    }
-    function resolveEvent(filePath) {
-        const rel = relative(agentDir, filePath);
-        if (rel.startsWith(".."))
-            return null;
-        // Check direct file matches
-        for (const [file, event] of Object.entries(EVENT_MAP)) {
-            if (rel === file)
-                return event;
-        }
-        // Check extensions directory
-        if (rel.startsWith(EXTENSIONS_DIR + "/") || rel === EXTENSIONS_DIR) {
-            return "extensions-changed";
-        }
-        return null;
-    }
-    watcher = watch(agentDir, {
-        ignoreInitial: true,
-        depth: 2,
-        ignored: IGNORED_PATTERNS,
-    });
-    for (const eventType of ["add", "change", "unlink"]) {
-        watcher.on(eventType, (filePath) => {
-            const event = resolveEvent(filePath);
-            if (event)
-                debounceEmit(event);
-        });
-    }
-    // Wait for watcher to be ready
-    await new Promise((resolve) => {
-        watcher.on("ready", resolve);
-    });
-}
-/**
- * Stop the file watcher and clean up resources.
- */
-export async function stopFileWatcher() {
-    for (const timer of pending.values())
-        clearTimeout(timer);
-    pending.clear();
-    if (watcher) {
-        await watcher.close();
-        watcher = null;
-    }
-}

package/dist/resources/extensions/gsd/rtk-status.js

@@ -1,43 +0,0 @@
-import { ensureRtkSessionBaseline, formatRtkSavingsLabel, getRtkSessionSavings, } from "../shared/rtk-session-stats.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
-const STATUS_KEY = "gsd-rtk";
-const REFRESH_INTERVAL_MS = 30_000;
-let refreshTimer = null;
-function clearTimer() {
-    if (refreshTimer) {
-        clearInterval(refreshTimer);
-        refreshTimer = null;
-    }
-}
-function isRtkEnabledInPrefs() {
-    return loadEffectiveGSDPreferences()?.preferences.experimental?.rtk === true;
-}
-function updateStatus(ctx) {
-    if (!ctx.hasUI)
-        return;
-    if (!isRtkEnabledInPrefs())
-        return;
-    const basePath = ctx.cwd;
-    const sessionId = ctx.sessionManager.getSessionId();
-    ensureRtkSessionBaseline(basePath, sessionId);
-    const savings = getRtkSessionSavings(basePath, sessionId);
-    ctx.ui.setStatus(STATUS_KEY, formatRtkSavingsLabel(savings) ?? undefined);
-}
-export function startRtkStatusUpdates(ctx) {
-    clearTimer();
-    if (!isRtkEnabledInPrefs()) {
-        // Ensure any previously set status is cleared (e.g. preference was toggled off)
-        ctx.ui.setStatus(STATUS_KEY, undefined);
-        return;
-    }
-    updateStatus(ctx);
-    if (!ctx.hasUI)
-        return;
-    refreshTimer = setInterval(() => {
-        updateStatus(ctx);
-    }, REFRESH_INTERVAL_MS);
-}
-export function stopRtkStatusUpdates(ctx) {
-    clearTimer();
-    ctx?.ui.setStatus(STATUS_KEY, undefined);
-}