@xopcai/xopc 0.0.234 → 0.0.238

package/dist/src/gateway/hono/lib/config-payload.d.ts

@@ -35,7 +35,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
                     primary: string;
                     fallbacks: string[];
                 };
-                intents?: Partial<Record<"understanding" | "fast" | "reasoning" | "coding" | "review" | "vision", {
+                intents?: Partial<Record<"review" | "coding" | "understanding" | "fast" | "reasoning" | "vision", {
                     primary: string;
                     fallbacks: string[];
                 }>>;
@@ -74,7 +74,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
                     primary: string;
                     fallbacks: string[];
                 };
-                intents: Partial<Record<"understanding" | "fast" | "reasoning" | "coding" | "review" | "vision", {
+                intents: Partial<Record<"review" | "coding" | "understanding" | "fast" | "reasoning" | "vision", {
                     primary: string;
                     fallbacks: string[];
                 }>>;
@@ -209,7 +209,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
     };
     userContext: {
         preferences: {
-            responseLanguage: "auto" | "zh-CN" | "en";
+            responseLanguage: "en" | "auto" | "zh-CN";
         };
         dreaming: {
             mode: "off" | "review";
@@ -221,7 +221,7 @@ export declare function buildSafeWebConfigPayload(service: GatewayService, optio
             timezone?: string;
         };
         privacy: {
-            sensitiveWritePolicy: "allow" | "deny" | "confirm";
+            sensitiveWritePolicy: "allow" | "confirm" | "deny";
         };
         memory: {
             retention: {

package/dist/src/gateway/hono/lib/config-payload.js

@@ -1,9 +1,9 @@
 import { ContextCompactionPolicySchema, UserContextDreamingSchema, UserContextPrivacySchema, init_config } from "../../../user-context/config.js";
 import { init_agent_scope, listAgentEntries, normalizeAgentId, resolveDefaultAgentId } from "../../../agent/agent-scope.js";
 import { resolveModelsJsonPath } from "../../../config/paths.js";
+import { buildChannelCatalogForConfig, buildChannelCatalogFromSnapshot, getChannelSetupStatus, init_channel_catalog_service } from "../../../channels/catalog/channel-catalog-service.js";
 import { init_models_json, loadModelsJson } from "../../../config/models-json.js";
 import { CredentialResolver, init_credentials } from "../../../auth/credentials.js";
-import { buildChannelCatalogForConfig, buildChannelCatalogFromSnapshot, getChannelSetupStatus, init_channel_catalog_service } from "../../../channels/catalog/channel-catalog-service.js";
 import { getProviderRegistry, init_plugin_registry } from "../../../providers/plugin-registry.js";
 import { getAllProviders, init_providers, isProviderConfigured } from "../../../providers/index.js";
 import { normalizeConfiguredMcpServers } from "../../../config/mcp-config-normalize.js";

package/dist/src/gateway/hono/routes/chat-model-config.d.ts

@@ -0,0 +1,34 @@
+import type { Context } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function patchChatModelConfig(c: Context, service: AuthenticatedRouteDeps['service'], sessionKey: string, body: Record<string, unknown>): Promise<(Response & import("hono").TypedResponse<{
+    ok: false;
+    error: string;
+    code: string;
+}, 409, "json">) | (Response & import("hono").TypedResponse<{
+    ok: false;
+    error: string;
+}, 400, "json">) | (Response & import("hono").TypedResponse<{
+    ok: false;
+    error: string;
+    code: "CONFIG_CHANGED" | "INVALID_MODEL" | "INVALID_THINKING";
+}, 400 | 409, "json">) | (Response & import("hono").TypedResponse<{
+    ok: true;
+    payload: {
+        thinkingLevel: import("@earendil-works/pi-agent-core").ThinkingLevel;
+        model: string;
+        configVersion: number;
+        fixedModel: boolean;
+        reasoningLevel: import("../../../config/index.js").ReasoningLevel;
+        activityDetail: {
+            default: import("../../../config/index.js").ReasoningLevel;
+            override: import("../../../config/index.js").ReasoningLevel | null;
+            effective: import("../../../config/index.js").ReasoningLevel;
+            source: "session" | "default";
+        };
+        verboseLevel: import("../../../config/index.js").VerboseLevel;
+        effectiveWorkspacePath: string;
+        workingDirectoryLocked: boolean;
+        workspaceSource: "execution_environment" | "project" | "session_override" | "agent_default_root" | "agent_workspace";
+        userContextMode: "enabled" | "off" | "temporary";
+    };
+}, import("hono/dist/types/utils/http-status.js").ContentfulStatusCode, "json">)>;

package/dist/src/gateway/hono/routes/chat-model-config.js

@@ -0,0 +1,42 @@
+import { withModelConfigLock } from "../../../session/model-config-lock.js";
+//#region src/gateway/hono/routes/chat-model-config.ts
+async function patchChatModelConfig(c, service, sessionKey, body) {
+	return withModelConfigLock(sessionKey, async () => {
+		const changesModel = body.model !== void 0 || body.thinkingLevel !== void 0;
+		if (changesModel) {
+			const state = service.getSessionInputState(sessionKey);
+			if (service.sessions.getActiveRun(sessionKey).active || state.activeRunId || state.inputs.length > 0) return c.json({
+				ok: false,
+				error: "Wait for the current reply and pending inputs to finish",
+				code: "SESSION_BUSY"
+			}, 409);
+			if (body.thinkingLevel !== void 0 && typeof body.thinkingLevel !== "string") return c.json({
+				ok: false,
+				error: "Invalid thinking level"
+			}, 400);
+			if (body.configVersion !== void 0 && (!Number.isSafeInteger(body.configVersion) || Number(body.configVersion) < 0)) return c.json({
+				ok: false,
+				error: "Invalid configuration version"
+			}, 400);
+			if (body.model !== void 0 && (typeof body.model !== "string" || !body.model.trim())) return c.json({
+				ok: false,
+				error: "Select a specific model"
+			}, 400);
+		}
+		const result = await service.sessions.patchAgentConfig(sessionKey, {
+			...body,
+			...changesModel ? { fixedModel: true } : {}
+		});
+		if (!result.ok) return c.json({
+			ok: false,
+			error: result.error,
+			code: result.code
+		}, result.code === "CONFIG_CHANGED" ? 409 : 400);
+		return c.json({
+			ok: true,
+			payload: await service.sessions.getAgentConfig(sessionKey)
+		});
+	});
+}
+//#endregion
+export { patchChatModelConfig };

package/dist/src/gateway/hono/routes/device-pairing-approval.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from 'hono';
+export declare function registerPairingApprovalPublicRoutes(app: Hono): void;
+export declare function registerPairingApprovalAdminRoutes(app: Hono): void;

package/dist/src/gateway/hono/routes/device-pairing-approval.js

@@ -0,0 +1,100 @@
+import { devicePairingCompleteSchema, devicePairingProofSchema, devicePairingRequestSchema } from "../../../../packages/gateway-contract/src/device-pairing.js";
+import { getOrCreateGatewayIdentity, signGatewayPayload } from "../../../storage/sqlite/gateway-identity-repository.js";
+import { DevicePairingError, cancelDevicePairingSetup, decideDevicePairingRequest, operateDevicePairingRequest, readDevicePairingSetup, submitDevicePairingRequest } from "../../../storage/sqlite/device-pairing-approval.js";
+import os from "node:os";
+import { z } from "zod";
+//#region src/gateway/hono/routes/device-pairing-approval.ts
+function pairingError(c, error) {
+	if (error instanceof DevicePairingError) return c.json({
+		ok: false,
+		error: {
+			code: error.code,
+			message: error.code
+		}
+	}, error.status);
+	return c.json({
+		ok: false,
+		error: {
+			code: "PAIRING_FAILED",
+			message: "Pairing could not be completed"
+		}
+	}, 500);
+}
+function registerPairingApprovalPublicRoutes(app) {
+	for (const action of [
+		"request",
+		"status",
+		"complete",
+		"cancel"
+	]) {
+		const path = action === "request" ? "/api/device-pairing/requests" : `/api/device-pairing/requests/:id/${action}`;
+		app.post(path, async (c) => {
+			const parsed = (action === "request" ? devicePairingRequestSchema : action === "complete" ? devicePairingCompleteSchema : devicePairingProofSchema).safeParse(await c.req.json().catch(() => null));
+			if (!parsed.success || action !== "request" && parsed.data.requestId !== c.req.param("id")) return c.json({
+				ok: false,
+				error: {
+					code: "BAD_REQUEST",
+					message: "Invalid pairing request"
+				}
+			}, 400);
+			try {
+				const result = action === "request" ? { request: submitDevicePairingRequest(parsed.data) } : operateDevicePairingRequest(action, parsed.data);
+				const signedPayload = Buffer.from(JSON.stringify({
+					...result,
+					gateway: {
+						id: getOrCreateGatewayIdentity().id,
+						name: os.hostname()
+					},
+					nonce: parsed.data.nonce,
+					issuedAt: Date.now()
+				})).toString("base64url");
+				return c.json({
+					ok: true,
+					signedPayload,
+					signature: signGatewayPayload(signedPayload)
+				});
+			} catch (error) {
+				return pairingError(c, error);
+			}
+		});
+	}
+}
+function registerPairingApprovalAdminRoutes(app) {
+	app.get("/api/device-pairing/setups/:id", (c) => {
+		try {
+			return c.json({
+				ok: true,
+				...readDevicePairingSetup(c.req.param("id"))
+			});
+		} catch (error) {
+			return pairingError(c, error);
+		}
+	});
+	app.delete("/api/device-pairing/setups/:id", (c) => {
+		cancelDevicePairingSetup(c.req.param("id"));
+		return c.json({ ok: true });
+	});
+	app.post("/api/device-pairing/requests/:id/decision", async (c) => {
+		const parsed = z.strictObject({
+			decision: z.enum(["approve", "reject"]),
+			expectedRevision: z.number().int().positive()
+		}).safeParse(await c.req.json().catch(() => null));
+		if (!parsed.success) return c.json({
+			ok: false,
+			error: {
+				code: "BAD_REQUEST",
+				message: "Invalid decision"
+			}
+		}, 400);
+		try {
+			return c.json({
+				ok: true,
+				request: decideDevicePairingRequest(c.req.param("id"), parsed.data.decision, parsed.data.expectedRevision)
+			});
+		} catch (error) {
+			return pairingError(c, error);
+		}
+	});
+}
+//#endregion
+export { registerPairingApprovalAdminRoutes, registerPairingApprovalPublicRoutes };

package/dist/src/gateway/hono/routes/devices.js

@@ -5,6 +5,7 @@ import { getGatewayIdentityPublicKeyRaw, getOrCreateGatewayIdentity, signGateway
 import { consumeDevicePairingToken, createDevicePairingSetup, isDevicePairingSetupActive } from "../../../storage/sqlite/device-pairing-repository.js";
 import { resolveSecureDeviceRoutes } from "../../device-routes.js";
 import { getGatewayPrincipal } from "../../security/gateway-principal.js";
+import { registerPairingApprovalAdminRoutes, registerPairingApprovalPublicRoutes } from "./device-pairing-approval.js";
 import os from "node:os";
 import { z } from "zod";
 //#region src/gateway/hono/routes/devices.ts
@@ -31,12 +32,10 @@ const pairingExchangeSchema = z.strictObject({
 });
 const pairingProbeSchema = z.strictObject({ pairingId: z.string().uuid() });
 function pairingLinkPayload(input) {
-	return Buffer.from(JSON.stringify({
-		version: 2,
-		...input
-	})).toString("base64url");
+	return Buffer.from(JSON.stringify(input)).toString("base64url");
 }
 function registerDeviceAuthPublicRoutes(app) {
+	registerPairingApprovalPublicRoutes(app);
 	app.post("/api/device-auth/refresh", async (c) => {
 		const parsed = refreshRequestSchema.safeParse(await c.req.json().catch(() => null));
 		if (!parsed.success) return c.json({
@@ -138,15 +137,21 @@ function registerDeviceAuthPublicRoutes(app) {
 	});
 }
 function registerDeviceRoutes(authenticated, deps) {
+	registerPairingApprovalAdminRoutes(authenticated);
 	authenticated.get("/api/device-pairing/readiness", (c) => {
 		const routes = resolveSecureDeviceRoutes(deps.service.currentConfig);
 		return c.json({
 			ok: true,
 			ready: routes.length > 0,
-			routes
+			routes,
+			protocolVersions: [2, 3],
+			routeState: routes.length > 0 ? "configured" : "missing",
+			nextAction: routes.length > 0 ? "scan" : "configure-route",
+			serverTime: Date.now()
 		});
 	});
-	authenticated.post("/api/device-pairing/setups", (c) => {
+	authenticated.post("/api/device-pairing/setups", async (c) => {
+		const version = (await c.req.json().catch(() => ({}))).protocolVersion === 3 ? 3 : 2;
 		const routes = resolveSecureDeviceRoutes(deps.service.currentConfig);
 		if (routes.length === 0) return c.json({
 			ok: false,
@@ -155,9 +160,10 @@ function registerDeviceRoutes(authenticated, deps) {
 				message: "Configure XOPC Secure Link, Tailscale Serve, or an HTTPS public URL first"
 			}
 		}, 409);
-		const setup = createDevicePairingSetup(routes);
+		const setup = createDevicePairingSetup(routes, Date.now(), version);
 		const identity = getOrCreateGatewayIdentity();
 		const encoded = pairingLinkPayload({
+			version,
 			pairingToken: setup.token,
 			gatewayId: identity.id,
 			gatewayName: os.hostname(),
@@ -171,7 +177,8 @@ function registerDeviceRoutes(authenticated, deps) {
 				id: setup.id,
 				universalLink: `https://link.xopc.ai/connect#p=${encoded}`,
 				expiresAt: setup.expiresAt,
-				routes
+				routes,
+				protocolVersion: version
 			}
 		}, 201);
 	});

package/dist/src/gateway/hono/routes/execution-environments.d.ts

@@ -0,0 +1,3 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+export declare function registerExecutionEnvironmentRoutes(authenticated: Hono, deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/execution-environments.js

@@ -0,0 +1,136 @@
+import { ExecutionEnvironmentStore } from "../../../execution-environments/store.js";
+import { LocalWorktreeManager } from "../../../execution-environments/local-worktree-manager.js";
+import { SessionEnvironmentService } from "../../../execution-environments/session-environment-service.js";
+//#region src/gateway/hono/routes/execution-environments.ts
+function executionMode(value) {
+	return value === "local_checkout" || value === "managed_worktree" ? value : void 0;
+}
+function errorResponse(error) {
+	return {
+		ok: false,
+		error: error instanceof Error ? error.message : String(error)
+	};
+}
+function registerExecutionEnvironmentRoutes(authenticated, deps) {
+	const store = new ExecutionEnvironmentStore();
+	const worktrees = new LocalWorktreeManager({ store });
+	const sessions = new SessionEnvironmentService({
+		store,
+		worktrees
+	});
+	authenticated.get("/api/projects/:projectId/environments", (c) => {
+		const projectId = c.req.param("projectId");
+		if (!deps.service.projects.get(projectId)) return c.json({
+			ok: false,
+			error: "Project not found"
+		}, 404);
+		return c.json({
+			ok: true,
+			environments: store.list({
+				projectId,
+				includeDeleted: c.req.query("includeDeleted") === "true"
+			})
+		});
+	});
+	authenticated.get("/api/sessions/:sessionKey/environment", (c) => {
+		const environment = sessions.get(c.req.param("sessionKey"));
+		return environment ? c.json({
+			ok: true,
+			environment
+		}) : c.json({
+			ok: false,
+			error: "Execution environment not found"
+		}, 404);
+	});
+	authenticated.post("/api/sessions/:sessionKey/environment", async (c) => {
+		const sessionKey = c.req.param("sessionKey");
+		if (deps.service.getActiveWebchatRunId(sessionKey)) return c.json({
+			ok: false,
+			error: "Stop the active session run before changing its environment"
+		}, 409);
+		const session = await deps.service.sessions.getSession(sessionKey);
+		if (!session) return c.json({
+			ok: false,
+			error: "Session not found"
+		}, 404);
+		const projectId = session.projectId?.trim();
+		const project = projectId ? deps.service.projects.get(projectId) : null;
+		if (!project) return c.json({
+			ok: false,
+			error: "Session is not attached to a project"
+		}, 409);
+		const body = await c.req.json().catch(() => ({}));
+		const mode = body.mode === void 0 ? void 0 : executionMode(body.mode);
+		if (body.mode !== void 0 && !mode) return c.json({
+			ok: false,
+			error: "Invalid execution mode"
+		}, 400);
+		try {
+			const environment = await sessions.attach({
+				sessionKey,
+				project,
+				mode,
+				baseRef: typeof body.baseRef === "string" ? body.baseRef : void 0
+			});
+			return c.json({
+				ok: true,
+				environment
+			}, 201);
+		} catch (error) {
+			return c.json(errorResponse(error), 409);
+		}
+	});
+	authenticated.delete("/api/sessions/:sessionKey/environment", async (c) => {
+		const sessionKey = c.req.param("sessionKey");
+		if (deps.service.getActiveWebchatRunId(sessionKey)) return c.json({
+			ok: false,
+			error: "Stop the active session run before releasing its environment"
+		}, 409);
+		try {
+			const environment = await sessions.release(sessionKey, c.req.query("keepManaged") !== "true");
+			return c.json({
+				ok: true,
+				environment
+			});
+		} catch (error) {
+			return c.json(errorResponse(error), 409);
+		}
+	});
+	authenticated.get("/api/execution-environments/:environmentId", async (c) => {
+		const environment = store.get(c.req.param("environmentId"));
+		if (!environment) return c.json({
+			ok: false,
+			error: "Execution environment not found"
+		}, 404);
+		const inspection = environment.kind === "managed_worktree" ? await worktrees.inspect(environment.id).catch(() => void 0) : void 0;
+		return c.json({
+			ok: true,
+			environment,
+			...inspection ? { inspection } : {}
+		});
+	});
+	authenticated.post("/api/execution-environments/:environmentId/reconcile", async (c) => {
+		try {
+			const environment = await worktrees.reconcile(c.req.param("environmentId"));
+			return c.json({
+				ok: true,
+				environment
+			});
+		} catch (error) {
+			return c.json(errorResponse(error), 409);
+		}
+	});
+	authenticated.delete("/api/execution-environments/:environmentId", async (c) => {
+		try {
+			const environment = await worktrees.remove(c.req.param("environmentId"));
+			return c.json({
+				ok: true,
+				environment
+			});
+		} catch (error) {
+			return c.json(errorResponse(error), 409);
+		}
+	});
+}
+//#endregion
+export { registerExecutionEnvironmentRoutes };

package/dist/src/gateway/hono/routes/file-references.d.ts

@@ -0,0 +1,4 @@
+import type { Hono } from 'hono';
+import type { AuthenticatedRouteDeps } from './deps.js';
+/** Metadata and explicit desktop actions for links outside a managed workspace. */
+export declare function registerFileReferenceRoutes(app: Hono, deps: AuthenticatedRouteDeps): void;

package/dist/src/gateway/hono/routes/file-references.js

@@ -0,0 +1,98 @@
+import { FileServiceError } from "../../../files/file-service.js";
+import { buildFilePathClassifierContext, classifyFileLocation, displayNameForPath, fileRefSessionKeysMatch, resolveFileReferenceCandidate } from "../../file-path-classifier.js";
+import { classifyFileReferenceFsError } from "../../file-reference-errors.js";
+import { FileReferenceRegistry } from "../../file-reference-registry.js";
+import { getGatewayFileSpaceService } from "../../file-space-service.js";
+import { realpath, stat } from "node:fs/promises";
+//#region src/gateway/hono/routes/file-references.ts
+/** Metadata and explicit desktop actions for links outside a managed workspace. */
+function registerFileReferenceRoutes(app, deps) {
+	const files = getGatewayFileSpaceService(deps.service);
+	const refs = new FileReferenceRegistry();
+	app.post("/api/files/resolve-reference", async (c) => {
+		const body = await c.req.json();
+		if (!body.spaceId || !body.path?.trim()) return c.json({ error: { message: "spaceId and path are required" } }, 400);
+		try {
+			const space = await files.get(body.spaceId);
+			const sessionKey = body.sessionKey?.trim();
+			const agentId = space.bindings.find((binding) => binding.kind === "agent")?.id;
+			const ctx = {
+				...buildFilePathClassifierContext(deps.service.currentConfig, sessionKey || (agentId ? `agent:${agentId}:main` : void 0)),
+				workspaceRoot: space.root
+			};
+			const inputPath = body.path.trim();
+			const base = {
+				inputPath,
+				displayName: displayNameForPath(inputPath)
+			};
+			const { candidate, invalid } = await resolveFileReferenceCandidate(inputPath, space.root, ctx);
+			if (!candidate || invalid) return c.json({ reference: {
+				...base,
+				scope: "invalid",
+				exists: false,
+				capabilities: []
+			} });
+			let absolutePath;
+			let info;
+			try {
+				absolutePath = await realpath(candidate);
+				info = await stat(absolutePath);
+			} catch (error) {
+				const failure = classifyFileReferenceFsError(error);
+				if (failure.code !== "FILE_NOT_FOUND") return c.json({ error: { message: failure.message } }, failure.status === 403 ? 403 : 500);
+				return c.json({ reference: {
+					...base,
+					scope: "missing",
+					absolutePath: candidate,
+					exists: false,
+					capabilities: ["copyPath"]
+				} });
+			}
+			const classified = classifyFileLocation(absolutePath, ctx);
+			const capabilities = info.isFile() || info.isDirectory() ? [
+				"openExternal",
+				"revealInFolder",
+				"copyPath"
+			] : ["copyPath"];
+			const ref = refs.register({
+				absolutePath,
+				sessionKey,
+				...classified,
+				capabilities
+			});
+			return c.json({ reference: {
+				...base,
+				...classified,
+				fileRefId: ref.id,
+				absolutePath,
+				exists: true,
+				isDirectory: info.isDirectory(),
+				capabilities,
+				mtimeMs: info.mtimeMs
+			} });
+		} catch (error) {
+			if (error instanceof FileServiceError) return c.json({ error: { message: error.message } }, error.status);
+			throw error;
+		}
+	});
+	app.post("/api/files/references/:id/action", async (c) => {
+		const ref = refs.resolve(c.req.param("id"));
+		if (!ref) return c.json({ error: { message: "File reference expired" } }, 404);
+		const body = await c.req.json();
+		if (!fileRefSessionKeysMatch(ref.sessionKey, body.sessionKey)) return c.json({ error: { message: "File reference forbidden" } }, 403);
+		if (body.action !== "openExternal" && body.action !== "revealInFolder" || !ref.capabilities.includes(body.action)) return c.json({ error: { message: "Action not allowed" } }, 403);
+		try {
+			if (await realpath(ref.absolutePath) !== ref.absolutePath) return c.json({ error: { message: "File reference changed" } }, 409);
+			const info = await stat(ref.absolutePath);
+			if (!info.isFile() && !info.isDirectory()) return c.json({ error: { message: "Not a file or directory" } }, 400);
+			return c.json({
+				absolutePath: ref.absolutePath,
+				isDirectory: info.isDirectory()
+			});
+		} catch {
+			return c.json({ error: { message: "File not found" } }, 404);
+		}
+	});
+}
+//#endregion
+export { registerFileReferenceRoutes };

package/dist/src/gateway/hono/routes/files.js

@@ -1,8 +1,10 @@
-import { FileServiceError, FileSpaceService, fileResourceFromPath, resolveFilePath } from "../../../files/file-service.js";
+import { FileServiceError, fileResourceFromPath, resolveFilePath } from "../../../files/file-service.js";
+import { getGatewayFileSpaceService } from "../../file-space-service.js";
+import { fuzzySearchWorkspaceFiles, fuzzySubsequenceScore } from "../../workspace-file-search.js";
+import { registerFileReferenceRoutes } from "./file-references.js";
 import { basename, join } from "node:path";
 import { readFile, writeFile } from "node:fs/promises";
 //#region src/gateway/hono/routes/files.ts
-const services = /* @__PURE__ */ new WeakMap();
 const mutationLocks = /* @__PURE__ */ new Map();
 async function withMutationLock(key, action) {
 	const previous = mutationLocks.get(key) ?? Promise.resolve();
@@ -20,13 +22,6 @@ async function withMutationLock(key, action) {
 		if (mutationLocks.get(key) === tail) mutationLocks.delete(key);
 	}
 }
-function getFiles(deps) {
-	const existing = services.get(deps.service);
-	if (existing) return existing;
-	const created = new FileSpaceService(() => deps.service.currentConfig, deps.service.projects, (sessionKey) => deps.service.agentService.getResolvedWorkspaceForSession(sessionKey));
-	services.set(deps.service, created);
-	return created;
-}
 function publicSpace(space) {
 	const { root: _root, ...value } = space;
 	return value;
@@ -39,22 +34,28 @@ function contentDisposition(disposition, fileName) {
 	const sanitized = fileName.replace(/[\u0000-\u001f\u007f]/g, "_");
 	return `${disposition}; filename="${sanitized.replace(/[^\x20-\x7e]/g, "_").replace(/["\\]/g, "_")}"; filename*=UTF-8''${encodeURIComponent(sanitized).replace(/['()*]/g, (character) => `%${character.charCodeAt(0).toString(16).toUpperCase()}`)}`;
 }
-async function collectFiles(files, spaceId, query, max) {
+async function collectFiles(files, spaceId, max) {
 	const output = [];
 	const directories = [""];
+	const visited = /* @__PURE__ */ new Set();
+	const space = await files.get(spaceId);
 	while (directories.length && output.length < max) {
 		const directory = directories.shift();
+		const canonical = await resolveFilePath(space.root, directory).catch(() => null);
+		if (!canonical || visited.has(canonical)) continue;
+		visited.add(canonical);
 		const children = await files.children(spaceId, directory);
 		for (const child of children) {
 			if (child.kind === "directory") directories.push(child.relativePath);
-			else if (!query || child.name.toLocaleLowerCase().includes(query)) output.push(child);
+			else output.push(child);
 			if (output.length >= max) break;
 		}
 	}
 	return output;
 }
 function registerFilesRoutes(authenticated, deps) {
-	const files = getFiles(deps);
+	const files = getGatewayFileSpaceService(deps.service);
+	registerFileReferenceRoutes(authenticated, deps);
 	authenticated.get("/api/files/spaces", async (c) => {
 		try {
 			return c.json({ spaces: (await files.list()).map(publicSpace) });
@@ -62,6 +63,13 @@ function registerFilesRoutes(authenticated, deps) {
 			return errorResponse(c, error);
 		}
 	});
+	authenticated.get("/api/files/default-space", async (c) => {
+		try {
+			return c.json({ space: publicSpace(await files.defaultSpace()) });
+		} catch (error) {
+			return errorResponse(c, error);
+		}
+	});
 	authenticated.get("/api/files/contexts/:kind/:id", async (c) => {
 		try {
 			const kind = c.req.param("kind");
@@ -82,7 +90,7 @@ function registerFilesRoutes(authenticated, deps) {
 		try {
 			const limit = Math.min(100, Math.max(1, Number(c.req.query("limit")) || 50));
 			const spaces = await files.list();
-			const items = (await Promise.all(spaces.map((space) => collectFiles(files, space.id, "", 5e3)))).flat().sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, limit);
+			const items = (await Promise.all(spaces.map((space) => collectFiles(files, space.id, 5e3)))).flat().sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, limit);
 			return c.json({ items });
 		} catch (error) {
 			return errorResponse(c, error);
@@ -91,11 +99,23 @@ function registerFilesRoutes(authenticated, deps) {
 	authenticated.get("/api/files/search", async (c) => {
 		try {
 			const query = (c.req.query("q") ?? "").trim().toLocaleLowerCase();
-			if (!query) return c.json({ items: [] });
 			const limit = Math.min(100, Math.max(1, Number(c.req.query("limit")) || 50));
 			const requestedSpaceId = c.req.query("spaceId");
 			const spaces = requestedSpaceId ? [await files.get(requestedSpaceId)] : await files.list();
-			const items = (await Promise.all(spaces.map((space) => collectFiles(files, space.id, query, 5e3)))).flat().sort((a, b) => b.modifiedAt - a.modifiedAt).slice(0, limit);
+			const items = (await Promise.all(spaces.map(async (space) => {
+				const candidates = await fuzzySearchWorkspaceFiles(space.root, query, limit);
+				return Promise.all(candidates.map(async (candidate) => {
+					try {
+						return await fileResourceFromPath(space, await resolveFilePath(space.root, candidate.path));
+					} catch (error) {
+						if (error instanceof FileServiceError) return null;
+						throw error;
+					}
+				}));
+			}))).flat().filter((file) => file !== null).map((file) => ({
+				file,
+				score: Math.max(fuzzySubsequenceScore(query, file.relativePath) ?? -Infinity, fuzzySubsequenceScore(query, file.name) ?? -Infinity)
+			})).sort((a, b) => b.score - a.score || a.file.relativePath.localeCompare(b.file.relativePath)).slice(0, limit).map((row) => row.file);
 			return c.json({ items });
 		} catch (error) {
 			return errorResponse(c, error);
@@ -144,12 +164,14 @@ function registerFilesRoutes(authenticated, deps) {
 			const body = await c.req.json();
 			if (typeof body.content !== "string" || !body.revision) throw new FileServiceError(400, "content and revision are required");
 			const id = c.req.param("id");
-			const resource = await withMutationLock(id, async () => {
+			const initial = await files.resource(id);
+			const resource = await withMutationLock(initial.absolutePath, async () => {
 				const current = await files.resource(id);
+				if (current.absolutePath !== initial.absolutePath) throw new FileServiceError(409, "File has changed");
 				if (!current.resource.capabilities.includes("edit")) throw new FileServiceError(403, "File is not editable");
 				if (body.revision !== current.resource.revision) throw new FileServiceError(409, "File has changed");
 				await writeFile(current.absolutePath, body.content, "utf8");
-				return fileResourceFromPath(current.space, current.absolutePath);
+				return (await files.resource(id)).resource;
 			});
 			return c.json({ resource });
 		} catch (error) {