@deepseek-insight/dsi 0.5.8 → 0.5.10

package/build/server/chunks/entries/endpoints/api/prompts/{_server.ts.js-CCV5F65b.js → _server.ts.js-Bk-I6Cmq.js}

@@ -1,13 +1,14 @@
-import { l as listPrompts, s as searchPrompts, c as createPrompt } from '../../../../chunks/db2.js-BYr2lzQs.js';
-import { j as json } from '../../../../chunks/utils.js-tOWCe9Wk.js';
-import '../../../../chunks/insight-config.js-BAitz0O1.js';
-import '../../../../chunks/config.js-BBYogCe7.js';
+import { l as listPrompts, s as searchPrompts, c as createPrompt } from '../../../../chunks/db2.js-CPqi0hcH.js';
+import { j as json } from '../../../../chunks/utils.js-CAdNO8Tu.js';
+import '../../../../chunks/insight-config.js-BwcV3Bct.js';
+import '../../../../chunks/config.js-D2vQdial.js';
+import '../../../../chunks/settings-document.js-BIwLIxnE.js';
 import 'node:fs';
 import 'node:path';
 import 'node:os';
 import 'yaml';
 import 'node:sqlite';
-import '../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../chunks/shared.js-HQ0rfhm4.js';
 import '../../../../chunks/uneval.js-BJ9Qq2SF.js';
 
 //#region src/routes/api/prompts/+server.ts
@@ -84,4 +85,4 @@ var POST = async ({ request }) => {
 };
 
 export { GET, POST };
-//# sourceMappingURL=_server.ts.js-CCV5F65b.js.map
+//# sourceMappingURL=_server.ts.js-Bk-I6Cmq.js.map

package/build/server/chunks/entries/endpoints/api/prompts/use/{_server.ts.js-5zjPgL0k.js → _server.ts.js-CWdigZaS.js}

@@ -1,13 +1,14 @@
-import { i as readPromptsConfig } from '../../../../../chunks/insight-config.js-BAitz0O1.js';
-import { f as findPromptByText, r as recordPromptUse } from '../../../../../chunks/db2.js-BYr2lzQs.js';
-import { j as json } from '../../../../../chunks/utils.js-tOWCe9Wk.js';
-import '../../../../../chunks/config.js-BBYogCe7.js';
+import { i as readPromptsConfig } from '../../../../../chunks/insight-config.js-BwcV3Bct.js';
+import { f as findPromptByText, r as recordPromptUse } from '../../../../../chunks/db2.js-CPqi0hcH.js';
+import { j as json } from '../../../../../chunks/utils.js-CAdNO8Tu.js';
+import '../../../../../chunks/config.js-D2vQdial.js';
+import '../../../../../chunks/settings-document.js-BIwLIxnE.js';
 import 'node:fs';
 import 'node:path';
 import 'node:os';
 import 'yaml';
 import 'node:sqlite';
-import '../../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../../chunks/shared.js-HQ0rfhm4.js';
 import '../../../../../chunks/uneval.js-BJ9Qq2SF.js';
 
 //#region src/routes/api/prompts/use/+server.ts
@@ -51,4 +52,4 @@ var POST = async ({ request }) => {
 };
 
 export { POST };
-//# sourceMappingURL=_server.ts.js-5zjPgL0k.js.map
+//# sourceMappingURL=_server.ts.js-CWdigZaS.js.map

package/build/server/chunks/entries/endpoints/api/settings/{_server.ts.js-DGy6xjPE.js → _server.ts.js-BgZ3eon4.js}

@@ -1,11 +1,12 @@
-import { j as readSettingsDocument, s as saveSettingsDocument, S as SettingsParseError, k as DEFAULT_DSH_PRESET_ENGLISH, l as DEFAULT_SERVER_CONFIG, m as DEFAULT_PROMPTS_CONFIG, n as DEFAULT_SIDEBAR_CONFIG, o as DEFAULT_PANEL_CONFIG, p as DEFAULT_A2A_CONFIG, q as DEFAULT_HOME_CONFIG, t as DEFAULT_CONVERSATION_CONFIG, u as DEFAULT_CHAT_CONFIG } from '../../../../chunks/insight-config.js-BAitz0O1.js';
-import { j as json } from '../../../../chunks/utils.js-tOWCe9Wk.js';
+import { r as readSettingsDocument, s as saveSettingsDocument, S as SettingsParseError } from '../../../../chunks/settings-document.js-BIwLIxnE.js';
+import { j as DEFAULT_DSH_PRESET_ENGLISH, k as DEFAULT_SERVER_CONFIG, l as DEFAULT_PROMPTS_CONFIG, m as DEFAULT_SIDEBAR_CONFIG, n as DEFAULT_PANEL_CONFIG, o as DEFAULT_A2A_CONFIG, p as DEFAULT_HOME_CONFIG, q as DEFAULT_CONVERSATION_CONFIG, s as DEFAULT_CHAT_CONFIG } from '../../../../chunks/insight-config.js-BwcV3Bct.js';
+import { j as json } from '../../../../chunks/utils.js-CAdNO8Tu.js';
 import { stringify } from 'yaml';
-import '../../../../chunks/config.js-BBYogCe7.js';
+import '../../../../chunks/config.js-D2vQdial.js';
 import 'node:fs';
 import 'node:path';
 import 'node:os';
-import '../../../../chunks/shared.js-C4-Py8s_.js';
+import '../../../../chunks/shared.js-HQ0rfhm4.js';
 import '../../../../chunks/uneval.js-BJ9Qq2SF.js';
 
 //#region src/routes/api/settings/+server.ts
@@ -98,4 +99,4 @@ var PUT = async ({ url, request }) => {
 };
 
 export { GET, PUT };
-//# sourceMappingURL=_server.ts.js-DGy6xjPE.js.map
+//# sourceMappingURL=_server.ts.js-BgZ3eon4.js.map

package/build/server/chunks/entries/endpoints/api/workspace/file-write/_server.ts.js-CMDHM8Ts.js

@@ -0,0 +1,109 @@
+import { s as statusFor, m as mapRpcFailure } from '../../../../../chunks/dsh-connection.js-DlwhJZaV.js';
+import { g as gitGateEnabled, i as isInsideRoot } from '../../../../../chunks/git-probe.js-nfLEa58f.js';
+import { j as json } from '../../../../../chunks/utils.js-CAdNO8Tu.js';
+import { promises } from 'node:fs';
+import * as nodePath from 'node:path';
+import '../../../../../chunks/config.js-D2vQdial.js';
+import '../../../../../chunks/insight-config.js-BwcV3Bct.js';
+import '../../../../../chunks/settings-document.js-BIwLIxnE.js';
+import 'node:os';
+import 'yaml';
+import '../../../../../chunks/dsh-events.js-BtDxaV6Q.js';
+import '../../../../../chunks/permission-state.js-yvwUSnug.js';
+import 'node:child_process';
+import '../../../../../chunks/shared.js-HQ0rfhm4.js';
+import '../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/workspace/file-write/+server.ts
+/**
+* api-workspace — POST /api/workspace/file-write
+*
+* The File Eye's direct save (ADR The File Eye 2026-09-12, D4): on a
+* full-access desk the DSI server writes the bytes ITSELF — fresh gate,
+* realpath containment of the target inside the workspace root, then
+* fs.writeFile. The written receipt IS proof of effect (unlike the
+* retired delegated turn). Every refusal happens BEFORE the filesystem
+* is touched.
+*/
+var POST = async ({ request }) => {
+	let body;
+	try {
+		body = await request.json();
+	} catch {
+		return json({
+			ok: false,
+			error: {
+				code: "bad-json",
+				message: "request body is not valid JSON"
+			}
+		}, { status: 400 });
+	}
+	const { sessionId, root, path, content } = body ?? {};
+	if (typeof sessionId !== "string" || sessionId.trim().length === 0) return json({
+		ok: false,
+		error: {
+			code: "bad-session",
+			message: "sessionId is required"
+		}
+	}, { status: 400 });
+	if (typeof root !== "string" || root.trim().length === 0) return json({
+		ok: false,
+		error: {
+			code: "bad-root",
+			message: "root is required"
+		}
+	}, { status: 400 });
+	if (typeof path !== "string" || path.length === 0) return json({
+		ok: false,
+		error: {
+			code: "bad-path",
+			message: "path is required"
+		}
+	}, { status: 400 });
+	if (typeof content !== "string") return json({
+		ok: false,
+		error: {
+			code: "bad-content",
+			message: "content must be a string"
+		}
+	}, { status: 400 });
+	let enabled;
+	try {
+		enabled = await gitGateEnabled(sessionId);
+	} catch (err) {
+		return json(mapRpcFailure(err), { status: statusFor(err) });
+	}
+	if (!enabled) return json({
+		ok: false,
+		error: {
+			code: "gate-closed",
+			message: "the desk does not permit direct writes"
+		}
+	}, { status: 403 });
+	const absolute = nodePath.join(root, ...path.split("/").filter((p) => p.length > 0));
+	if (!await isInsideRoot(root, absolute)) return json({
+		ok: false,
+		error: {
+			code: "outside-workspace",
+			message: "the file path is not inside the workspace root"
+		}
+	}, { status: 403 });
+	try {
+		await promises.writeFile(absolute, content, "utf8");
+		return json({
+			ok: true,
+			written: true
+		});
+	} catch (err) {
+		return json({
+			ok: false,
+			error: {
+				code: "write-failed",
+				message: err instanceof Error ? err.message : "write failed"
+			}
+		}, { status: 500 });
+	}
+};
+
+export { POST };
+//# sourceMappingURL=_server.ts.js-CMDHM8Ts.js.map

package/build/server/chunks/entries/endpoints/api/workspace/git-events/_server.ts.js-DsrelTvu.js

@@ -0,0 +1,295 @@
+import { s as statusFor, m as mapRpcFailure } from '../../../../../chunks/dsh-connection.js-DlwhJZaV.js';
+import { g as gitGateEnabled, i as isInsideRoot, a as gitStatus, p as parsePorcelainStatus } from '../../../../../chunks/git-probe.js-nfLEa58f.js';
+import { j as json } from '../../../../../chunks/utils.js-CAdNO8Tu.js';
+import { watch } from 'node:fs';
+import { join } from 'node:path';
+import { execFileSync } from 'node:child_process';
+import '../../../../../chunks/config.js-D2vQdial.js';
+import '../../../../../chunks/insight-config.js-BwcV3Bct.js';
+import '../../../../../chunks/settings-document.js-BIwLIxnE.js';
+import 'node:os';
+import 'yaml';
+import '../../../../../chunks/dsh-events.js-BtDxaV6Q.js';
+import '../../../../../chunks/permission-state.js-yvwUSnug.js';
+import '../../../../../chunks/shared.js-HQ0rfhm4.js';
+import '../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+/** Module-level registry — the DSI server is a long-lived Node process
+*  (adapter-node), so this state persists across requests (ADR fact 8). */
+var registry = /* @__PURE__ */ new Map();
+function workspaceOf(workspaceKey) {
+	let ws = registry.get(workspaceKey);
+	if (!ws) {
+		ws = {
+			generation: 0,
+			watchers: /* @__PURE__ */ new Map(),
+			listeners: /* @__PURE__ */ new Set()
+		};
+		registry.set(workspaceKey, ws);
+	}
+	return ws;
+}
+/** Current generation for a workspace (0 before the first ring). */
+function getGeneration(workspaceKey) {
+	return registry.get(workspaceKey)?.generation ?? 0;
+}
+/** Subscribe to generation bumps for one workspace. Returns an unsubscribe. */
+function onGeneration(workspaceKey, cb) {
+	const ws = workspaceOf(workspaceKey);
+	ws.listeners.add(cb);
+	return () => ws.listeners.delete(cb);
+}
+function bump(workspaceKey) {
+	const ws = registry.get(workspaceKey);
+	if (!ws) return;
+	ws.generation += 1;
+	for (const cb of ws.listeners) try {
+		cb(ws.generation);
+	} catch {}
+}
+function scheduleRing(workspaceKey, entry) {
+	if (entry.timer !== null) clearTimeout(entry.timer);
+	entry.timer = setTimeout(async () => {
+		entry.timer = null;
+		let snapshot = null;
+		try {
+			const status = await gitStatus(entry.repo);
+			snapshot = JSON.stringify(status.files);
+		} catch {
+			snapshot = null;
+		}
+		if (snapshot === null || snapshot === entry.lastStatus) return;
+		entry.lastStatus = snapshot;
+		entry.rootEventPending = false;
+		let open = false;
+		try {
+			open = await entry.gateCheck();
+		} catch {
+			open = false;
+		}
+		if (open) bump(workspaceKey);
+		else try {
+			entry.onGateClosed();
+		} catch {}
+	}, 300);
+}
+/**
+* Acquire one claim on a repo's index watcher for a workspace. The watcher
+* is created on the FIRST acquire and torn down when the last lease is
+* released (ADR D5). gateCheck is re-resolved on every ring — never cached.
+*/
+function acquireWatch(opts) {
+	const ws = workspaceOf(opts.workspaceKey);
+	let entry = ws.watchers.get(opts.repo);
+	if (!entry) {
+		let watcher;
+		try {
+			watcher = watch(join(opts.repo, ".git"), () => {
+				scheduleRing(opts.workspaceKey, fresh);
+			});
+		} catch {
+			const dead = {
+				watcher: { close: () => void 0 },
+				rootWatcher: null,
+				refcount: 0,
+				repo: opts.repo,
+				gateCheck: opts.gateCheck,
+				onGateClosed: opts.onGateClosed ?? (() => void 0),
+				timer: null,
+				lastStatus: null,
+				rootEventPending: false
+			};
+			entry = dead;
+			ws.watchers.set(opts.repo, entry);
+			entry.refcount += 1;
+			let alreadyReleased = false;
+			return { release: async () => {
+				if (alreadyReleased) return;
+				alreadyReleased = true;
+				await releaseWatcher(opts.workspaceKey, dead);
+			} };
+		}
+		const fresh = {
+			watcher,
+			rootWatcher: null,
+			refcount: 0,
+			repo: opts.repo,
+			gateCheck: opts.gateCheck,
+			onGateClosed: opts.onGateClosed ?? (() => void 0),
+			timer: null,
+			lastStatus: statusSnapshotSync(opts.repo),
+			rootEventPending: false
+		};
+		entry = fresh;
+		watcher.on("error", () => {
+			releaseWatcher(opts.workspaceKey, fresh);
+		});
+		let rootWatcher = null;
+		try {
+			rootWatcher = watch(opts.repo, (kind, name) => {
+				const n = name === null ? "" : String(name);
+				if (n === ".git" || n.startsWith(".git")) return;
+				fresh.rootEventPending = true;
+				scheduleRing(opts.workspaceKey, fresh);
+			});
+		} catch {
+			rootWatcher = null;
+		}
+		fresh.rootWatcher = rootWatcher;
+		watcher.on("error", () => {
+			releaseWatcher(opts.workspaceKey, fresh);
+		});
+		ws.watchers.set(opts.repo, entry);
+	}
+	entry.refcount += 1;
+	let released = false;
+	return { release: async () => {
+		if (released) return;
+		released = true;
+		await releaseWatcher(opts.workspaceKey, entry);
+	} };
+}
+async function releaseWatcher(workspaceKey, entry) {
+	const ws = registry.get(workspaceKey);
+	if (!ws) return;
+	if (ws.watchers.get(entry.repo) !== entry) return;
+	entry.refcount -= 1;
+	if (entry.refcount > 0) return;
+	ws.watchers.delete(entry.repo);
+	if (entry.timer !== null) clearTimeout(entry.timer);
+	entry.timer = null;
+	try {
+		await entry.watcher.close();
+	} catch {}
+	if (entry.rootWatcher !== null) try {
+		entry.rootWatcher.close();
+	} catch {}
+	if (ws.watchers.size === 0 && ws.listeners.size === 0) registry.delete(workspaceKey);
+}
+/** SYNC baseline seed (Index Pulse): a null lastStatus makes the first
+*  verified ring bump even when NOTHING changed (FSEvents setup ghosts
+*  made that a real flake). Reading porcelain synchronously at acquire
+*  costs one bounded git child per watcher CREATION (not per ring) and
+*  removes the race an async seed provably has. */
+function statusSnapshotSync(repo) {
+	try {
+		const out = execFileSync("git", [
+			"-C",
+			repo,
+			"status",
+			"--porcelain=v1",
+			"-z"
+		], {
+			timeout: 1e4,
+			maxBuffer: 4194304
+		});
+		return JSON.stringify(parsePorcelainStatus(out.toString()).files);
+	} catch {
+		return null;
+	}
+}
+//#endregion
+//#region src/routes/api/workspace/git-events/+server.ts
+/**
+* api-workspace — GET /api/workspace/git-events?sessionId=…&root=…&repo=…(&repo=…)
+*
+* The Index Pulse's SSE stream (ADR 2026-09-13, D3/D5): one server-sent
+* events channel per explorer panel. The gate is resolved at connect —
+* closed means the plain git-status JSON contract ({ ok:true,
+* enabled:false }), NOT a stream. Open, the stream speaks two events:
+* `generation` (a per-workspace monotonic integer, one per debounced ring)
+* and `enabled:false` (the gate died mid-stream; the panel degrades to
+* today's manual-Refresh world). TRUTH NEVER RIDES THIS STREAM — the panel
+* refetches rows through the unchanged gated git-status route. Watchers
+* are refcounted per workspace; the last client's disconnect closes them.
+*/
+var GET = async ({ url, request }) => {
+	const sessionId = url.searchParams.get("sessionId");
+	const root = url.searchParams.get("root");
+	const repos = url.searchParams.getAll("repo").filter((r) => r.trim().length > 0);
+	if (sessionId === null || sessionId.trim().length === 0 || root === null || root.trim().length === 0 || repos.length === 0) return json({
+		ok: false,
+		error: {
+			code: "bad-params",
+			message: "sessionId, root and at least one repo are required"
+		}
+	}, { status: 400 });
+	let enabled;
+	try {
+		enabled = await gitGateEnabled(sessionId);
+	} catch (err) {
+		return json(mapRpcFailure(err), { status: statusFor(err) });
+	}
+	if (!enabled) return json({
+		ok: true,
+		enabled: false
+	});
+	for (const repo of repos) if (!await isInsideRoot(root, repo)) return json({
+		ok: false,
+		error: {
+			code: "outside-workspace",
+			message: "the repo path is not inside the workspace root"
+		}
+	}, { status: 403 });
+	const encoder = new TextEncoder();
+	const workspaceKey = root;
+	let cleanup = () => void 0;
+	const stream = new ReadableStream({
+		start(controller) {
+			let closed = false;
+			const send = (event, data) => {
+				if (closed) return;
+				try {
+					controller.enqueue(encoder.encode("event: " + event + "\ndata: " + data + "\n\n"));
+				} catch {
+					closed = true;
+				}
+			};
+			send("generation", String(getGeneration(workspaceKey)));
+			const leases = repos.map((repo) => acquireWatch({
+				workspaceKey,
+				repo,
+				gateCheck: () => gitGateEnabled(sessionId),
+				onGateClosed: () => {
+					send("enabled", "false");
+					finish();
+				}
+			}));
+			const unsubscribe = onGeneration(workspaceKey, (generation) => {
+				send("generation", String(generation));
+			});
+			const ping = setInterval(() => {
+				if (closed) return;
+				try {
+					controller.enqueue(encoder.encode(": ping\n\n"));
+				} catch {
+					closed = true;
+				}
+			}, 25e3);
+			function finish() {
+				if (closed) return;
+				closed = true;
+				clearInterval(ping);
+				unsubscribe();
+				for (const lease of leases) lease.release();
+				try {
+					controller.close();
+				} catch {}
+			}
+			cleanup = finish;
+			request.signal.addEventListener("abort", finish);
+		},
+		cancel() {
+			cleanup();
+		}
+	});
+	return new Response(stream, { headers: {
+		"content-type": "text/event-stream; charset=utf-8",
+		"cache-control": "no-cache",
+		connection: "keep-alive",
+		"x-accel-buffering": "no"
+	} });
+};
+
+export { GET };
+//# sourceMappingURL=_server.ts.js-DsrelTvu.js.map

package/build/server/chunks/entries/endpoints/api/workspace/git-file-head/_server.ts.js-Bjo1hSe3.js

@@ -0,0 +1,87 @@
+import { s as statusFor, m as mapRpcFailure } from '../../../../../chunks/dsh-connection.js-DlwhJZaV.js';
+import { g as gitGateEnabled, r as resolveEnclosingRepo, i as isInsideRoot, b as gitFileHead, G as GitUnavailableError } from '../../../../../chunks/git-probe.js-nfLEa58f.js';
+import { j as json } from '../../../../../chunks/utils.js-CAdNO8Tu.js';
+import '../../../../../chunks/config.js-D2vQdial.js';
+import '../../../../../chunks/insight-config.js-BwcV3Bct.js';
+import '../../../../../chunks/settings-document.js-BIwLIxnE.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import '../../../../../chunks/dsh-events.js-BtDxaV6Q.js';
+import '../../../../../chunks/permission-state.js-yvwUSnug.js';
+import 'node:child_process';
+import '../../../../../chunks/shared.js-HQ0rfhm4.js';
+import '../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/workspace/git-file-head/+server.ts
+/**
+* api-workspace — GET /api/workspace/git-file-head?sessionId=…&root=…&path=…
+*
+* The File Eye's "before" side (ADR The File Eye 2026-09-12, D2): the
+* DSI server resolves the file's enclosing repo and runs a READ-ONLY
+* git show HEAD:<rel>, gated exactly like git-status. head is null when
+* git has no version of the path (untracked / newly added) — the honest
+* no-before-version, never an error. Containment over realpaths.
+*/
+var GET = async ({ url }) => {
+	const sessionId = url.searchParams.get("sessionId");
+	const root = url.searchParams.get("root");
+	const path = url.searchParams.get("path");
+	if (sessionId === null || sessionId.trim().length === 0 || root === null || root.trim().length === 0 || path === null || path.trim().length === 0) return json({
+		ok: false,
+		error: {
+			code: "bad-params",
+			message: "sessionId, root and path are required"
+		}
+	}, { status: 400 });
+	let enabled;
+	try {
+		enabled = await gitGateEnabled(sessionId);
+	} catch (err) {
+		return json(mapRpcFailure(err), { status: statusFor(err) });
+	}
+	if (!enabled) return json({
+		ok: true,
+		enabled: false
+	});
+	const enclosing = await resolveEnclosingRepo(root, path);
+	if (enclosing === null) return json({
+		ok: false,
+		error: {
+			code: "no-repo",
+			message: "no git repo encloses this path"
+		}
+	}, { status: 404 });
+	if (!await isInsideRoot(root, enclosing.repo)) return json({
+		ok: false,
+		error: {
+			code: "outside-workspace",
+			message: "the repo path is not inside the workspace root"
+		}
+	}, { status: 403 });
+	try {
+		const head = await gitFileHead(enclosing.repo, enclosing.rel);
+		return json({
+			ok: true,
+			enabled: true,
+			head
+		});
+	} catch (err) {
+		if (err instanceof GitUnavailableError) return json({
+			ok: false,
+			code: "git-unavailable",
+			message: err.message
+		});
+		return json({
+			ok: false,
+			error: {
+				code: "head-failed",
+				message: err instanceof Error ? err.message : "head read failed"
+			}
+		}, { status: statusFor(err) });
+	}
+};
+
+export { GET };
+//# sourceMappingURL=_server.ts.js-Bjo1hSe3.js.map

package/build/server/chunks/entries/endpoints/api/workspace/git-map/_server.ts.js-kbPAnTV6.js

@@ -0,0 +1,75 @@
+import { s as statusFor, m as mapRpcFailure } from '../../../../../chunks/dsh-connection.js-DlwhJZaV.js';
+import { g as gitGateEnabled, d as detectRepos } from '../../../../../chunks/git-probe.js-nfLEa58f.js';
+import { j as json } from '../../../../../chunks/utils.js-CAdNO8Tu.js';
+import '../../../../../chunks/config.js-D2vQdial.js';
+import '../../../../../chunks/insight-config.js-BwcV3Bct.js';
+import '../../../../../chunks/settings-document.js-BIwLIxnE.js';
+import 'node:fs';
+import 'node:path';
+import 'node:os';
+import 'yaml';
+import '../../../../../chunks/dsh-events.js-BtDxaV6Q.js';
+import '../../../../../chunks/permission-state.js-yvwUSnug.js';
+import 'node:child_process';
+import '../../../../../chunks/shared.js-HQ0rfhm4.js';
+import '../../../../../chunks/uneval.js-BJ9Qq2SF.js';
+
+//#region src/routes/api/workspace/git-map/+server.ts
+/**
+* api-workspace — GET /api/workspace/git-map?sessionId=…&dir=…
+*
+* Per-level repo flags for the workspace explorer (Git Eye ADR 2026-09-12,
+* D1/D3): which immediate child directories host a .git entry, and whether
+* the level itself does. Detection lives in $lib/server/git-probe and is
+* GATED (ADR D2): unless the owning session's sandbox mode is
+* danger-full-access, the route answers { ok:true, enabled:false } and
+* touches the filesystem for NOTHING. Errors keep the explorer's honest
+* failure face: a vanished directory is 404 not-found, a forbidden one 403,
+* anything else the shared status mapping.
+*/
+function errnoStatus(err) {
+	const code = err?.code;
+	if (code === "ENOENT") return 404;
+	if (code === "EACCES" || code === "EPERM") return 403;
+	return statusFor(err);
+}
+var GET = async ({ url }) => {
+	const sessionId = url.searchParams.get("sessionId");
+	const dir = url.searchParams.get("dir");
+	if (sessionId === null || sessionId.trim().length === 0 || dir === null || dir.trim().length === 0) return json({
+		ok: false,
+		error: {
+			code: "bad-params",
+			message: "sessionId and dir are required"
+		}
+	}, { status: 400 });
+	let enabled;
+	try {
+		enabled = await gitGateEnabled(sessionId);
+	} catch (err) {
+		return json(mapRpcFailure(err), { status: statusFor(err) });
+	}
+	if (!enabled) return json({
+		ok: true,
+		enabled: false
+	});
+	try {
+		const map = await detectRepos(dir);
+		return json({
+			ok: true,
+			enabled: true,
+			...map
+		});
+	} catch (err) {
+		return json({
+			ok: false,
+			error: {
+				code: "probe-failed",
+				message: err instanceof Error ? err.message : "probe failed"
+			}
+		}, { status: errnoStatus(err) });
+	}
+};
+
+export { GET };
+//# sourceMappingURL=_server.ts.js-kbPAnTV6.js.map