wiki-viewer 1.7.2 → 1.8.0

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);

package/.next/standalone/src/app/api/agent/internal/span/route.ts

@@ -8,7 +8,8 @@ import { revertProofSpan } from "@/lib/proof/proof-span";
 import { readSidecar, writeSidecar, emptySidecar } from "@/lib/proof/sidecar";
 import { withFileMutex } from "@/lib/proof/mutex";
 import { emitEvents } from "@/lib/proof/event-bus";
-import { getRootDir, safeRootPath } from "@/lib/root-dir";
+import { resolveWorkspaceForAgent } from "@/lib/workspace-context";
+import { safeWorkspacePath } from "@/lib/workspaces";
 import { checkAuth, enforceScope } from "@/lib/proof/auth";
 
 export const runtime = "nodejs";
@@ -63,22 +64,25 @@ export async function POST(req: Request): Promise<NextResponse> {
 		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(authResult.agent, { filePath: rel, op: "mutate" });
+	const scopeCheck = enforceScope(authResult.agent, { filePath: rel, op: "mutate", workspaceId: ws.id });
 	if (!scopeCheck.ok) {
 		return NextResponse.json({ error: scopeCheck.code, message: scopeCheck.message }, { status: 403 });
 	}
 
-	const rootDir = getRootDir();
 	const actorId = authResult.agent.id;
 
 	let notFound = false;
 	try {
-		await withFileMutex(rel, async () => {
+		await withFileMutex(`${rootDir}\u0000${rel}`, async () => {
 			let content: string;
 			try {
 				content = await readFile(absPath, "utf-8");

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

@@ -31,7 +31,15 @@ function validateScope(s: Record<string, unknown>): AgentScope | { error: string
 			return { error: `scope.ops values must be "read", "mutate", or "delete"` };
 		}
 	}
-	return { paths: s.paths as string[], ops: s.ops as Array<"read" | "mutate" | "delete"> };
+	// Optional workspaceId: if present must be a non-empty string ≤ 64 chars.
+	let workspaceId: string | undefined;
+	if (s.workspaceId !== undefined) {
+		if (typeof s.workspaceId !== "string" || s.workspaceId.length < 1 || s.workspaceId.length > 64) {
+			return { error: "scope.workspaceId must be a string of 1\u201364 characters" };
+		}
+		workspaceId = s.workspaceId;
+	}
+	return { paths: s.paths as string[], ops: s.ops as Array<"read" | "mutate" | "delete">, ...(workspaceId !== undefined ? { workspaceId } : {}) };
 }
 
 /** Exported for reuse in approve route. */

package/.next/standalone/src/app/api/agent/settings/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 { readRegistry } from "@/lib/proof/registry";
 import { listPendingRegistrations } from "@/lib/proof/pending";
 
@@ -12,7 +12,11 @@ export async function GET(req: Request): Promise<NextResponse> {
 		return NextResponse.json({ error: "UNAUTHORIZED" }, { status: 401 });
 	}
 
-	const scopeCheck = enforceScope(auth.agent, { op: "read" });
+	const wsx = await resolveWorkspaceForAgent(req);
+	if (!wsx.ok) return NextResponse.json({ error: wsx.code }, { status: wsx.status });
+	const { ws, rootDir } = wsx;
+
+	const scopeCheck = enforceScope(auth.agent, { op: "read", workspaceId: ws.id });
 	if (!scopeCheck.ok) {
 		return NextResponse.json({ error: scopeCheck.code, message: scopeCheck.message }, { status: 403 });
 	}
@@ -23,7 +27,7 @@ export async function GET(req: Request): Promise<NextResponse> {
 
 	return NextResponse.json({
 		rateLimit: Number(process.env.AGENT_RATE_LIMIT) || 60,
-		root: getRootDir(),
+		root: rootDir,
 		registeredAgents,
 		pendingRegistrations,
 	});

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

@@ -1,7 +1,8 @@
 import { NextResponse } from "next/server";
 import { checkAuth, enforceScope } from "@/lib/proof/auth";
 import { readSidecar, emptySidecar } from "@/lib/proof/sidecar";
-import { getRootDir, safeRootPath } from "@/lib/root-dir";
+import { resolveWorkspaceForAgent } from "@/lib/workspace-context";
+import { safeWorkspacePath } from "@/lib/workspaces";
 
 export const runtime = "nodejs";
 
@@ -32,17 +33,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 sidecar = (await readSidecar(rootDir, rel)) ?? emptySidecar(rel);
 
 	return NextResponse.json(sidecar);

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

@@ -1,7 +1,8 @@
 import { readFile, stat } from "node:fs/promises";
 import path from "node:path";
 import { NextResponse } from "next/server";
-import { getRootDir } from "@/lib/root-dir";
+import { resolveWorkspaceForAgent } from "@/lib/workspace-context";
+import { safeWorkspacePath } from "@/lib/workspaces";
 
 const MIME_MAP: Record<string, string> = {
 	jpg: "image/jpeg",
@@ -38,15 +39,19 @@ const MIME_MAP: Record<string, string> = {
 };
 
 export async function GET(
-	_request: Request,
+	request: Request,
 	{ params }: { params: Promise<{ path: string[] }> },
 ) {
+	const wsx = await resolveWorkspaceForAgent(request);
+	if (!wsx.ok) return NextResponse.json({ error: wsx.code }, { status: wsx.status });
+	const { rootDir } = wsx;
+
 	const segments = (await params).path;
 	const rel = segments.join("/");
 
 	// Path traversal guard
-	const resolved = path.resolve(getRootDir(), rel);
-	if (resolved !== getRootDir() && !resolved.startsWith(getRootDir() + path.sep)) {
+	const resolved = safeWorkspacePath(rootDir, rel);
+	if (!resolved) {
 		return NextResponse.json({ error: "Invalid path" }, { status: 400 });
 	}