wiki-viewer 1.7.2 → 1.8.1

package/.next/standalone/packages/wiki-viewer-mcp/src/index.ts

@@ -9,6 +9,7 @@
  *   WIKI_VIEWER_URL      Base URL of wiki-viewer instance (required)
  *   WIKI_VIEWER_TOKEN    Bearer token from TOFU registration (required)
  *   WIKI_VIEWER_AGENT_ID X-Agent-Id header value (required)
+ *   WIKI_VIEWER_WORKSPACE  Workspace id for X-Workspace header (optional; targets one workspace)
  *
  * Mode-awareness:
  *   Before any raw write to a .md file, the shim checks the cached
@@ -76,12 +77,14 @@ export function createClient(overrides?: {
   baseUrl?: string;
   token?: string;
   agentId?: string;
+  workspace?: string;
   fetch?: typeof fetch;
 }): WikiViewerClient {
   return new WikiViewerClient({
     baseUrl: overrides?.baseUrl ?? requireEnv("WIKI_VIEWER_URL"),
     token: overrides?.token ?? requireEnv("WIKI_VIEWER_TOKEN"),
     agentId: overrides?.agentId ?? requireEnv("WIKI_VIEWER_AGENT_ID"),
+    workspace: overrides?.workspace ?? process.env.WIKI_VIEWER_WORKSPACE,
     fetch: overrides?.fetch,
   });
 }
@@ -524,6 +527,7 @@ async function runRegister() {
       "scope-paths": { type: "string", default: "**/*" },
       ops: { type: "string", default: "read,mutate" },
       timeout: { type: "string", default: "300" },
+      workspace: { type: "string" },
     },
     allowPositionals: true,
   });
@@ -595,6 +599,7 @@ async function runRegister() {
             WIKI_VIEWER_URL: values.url,
             WIKI_VIEWER_TOKEN: result.token,
             WIKI_VIEWER_AGENT_ID: result.agentId,
+            ...(values.workspace ? { WIKI_VIEWER_WORKSPACE: values.workspace } : {}),
           },
         },
       },

package/.next/standalone/src/app/api/agent/activity/route.ts

@@ -1,6 +1,6 @@
 import { NextResponse } from "next/server";
 import { checkAuth, enforceScope } from "@/lib/proof/auth";
-import { getRootDir } from "@/lib/root-dir";
+import { resolveWorkspaceForAgent } from "@/lib/workspace-context";
 import {
 	aggregateActivity,
 	ACTIVITY_DEFAULT_LIMIT,
@@ -16,14 +16,15 @@ export async function GET(req: Request): Promise<NextResponse> {
 		return NextResponse.json({ error: "UNAUTHORIZED" }, { status: 401 });
 	}
 
-	const scopeCheck = enforceScope(auth.agent, { op: "read" });
-	if (!scopeCheck.ok) {
-		return NextResponse.json({ error: scopeCheck.code, message: scopeCheck.message }, { status: 403 });
+	const wsx = await resolveWorkspaceForAgent(req);
+	if (!wsx.ok) {
+		return NextResponse.json({ error: wsx.code }, { status: wsx.status });
 	}
+	const { ws, rootDir } = wsx;
 
-	const rootDir = getRootDir();
-	if (!rootDir) {
-		return NextResponse.json({ error: "ROOT_NOT_SET" }, { status: 503 });
+	const scopeCheck = enforceScope(auth.agent, { op: "read", workspaceId: ws.id });
+	if (!scopeCheck.ok) {
+		return NextResponse.json({ error: scopeCheck.code, message: scopeCheck.message }, { status: 403 });
 	}
 
 	const url = new URL(req.url);
@@ -32,7 +33,7 @@ export async function GET(req: Request): Promise<NextResponse> {
 
 	// Enforce scope on explicit file query parameter
 	if (fileFilter) {
-		const fileScope = enforceScope(auth.agent, { filePath: fileFilter, op: "read" });
+		const fileScope = enforceScope(auth.agent, { filePath: fileFilter, op: "read", workspaceId: ws.id });
 		if (!fileScope.ok) {
 			return NextResponse.json({ error: fileScope.code, message: fileScope.message }, { status: 403 });
 		}

package/.next/standalone/src/app/api/agent/events/[...path]/route.ts

@@ -3,7 +3,8 @@ import { checkAuth, enforceScope, verifyBy } from "@/lib/proof/auth";
 import { readSidecar, writeSidecar, emptySidecar } from "@/lib/proof/sidecar";
 import { pollEvents } from "@/lib/proof/event-bus";
 import { withFileMutex } from "@/lib/proof/mutex";
-import { getRootDir, safeRootPath } from "@/lib/root-dir";
+import { resolveWorkspaceForAgent } from "@/lib/workspace-context";
+import { safeWorkspacePath } from "@/lib/workspaces";
 
 export const runtime = "nodejs";
 
@@ -28,6 +29,12 @@ export async function GET(
 		return NextResponse.json({ error: "UNAUTHORIZED" }, { status: 401 });
 	}
 
+	const wsx = await resolveWorkspaceForAgent(req);
+	if (!wsx.ok) {
+		return NextResponse.json({ error: wsx.code }, { status: wsx.status });
+	}
+	const { ws, rootDir } = wsx;
+
 	const { path: segments } = await params;
 	const rel = mdPath(segments);
 
@@ -38,12 +45,12 @@ export async function GET(
 		return NextResponse.json({ error: "INVALID_PATH", message: "Path must be .md or .markdown" }, { status: 400 });
 	}
 
-	const absPath = safeRootPath(rel);
+	const absPath = safeWorkspacePath(rootDir, rel);
 	if (!absPath) {
 		return NextResponse.json({ error: "INVALID_PATH", message: "Path traversal rejected" }, { status: 400 });
 	}
 
-	const scopeCheck = enforceScope(auth.agent, { filePath: rel, op: "read" });
+	const scopeCheck = enforceScope(auth.agent, { filePath: rel, op: "read", workspaceId: ws.id });
 	if (!scopeCheck.ok) {
 		return NextResponse.json({ error: scopeCheck.code, message: scopeCheck.message }, { status: 403 });
 	}
@@ -65,7 +72,6 @@ export async function GET(
 		limit = MAX_LIMIT;
 	}
 
-	const rootDir = getRootDir();
 	const sidecar = (await readSidecar(rootDir, rel)) ?? emptySidecar(rel);
 	const events = pollEvents(sidecar, after, limit);
 	const lastEventId = sidecar.nextEventId - 1;
@@ -83,6 +89,12 @@ export async function POST(
 		return NextResponse.json({ error: "UNAUTHORIZED" }, { status: 401 });
 	}
 
+	const wsx = await resolveWorkspaceForAgent(req);
+	if (!wsx.ok) {
+		return NextResponse.json({ error: wsx.code }, { status: wsx.status });
+	}
+	const { ws, rootDir } = wsx;
+
 	const { path: segments } = await params;
 	const rel = mdPath(segments);
 
@@ -93,12 +105,12 @@ export async function POST(
 		return NextResponse.json({ error: "INVALID_PATH", message: "Path must be .md or .markdown" }, { status: 400 });
 	}
 
-	const absPath = safeRootPath(rel);
+	const absPath = safeWorkspacePath(rootDir, rel);
 	if (!absPath) {
 		return NextResponse.json({ error: "INVALID_PATH", message: "Path traversal rejected" }, { status: 400 });
 	}
 
-	const scopeCheck = enforceScope(auth.agent, { filePath: rel, op: "mutate" });
+	const scopeCheck = enforceScope(auth.agent, { filePath: rel, op: "mutate", workspaceId: ws.id });
 	if (!scopeCheck.ok) {
 		return NextResponse.json({ error: scopeCheck.code, message: scopeCheck.message }, { status: 403 });
 	}
@@ -122,11 +134,11 @@ export async function POST(
 		return NextResponse.json({ error: byCheck.code, message: byCheck.message }, { status: 403 });
 	}
 
-	const rootDir = getRootDir();
 	const upToId = body.upToId as number;
 	const by = body.by as string;
 
-	await withFileMutex(rel, async () => {
+	// Namespace mutex key with rootDir to prevent cross-workspace lock contention.
+	await withFileMutex(`${rootDir}\0${rel}`, async () => {
 		const sidecar = (await readSidecar(rootDir, rel)) ?? emptySidecar(rel);
 		sidecar.lastAck[by] = upToId;
 		await writeSidecar(rootDir, rel, sidecar);

package/.next/standalone/src/app/api/agent/files/[...path]/route.ts

@@ -18,7 +18,8 @@ import { NextResponse } from "next/server";
 import { checkAuth, enforceScope, verifyBy } from "@/lib/proof/auth";
 import { applyOps, readSnapshot } from "@/lib/proof/ops-applier";
 import { idempotency } from "@/lib/proof/idempotency";
-import { getRootDir, safeRootPath } from "@/lib/root-dir";
+import { resolveWorkspaceForAgent } from "@/lib/workspace-context";
+import { safeWorkspacePath } from "@/lib/workspaces";
 import type { Op } from "@/lib/proof/types";
 import { checkAndConsume } from "@/lib/proof/rate-limit";
 import { computeCollabState } from "@/lib/proof/collab-state";
@@ -52,17 +53,20 @@ export async function GET(
 		return NextResponse.json({ error: "INVALID_PATH", message: "Path must be .md or .markdown" }, { status: 400 });
 	}
 
-	const absPath = safeRootPath(rel);
+	const wsx = await resolveWorkspaceForAgent(req);
+	if (!wsx.ok) return NextResponse.json({ error: wsx.code }, { status: wsx.status });
+	const { ws, rootDir } = wsx;
+
+	const absPath = safeWorkspacePath(rootDir, rel);
 	if (!absPath) {
 		return NextResponse.json({ error: "INVALID_PATH", message: "Path traversal rejected" }, { status: 400 });
 	}
 
-	const scopeCheck = enforceScope(auth.agent, { filePath: rel, op: "read" });
+	const scopeCheck = enforceScope(auth.agent, { filePath: rel, op: "read", workspaceId: ws.id });
 	if (!scopeCheck.ok) {
 		return NextResponse.json({ error: scopeCheck.code, message: scopeCheck.message }, { status: 403 });
 	}
 
-	const rootDir = getRootDir();
 	const snapshot = await readSnapshot(rootDir, rel);
 	if (!snapshot) {
 		return NextResponse.json({ error: "NOT_FOUND", message: "File not found" }, { status: 404 });
@@ -107,7 +111,11 @@ export async function POST(
 		return NextResponse.json({ error: "INVALID_PATH", message: "Path must be .md or .markdown" }, { status: 400 });
 	}
 
-	const absPath = safeRootPath(rel);
+	const wsx = await resolveWorkspaceForAgent(req);
+	if (!wsx.ok) return NextResponse.json({ error: wsx.code }, { status: wsx.status });
+	const { ws, rootDir } = wsx;
+
+	const absPath = safeWorkspacePath(rootDir, rel);
 	if (!absPath) {
 		return NextResponse.json({ error: "INVALID_PATH", message: "Path traversal rejected" }, { status: 400 });
 	}
@@ -123,7 +131,7 @@ export async function POST(
 	const payloadHash = createHash("sha256").update(rawBody, "utf8").digest("hex");
 
 	// Check idempotency cache
-	const cached = idempotency.get(idempotencyKey);
+	const cached = idempotency.get(`${rootDir}\u0000${idempotencyKey}`);
 	if (cached) {
 		if (cached.payloadHash !== payloadHash) {
 			return NextResponse.json(
@@ -154,7 +162,7 @@ export async function POST(
 		return NextResponse.json({ error: "INVALID_PAYLOAD", message: "ops (array) required" }, { status: 400 });
 	}
 
-	const scopeCheck = enforceScope(auth.agent, { filePath: rel, op: "mutate" });
+	const scopeCheck = enforceScope(auth.agent, { filePath: rel, op: "mutate", workspaceId: ws.id });
 	if (!scopeCheck.ok) {
 		return NextResponse.json({ error: scopeCheck.code, message: scopeCheck.message }, { status: 403 });
 	}
@@ -181,7 +189,6 @@ export async function POST(
 		);
 	}
 
-	const rootDir = getRootDir();
 	const result = await applyOps({
 		rootDir,
 		mdPath: rel,
@@ -203,7 +210,7 @@ export async function POST(
 		responseBody = JSON.stringify(payload);
 	}
 
-	idempotency.set(idempotencyKey, { payloadHash, status, body: responseBody });
+	idempotency.set(`${rootDir}\u0000${idempotencyKey}`, { payloadHash, status, body: responseBody });
 
 	return new NextResponse(responseBody, {
 		status,

package/.next/standalone/src/app/api/agent/fs/file/[...path]/route.ts

@@ -11,7 +11,8 @@ import { readFile, stat, unlink, rm } from "node:fs/promises";
 import path from "node:path";
 import { NextResponse } from "next/server";
 import { checkAuth, enforceScope } from "@/lib/proof/auth";
-import { getRootDir, safeRootPath } from "@/lib/root-dir";
+import { resolveWorkspaceForAgent } from "@/lib/workspace-context";
+import { safeWorkspacePath } from "@/lib/workspaces";
 import { withFileMutex } from "@/lib/proof/mutex";
 import { readSidecar, emptySidecar, deleteSidecar } from "@/lib/proof/sidecar";
 import { reconcileSidecar } from "@/lib/proof/ops-applier";
@@ -50,13 +51,17 @@ export async function GET(
 	const { path: segments } = await params;
 	const relPath = rel(segments);
 
-	const basic = safeRootPath(relPath);
+	const wsx = await resolveWorkspaceForAgent(req);
+	if (!wsx.ok) return errJson(wsx.code, wsx.code, wsx.status);
+	const { ws, rootDir } = wsx;
+
+	const basic = safeWorkspacePath(rootDir, relPath);
 	if (!basic) return errJson("INVALID_PATH", "Path traversal rejected", 400);
 
-	const absPath = await safeAbsPath(relPath);
+	const absPath = await safeAbsPath(rootDir, relPath);
 	if (!absPath) return errJson("INVALID_PATH", "Path rejected (symlink escape or denied)", 400);
 
-	const scope = enforceScope(auth.agent, { filePath: relPath, op: "read" });
+	const scope = enforceScope(auth.agent, { filePath: relPath, op: "read", workspaceId: ws.id });
 	if (!scope.ok) return errJson(scope.code, scope.message, 403);
 
 	let data: Buffer;
@@ -84,7 +89,6 @@ export async function GET(
 	};
 
 	// X-Collab-* headers (§3.5 mode signal)
-	const rootDir = getRootDir();
 	const collab = await computeCollabState(rootDir, relPath);
 	if (collab.state !== "not-markdown") {
 		baseHeaders["X-Collab-State"] = collab.state;
@@ -148,23 +152,26 @@ async function applyMutation(
 	const auth = await checkAuth(req);
 	if (!auth.ok) return errJson("UNAUTHORIZED", auth.message ?? "Unauthorized", 401);
 
+	const wsx = await resolveWorkspaceForAgent(req);
+	if (!wsx.ok) return errJson(wsx.code, wsx.code, wsx.status);
+	const { ws, rootDir } = wsx;
+
 	const relPath = rel(segments);
 	const url = new URL(req.url);
 	const mkdirs = url.searchParams.get("mkdirs") === "true";
 	const force = url.searchParams.get("force") === "true";
 
-	const basic = safeRootPath(relPath);
+	const basic = safeWorkspacePath(rootDir, relPath);
 	if (!basic) return errJson("INVALID_PATH", "Path traversal rejected", 400);
 
-	const absPath = await safeAbsPath(relPath);
+	const absPath = await safeAbsPath(rootDir, relPath);
 	if (!absPath) return errJson("INVALID_PATH", "Path rejected (symlink escape or denied)", 400);
 
-	const scope = enforceScope(auth.agent, { filePath: relPath, op: "mutate" });
+	const scope = enforceScope(auth.agent, { filePath: relPath, op: "mutate", workspaceId: ws.id });
 	if (!scope.ok) return errJson(scope.code, scope.message, 403);
 
 	const ifMatch = req.headers.get("if-match");
 	const ifCollabMatch = req.headers.get("if-collab-match");
-	const rootDir = getRootDir();
 
 	// The whole read-existing → precondition → compute → write → reconcile → audit
 	// sequence runs inside the mutex for .md (so R6 and reconcile are atomic with
@@ -256,6 +263,7 @@ async function applyMutation(
 			oldSha: existingSha,
 			newSha,
 			forced: force,
+			workspaceId: ws.id,
 		});
 
 		const st = await stat(absPath);
@@ -268,7 +276,7 @@ async function applyMutation(
 		});
 	};
 
-	return isMarkdown(relPath) ? withFileMutex(relPath, doMutation) : doMutation();
+	return isMarkdown(relPath) ? withFileMutex(`${rootDir}\u0000${relPath}`, doMutation) : doMutation();
 }
 
 // ── PUT ──────────────────────────────────────────────────────────────────────
@@ -377,14 +385,18 @@ export async function DELETE(
 	const url = new URL(req.url);
 	const recursive = url.searchParams.get("recursive") === "true";
 
-	const basic = safeRootPath(relPath);
+	const wsx = await resolveWorkspaceForAgent(req);
+	if (!wsx.ok) return errJson(wsx.code, wsx.code, wsx.status);
+	const { ws, rootDir } = wsx;
+
+	const basic = safeWorkspacePath(rootDir, relPath);
 	if (!basic) return errJson("INVALID_PATH", "Path traversal rejected", 400);
 
-	const absPath = await safeAbsPath(relPath);
+	const absPath = await safeAbsPath(rootDir, relPath);
 	if (!absPath) return errJson("INVALID_PATH", "Path rejected (symlink escape or denied)", 400);
 
 	// Requires "delete" scope op
-	const scope = enforceScope(auth.agent, { filePath: relPath, op: "delete" });
+	const scope = enforceScope(auth.agent, { filePath: relPath, op: "delete", workspaceId: ws.id });
 	if (!scope.ok) return errJson(scope.code, scope.message, 403);
 
 	const ifMatch = req.headers.get("if-match");
@@ -405,7 +417,7 @@ export async function DELETE(
 		}
 		// Directory delete — no single sha, skip If-Match; require recursive flag as confirmation
 		await rm(absPath, { recursive: true, force: true });
-		writeAuditRow({ agentId: auth.agent.id, op: "delete", path: relPath, forced: false });
+		writeAuditRow({ agentId: auth.agent.id, op: "delete", path: relPath, forced: false, workspaceId: ws.id });
 		return NextResponse.json({ deleted: relPath });
 	}
 
@@ -420,10 +432,8 @@ export async function DELETE(
 		return errJson("PRECONDITION_FAILED", "If-Match sha256 mismatch", 412);
 	}
 
-	const rootDir = getRootDir();
-
 	if (isMarkdown(relPath)) {
-		await withFileMutex(relPath, async () => {
+		await withFileMutex(`${rootDir}\u0000${relPath}`, async () => {
 			await unlink(absPath);
 			await deleteSidecar(rootDir, relPath);
 		});
@@ -431,6 +441,6 @@ export async function DELETE(
 		await unlink(absPath);
 	}
 
-	writeAuditRow({ agentId: auth.agent.id, op: "delete", path: relPath, oldSha: existingSha, forced: false });
+	writeAuditRow({ agentId: auth.agent.id, op: "delete", path: relPath, oldSha: existingSha, forced: false, workspaceId: ws.id });
 	return NextResponse.json({ deleted: relPath });
 }

package/.next/standalone/src/app/api/agent/fs/ls/[[...path]]/route.ts

@@ -13,7 +13,8 @@ import { readdir, stat } from "node:fs/promises";
 import path from "node:path";
 import { NextResponse } from "next/server";
 import { checkAuth, enforceScope } from "@/lib/proof/auth";
-import { getRootDir, safeRootPath } from "@/lib/root-dir";
+import { resolveWorkspaceForAgent } from "@/lib/workspace-context";
+import { safeWorkspacePath } from "@/lib/workspaces";
 import { safeAbsPath } from "@/lib/proof/raw-fs";
 import type { Agent } from "@/lib/proof/registry";
 
@@ -44,6 +45,7 @@ async function walkDir(
 	maxDepth: number,
 	limit: number,
 	results: LsEntry[],
+	workspaceId?: string,
 ): Promise<void> {
 	if (depth > maxDepth || results.length >= limit) return;
 
@@ -63,7 +65,7 @@ async function walkDir(
 		const childRel = relDir ? `${relDir}/${item.name}` : item.name;
 
 		// Scope check per entry
-		const sc = enforceScope(agent, { filePath: childRel, op: "read" });
+		const sc = enforceScope(agent, { filePath: childRel, op: "read", workspaceId });
 		if (!sc.ok) continue;
 
 		let type: LsEntry["type"];
@@ -88,7 +90,7 @@ async function walkDir(
 		results.push({ name: item.name, path: childRel, type, size, mtime });
 
 		if (recursive && type === "dir") {
-			await walkDir(rootDir, childRel, agent, recursive, depth + 1, maxDepth, limit, results);
+			await walkDir(rootDir, childRel, agent, recursive, depth + 1, maxDepth, limit, results, workspaceId);
 		}
 	}
 }
@@ -103,10 +105,14 @@ export async function GET(
 	const { path: segments } = await params;
 	const relPath = segments ? segments.join("/") : "";
 
+	const wsx = await resolveWorkspaceForAgent(req);
+	if (!wsx.ok) return errJson(wsx.code, wsx.code, wsx.status);
+	const { ws, rootDir } = wsx;
+
 	if (relPath) {
-		const basic = safeRootPath(relPath);
+		const basic = safeWorkspacePath(rootDir, relPath);
 		if (!basic) return errJson("INVALID_PATH", "Path traversal rejected", 400);
-		const safe = await safeAbsPath(relPath);
+		const safe = await safeAbsPath(rootDir, relPath);
 		if (!safe) return errJson("INVALID_PATH", "Path rejected (symlink escape or denied)", 400);
 	}
 
@@ -122,7 +128,6 @@ export async function GET(
 	);
 
 	// Verify the dir actually exists
-	const rootDir = getRootDir();
 	const absDir = relPath ? path.join(rootDir, relPath) : rootDir;
 	try {
 		const st = await stat(absDir);
@@ -137,7 +142,7 @@ export async function GET(
 	}
 
 	const entries: LsEntry[] = [];
-	await walkDir(rootDir, relPath, auth.agent, recursive, 0, depth, limit, entries);
+	await walkDir(rootDir, relPath, auth.agent, recursive, 0, depth, limit, entries, ws.id);
 
 	return NextResponse.json({
 		path: relPath,

package/.next/standalone/src/app/api/agent/fs/move/route.ts

@@ -14,7 +14,8 @@ import { rename, stat } from "node:fs/promises";
 import path from "node:path";
 import { NextResponse } from "next/server";
 import { checkAuth, enforceScope } from "@/lib/proof/auth";
-import { getRootDir, safeRootPath } from "@/lib/root-dir";
+import { resolveWorkspaceForAgent } from "@/lib/workspace-context";
+import { safeWorkspacePath } from "@/lib/workspaces";
 import { withFileMutex } from "@/lib/proof/mutex";
 import { moveSidecar } from "@/lib/proof/sidecar";
 import { writeAuditRow } from "@/lib/proof/audit";
@@ -47,13 +48,17 @@ export async function POST(req: Request): Promise<NextResponse> {
 	const toRel = body.to;
 	const ifMatch = typeof body.ifMatch === "string" ? body.ifMatch : undefined;
 
+	const wsx = await resolveWorkspaceForAgent(req);
+	if (!wsx.ok) return errJson(wsx.code, wsx.code, wsx.status);
+	const { ws, rootDir } = wsx;
+
 	// Basic traversal
-	if (!safeRootPath(fromRel)) return errJson("INVALID_PATH", "from: path traversal rejected", 400);
-	if (!safeRootPath(toRel)) return errJson("INVALID_PATH", "to: path traversal rejected", 400);
+	if (!safeWorkspacePath(rootDir, fromRel)) return errJson("INVALID_PATH", "from: path traversal rejected", 400);
+	if (!safeWorkspacePath(rootDir, toRel)) return errJson("INVALID_PATH", "to: path traversal rejected", 400);
 
-	const fromAbs = await safeAbsPath(fromRel);
+	const fromAbs = await safeAbsPath(rootDir, fromRel);
 	if (!fromAbs) return errJson("INVALID_PATH", "from: path rejected (symlink escape or denied)", 400);
-	const toAbs = await safeAbsPath(toRel);
+	const toAbs = await safeAbsPath(rootDir, toRel);
 	if (!toAbs) return errJson("INVALID_PATH", "to: path rejected (symlink escape or denied)", 400);
 
 	// Self-move guard
@@ -63,11 +68,11 @@ export async function POST(req: Request): Promise<NextResponse> {
 	}
 
 	// Scope: source requires read+mutate; dest requires mutate
-	const sc1 = enforceScope(auth.agent, { filePath: fromRel, op: "read" });
+	const sc1 = enforceScope(auth.agent, { filePath: fromRel, op: "read", workspaceId: ws.id });
 	if (!sc1.ok) return errJson(sc1.code, sc1.message, 403);
-	const sc2 = enforceScope(auth.agent, { filePath: fromRel, op: "mutate" });
+	const sc2 = enforceScope(auth.agent, { filePath: fromRel, op: "mutate", workspaceId: ws.id });
 	if (!sc2.ok) return errJson(sc2.code, sc2.message, 403);
-	const sc3 = enforceScope(auth.agent, { filePath: toRel, op: "mutate" });
+	const sc3 = enforceScope(auth.agent, { filePath: toRel, op: "mutate", workspaceId: ws.id });
 	if (!sc3.ok) return errJson(sc3.code, sc3.message, 403);
 
 	// Verify source exists
@@ -95,7 +100,6 @@ export async function POST(req: Request): Promise<NextResponse> {
 		}
 	}
 
-	const rootDir = getRootDir();
 	const isMd = isMarkdown(fromRel);
 
 	// Lock source + dest in sorted order to avoid deadlock
@@ -112,13 +116,14 @@ export async function POST(req: Request): Promise<NextResponse> {
 			path: fromRel,
 			newSha: toRel, // store destination in newSha field for audit trail
 			forced: false,
+			workspaceId: ws.id,
 		});
 	};
 
 	if (first === fromRel) {
-		await withFileMutex(first, () => withFileMutex(second, doMove));
+		await withFileMutex(`${rootDir}\u0000${first}`, () => withFileMutex(`${rootDir}\u0000${second}`, doMove));
 	} else {
-		await withFileMutex(first, () => withFileMutex(second, doMove));
+		await withFileMutex(`${rootDir}\u0000${first}`, () => withFileMutex(`${rootDir}\u0000${second}`, doMove));
 	}
 
 	return NextResponse.json({ from: fromRel, to: toRel });

package/.next/standalone/src/app/api/agent/fs/search/route.ts

@@ -19,10 +19,12 @@
 export const runtime = "nodejs";
 
 import { readdir, readFile, stat } from "node:fs/promises";
+import { ensureIndexer, ftsSearch } from "@/lib/search/indexer";
 import path from "node:path";
 import { NextResponse } from "next/server";
 import { checkAuth, enforceScope } from "@/lib/proof/auth";
-import { getRootDir, safeRootPath } from "@/lib/root-dir";
+import { resolveWorkspaceForAgent } from "@/lib/workspace-context";
+import { safeWorkspacePath } from "@/lib/workspaces";
 import { safeAbsPath, looksLikeBinary } from "@/lib/proof/raw-fs";
 import { matchGlob } from "@/lib/proof/glob";
 import type { Agent } from "@/lib/proof/registry";
@@ -36,6 +38,8 @@ export interface SearchMatch {
 	line?: number;
 	col?: number;
 	text?: string;
+	score?: number;
+	snippet?: string;
 }
 
 function errJson(code: string, message: string, status: number): NextResponse {
@@ -74,6 +78,7 @@ async function grepSearch(
 	limit: number,
 	agent: Agent,
 	deadline: number,
+	workspaceId?: string,
 ): Promise<{ matches: SearchMatch[]; truncated: boolean }> {
 	let regex: RegExp;
 	try {
@@ -94,7 +99,7 @@ async function grepSearch(
 		if (matches.length >= limit) return { matches, truncated: true };
 		if (Date.now() > deadline) return { matches, truncated: true };
 
-		const sc = enforceScope(agent, { filePath: fileRel, op: "read" });
+		const sc = enforceScope(agent, { filePath: fileRel, op: "read", workspaceId });
 		if (!sc.ok) continue;
 
 		let buf: Buffer;
@@ -140,6 +145,7 @@ async function globSearch(
 	limit: number,
 	agent: Agent,
 	deadline: number,
+	workspaceId?: string,
 ): Promise<{ matches: SearchMatch[]; truncated: boolean }> {
 	const matches: SearchMatch[] = [];
 
@@ -151,7 +157,7 @@ async function globSearch(
 		const baseName = path.basename(fileRel);
 		if (!matchGlob(pattern, fileRel) && !matchGlob(pattern, baseName)) continue;
 
-		const sc = enforceScope(agent, { filePath: fileRel, op: "read" });
+		const sc = enforceScope(agent, { filePath: fileRel, op: "read", workspaceId });
 		if (!sc.ok) continue;
 
 		matches.push({ path: fileRel });
@@ -173,14 +179,17 @@ export async function POST(req: Request): Promise<NextResponse> {
 		return errJson("INVALID_PAYLOAD", "Invalid JSON body", 400);
 	}
 
-	if (body.kind !== "grep" && body.kind !== "glob") {
-		return errJson("INVALID_PAYLOAD", 'kind must be "grep" or "glob"', 400);
+	if (body.kind !== "grep" && body.kind !== "glob" && body.kind !== "fts") {
+		return errJson("INVALID_PAYLOAD", 'kind must be "grep", "glob", or "fts"', 400);
 	}
-	if (typeof body.query !== "string" || !body.query) {
+	if (typeof body.query !== "string") {
+		return errJson("INVALID_PAYLOAD", "query (string) required", 400);
+	}
+	if (body.kind !== "fts" && !body.query) {
 		return errJson("INVALID_PAYLOAD", "query (string) required", 400);
 	}
 
-	const kind = body.kind as "grep" | "glob";
+	const kind = body.kind as "grep" | "glob" | "fts";
 	const query = body.query as string;
 	const startRelRaw = typeof body.path === "string" ? body.path : "";
 	const limit = Math.min(
@@ -188,17 +197,19 @@ export async function POST(req: Request): Promise<NextResponse> {
 		HARD_MAX_MATCHES,
 	);
 
+	const wsx = await resolveWorkspaceForAgent(req);
+	if (!wsx.ok) return errJson(wsx.code, wsx.code, wsx.status);
+	const { ws, rootDir } = wsx;
+
 	// Validate start path
 	if (startRelRaw) {
-		if (!safeRootPath(startRelRaw)) {
+		if (!safeWorkspacePath(rootDir, startRelRaw)) {
 			return errJson("INVALID_PATH", "path: traversal rejected", 400);
 		}
-		const safe = await safeAbsPath(startRelRaw);
+		const safe = await safeAbsPath(rootDir, startRelRaw);
 		if (!safe) return errJson("INVALID_PATH", "path: rejected (symlink escape or denied)", 400);
 	}
 
-	const rootDir = getRootDir();
-
 	// Verify start path is a directory
 	if (startRelRaw) {
 		try {
@@ -214,14 +225,39 @@ export async function POST(req: Request): Promise<NextResponse> {
 		}
 	}
 
+	// FTS branch -- handled before the grep/glob path validation below.
+	if (kind === "fts") {
+		const sc = enforceScope(auth.agent, { op: "read", workspaceId: ws.id });
+		if (!sc.ok) return errJson("FORBIDDEN", sc.message ?? "Forbidden", 403);
+
+		ensureIndexer(ws.id, rootDir).catch((e) =>
+			console.error("[search] ensureIndexer failed", e),
+		);
+
+		// Over-fetch so the post-filter (path scope + start-path restriction) can
+		// still return up to `limit` results when some top-ranked hits are denied.
+		const startPrefix = startRelRaw ? `${startRelRaw.replace(/\/+$/, "")}/` : "";
+		const fts = ftsSearch(ws.id, query, Math.min(limit * 4, HARD_MAX_MATCHES));
+		const filtered = fts.matches.filter((m) => {
+			if (startPrefix && !m.path.startsWith(startPrefix)) return false;
+			return enforceScope(auth.agent, { filePath: m.path, op: "read", workspaceId: ws.id }).ok;
+		});
+		const matches = filtered
+			.slice(0, limit)
+			.map((m) => ({ path: m.path, score: m.score, snippet: m.snippet }));
+		// truncated if the DB itself capped, or the scoped set still exceeds limit.
+		const truncated = fts.truncated || filtered.length > limit;
+		return NextResponse.json({ kind, query, matches, truncated });
+	}
+
 	const deadline = Date.now() + SEARCH_TIMEOUT_MS;
 	let result: { matches: SearchMatch[]; truncated: boolean };
 
 	try {
 		if (kind === "grep") {
-			result = await grepSearch(rootDir, startRelRaw, query, limit, auth.agent, deadline);
+			result = await grepSearch(rootDir, startRelRaw, query, limit, auth.agent, deadline, ws.id);
 		} else {
-			result = await globSearch(rootDir, startRelRaw, query, limit, auth.agent, deadline);
+			result = await globSearch(rootDir, startRelRaw, query, limit, auth.agent, deadline, ws.id);
 		}
 	} catch (e) {
 		return errJson("SEARCH_ERROR", (e as Error).message, 400);