@schlessera/brain-ui-server 0.34.0 → 0.35.0

package/src/middleware/principals.ts

@@ -0,0 +1,189 @@
+import type { Logger } from "@opentelemetry/api-logs";
+import type { Database } from "bun:sqlite";
+import { Hono } from "hono";
+import type { Context } from "hono";
+import { generateSignedCookie } from "hono/cookie";
+
+import type { AppEnv } from "../app-env.js";
+import {
+  createPrincipal,
+  listLivePrincipals,
+  PrincipalCreatorNotUsableError,
+  PrincipalLimitError,
+  revokePrincipal,
+} from "../db/principals.js";
+import { readJsonBody } from "./body-limit.js";
+import {
+  applyPrincipalRevocation,
+  SESSION_TTL_SECONDS,
+  type AuthMode,
+  type AuthRuntime,
+} from "./auth.js";
+import { requireJson } from "./origin.js";
+import type { WsHost } from "../ws/host.js";
+import { requireOwner } from "./require-owner.js";
+
+const COOKIE_NAME = "brain_ui_session";
+const SECONDS_PER_DAY = 24 * 60 * 60;
+const DEFAULT_AGENT_TTL_DAYS = 7;
+const MAX_AGENT_TTL_DAYS = SESSION_TTL_SECONDS / SECONDS_PER_DAY;
+const MAX_LABEL_LENGTH = 64;
+const CONTROL_CHARACTERS = /[\u0000-\u001f\u007f-\u009f]/gu;
+
+export interface PrincipalManagementContext {
+  db: Database;
+  revoker: Pick<WsHost, "revokePrincipals">;
+  log?: Logger;
+}
+
+function notEnabled(c: Context) {
+  return c.json({ error: "Principal management is not enabled" }, 400);
+}
+
+function sanitizeLabel(value: unknown): string {
+  return typeof value === "string"
+    ? value
+        .replace(CONTROL_CHARACTERS, "")
+        .trim()
+        .slice(0, MAX_LABEL_LENGTH)
+        .trim()
+    : "";
+}
+
+function cookieValue(serialized: string): string {
+  const valueStart = serialized.indexOf("=") + 1;
+  const valueEnd = serialized.indexOf(";", valueStart);
+  return decodeURIComponent(
+    serialized.slice(valueStart, valueEnd === -1 ? undefined : valueEnd)
+  );
+}
+
+/**
+ * Owner-only delegated-principal routes. Mount AFTER the auth guard: the
+ * family middleware below authorizes the resolved principal, it does not
+ * authenticate the request itself.
+ */
+export function principalManagementRoutes(
+  mode: AuthMode,
+  auth: AuthRuntime,
+  ctx: PrincipalManagementContext
+): Hono<AppEnv> {
+  const app = new Hono<AppEnv>();
+
+  app.use("/auth/principals/*", async (c, next) => {
+    if (mode !== "password") return notEnabled(c);
+    await next();
+  });
+  app.use("/auth/principals/*", requireOwner());
+
+  app.get("/auth/principals", (c) => {
+    const caller = c.get("principal")!;
+    const principals = listLivePrincipals(ctx.db, Date.now()).map((principal) => ({
+      id: principal.id,
+      kind: principal.kind,
+      auth_method: principal.authMethod,
+      label: principal.label,
+      created_at: principal.createdAt,
+      expires_at: principal.expiresAt,
+      last_seen_at: principal.lastSeenAt,
+      is_own: principal.id === caller.id,
+    }));
+    return c.json({ principals });
+  });
+
+  app.post("/auth/principals", requireJson(), async (c) => {
+    let body: { label?: unknown; ttlDays?: unknown };
+    try {
+      const result = await readJsonBody<{ label?: unknown; ttlDays?: unknown }>(c);
+      if (result instanceof Response) return result;
+      if (!result || typeof result !== "object" || Array.isArray(result)) {
+        return c.json({ error: "Invalid request body" }, 400);
+      }
+      body = result;
+    } catch {
+      return c.json({ error: "Invalid request body" }, 400);
+    }
+
+    const label = sanitizeLabel(body.label);
+    if (!label) return c.json({ error: "label must be a non-empty string" }, 400);
+
+    const ttlDays =
+      body.ttlDays === undefined ? DEFAULT_AGENT_TTL_DAYS : body.ttlDays;
+    if (
+      typeof ttlDays !== "number" ||
+      !Number.isInteger(ttlDays) ||
+      ttlDays < 1 ||
+      ttlDays > MAX_AGENT_TTL_DAYS
+    ) {
+      return c.json(
+        { error: `ttlDays must be an integer between 1 and ${MAX_AGENT_TTL_DAYS}` },
+        400
+      );
+    }
+
+    const caller = c.get("principal")!;
+    let principal;
+    try {
+      principal = createPrincipal(ctx.db, {
+        authMethod: "delegated",
+        label,
+        createdBy: caller.id,
+        ttlSeconds: ttlDays * SECONDS_PER_DAY,
+      });
+    } catch (error) {
+      if (error instanceof PrincipalCreatorNotUsableError) {
+        return c.json({ error: "Owner access required" }, 403);
+      }
+      if (!(error instanceof PrincipalLimitError)) throw error;
+      return c.json(
+        { error: "Principal capacity reached. Revoke another principal and try again." },
+        503
+      );
+    }
+
+    const serialized = await generateSignedCookie(
+      COOKIE_NAME,
+      principal.id,
+      auth.cookieSecret ?? ""
+    );
+    const cookie = cookieValue(serialized);
+
+    ctx.log?.emit({
+      severityText: "INFO",
+      body: "delegated principal minted",
+      attributes: {
+        "auth.principal.id": caller.id,
+        "auth.target_principal.id": principal.id,
+      },
+    });
+    c.header("Cache-Control", "no-store");
+    return c.json({
+      id: principal.id,
+      label: principal.label,
+      expiresAt: principal.expiresAt,
+      cookie,
+    });
+  });
+
+  app.delete("/auth/principals/:id", (c) => {
+    const caller = c.get("principal")!;
+    const targetId = c.req.param("id");
+    const revokedIds = revokePrincipal(ctx.db, targetId, Date.now());
+    if (revokedIds.length === 0) {
+      return c.json({ error: "Unknown principal" }, 404);
+    }
+
+    applyPrincipalRevocation(ctx.revoker, revokedIds);
+    ctx.log?.emit({
+      severityText: "INFO",
+      body: "principal revoked",
+      attributes: {
+        "auth.principal.id": caller.id,
+        "auth.target_principal.id": targetId,
+      },
+    });
+    return c.json({ ok: true });
+  });
+
+  return app;
+}

package/src/middleware/require-owner.ts

@@ -0,0 +1,13 @@
+import type { MiddlewareHandler } from "hono";
+
+import type { AppEnv } from "../app-env.js";
+
+/** Require the authenticated request principal to be the owner. */
+export function requireOwner(): MiddlewareHandler<AppEnv> {
+  return async (c, next) => {
+    if (c.get("principal")?.kind !== "owner") {
+      return c.json({ error: "Owner access required" }, 403);
+    }
+    await next();
+  };
+}

package/src/observability/loggers.ts

@@ -54,7 +54,7 @@ export interface ConsoleLoggerProviderOptions {
 function formatLine(record: CapturedLog): string {
   const attrs = Object.entries(record.attributes)
     .filter(([, v]) => v !== undefined)
-    .map(([k, v]) => `${k}=${String(v)}`);
+    .map(([k, v]) => `${k}=${typeof v === "string" ? JSON.stringify(v) : String(v)}`);
   return `[${record.scope}] ${record.body}${attrs.length ? ` ${attrs.join(" ")}` : ""}`;
 }
 

package/src/routes/activity.ts

@@ -137,6 +137,9 @@ export function createActivityRoutes(deps: {
             name: s.name,
             sessionId: s.sessionId,
             jobName: s.jobName,
+            principalId: s.principalId,
+            principalLabel: null,
+            principalKind: null,
             startedAt: s.startedAt,
             endedAt: null,
             outcome: null,

package/src/routes/brain.ts

@@ -7,11 +7,14 @@ import {
   writeCache,
   type KeytermSettings,
 } from "../voice/keyterm-builder.js";
-import { existsSync } from "fs";
+import { existsSync, realpathSync } from "fs";
 import { join } from "path";
 import { readJsonBody } from "../middleware/body-limit.js";
 import { requireJson } from "../middleware/origin.js";
 
+// Shared across route instances, keyed by the canonical brain root.
+const syncingRoots = new Set<string>();
+
 export interface BrainRoutesDeps {
   brain: BrainClient;
   brainPath: string;
@@ -39,6 +42,7 @@ function findWhatsupScript(brainPath: string): string | null {
 
 export function createBrainRoutes(deps: BrainRoutesDeps): Hono {
   const { brain, brainPath, keyterms } = deps;
+  let indexing: Promise<void> | null = null;
 
   return new Hono()
   .get("/brain/search", async (c) => {
@@ -52,12 +56,13 @@ export function createBrainRoutes(deps: BrainRoutesDeps): Hono {
         tag: c.req.query("tag"),
         limit: c.req.query("limit") ? Number(c.req.query("limit")) : undefined,
         mode: c.req.query("mode"),
+        signal: c.req.raw.signal,
       });
       return c.json({ results, warnings });
     } catch (err) {
       return c.json(
         { error: err instanceof Error ? err.message : "Search failed" },
-        500
+        err instanceof Error && err.name === "TimeoutError" ? 504 : 500
       );
     }
   })
@@ -205,91 +210,123 @@ export function createBrainRoutes(deps: BrainRoutesDeps): Hono {
     // Stream sync output via SSE so the client sees live progress.
     // brain sync spawns a nested Claude Code process that can take minutes.
 
+    const syncRoot = realpathSync(brainPath);
+    if (syncingRoots.has(syncRoot)) {
+      return c.json({ error: "A sync is already running. Wait for it to finish before retrying." }, 409);
+    }
+    syncingRoots.add(syncRoot);
     return streamSSE(c, async (stream) => {
+      let keepalive: ReturnType<typeof setInterval> | undefined;
+      let disconnected = false;
+      stream.onAbort(() => { disconnected = true; });
       const send = (data: {
         type: string;
         text?: string;
         success?: boolean;
-      }) => stream.writeSSE({ data: JSON.stringify(data) });
+      }) => disconnected ? Promise.resolve() : stream.writeSSE({ data: JSON.stringify(data) })
+        .catch(() => { disconnected = true; });
 
-      await send({ type: "start", text: "Starting brain sync..." });
+      try {
+        await send({ type: "start", text: "Starting brain sync..." });
 
-      // The nested Claude process can be silent for minutes; without traffic
-      // the socket gets cut by idle timeouts (Bun's own, or a proxy's). SSE
-      // comment lines are ignored by EventSource and data-line parsers.
-      const keepalive = setInterval(() => {
-        stream.write(": keepalive\n\n").catch(() => {});
-      }, 15_000);
+        // The nested Claude process can be silent for minutes; without traffic
+        // the socket gets cut by idle timeouts (Bun's own, or a proxy's). SSE
+        // comment lines are ignored by EventSource and data-line parsers.
+        keepalive = setInterval(() => {
+          stream.write(": keepalive\n\n").catch(() => {});
+        }, 15_000);
 
-      // Merge stderr into stdout — brain sync spawns a nested Claude Code
-      // process whose output goes to stderr. The command comes from
-      // brain.cliCommand() (packaged bin or legacy vendored script), passed to
-      // bash as positional args rather than interpolated into the script, so a
-      // BRAIN_PATH containing spaces or shell metacharacters stays inert.
-      const [cliBin, ...cliArgs] = brain.cliCommand();
-      const proc = Bun.spawn(
-        ["bash", "-c", '"$0" "$@" 2>&1', cliBin!, ...cliArgs, "sync"],
-        {
-          cwd: brainPath,
-          stdout: "pipe",
-          stderr: "pipe",
-          env: subprocessEnv("brainCli", { NO_COLOR: "1" }),
-        }
-      );
+        // Merge stderr into stdout — brain sync spawns a nested Claude Code
+        // process whose output goes to stderr. The command comes from
+        // brain.cliCommand() (packaged bin or legacy vendored script), passed to
+        // bash as positional args rather than interpolated into the script, so a
+        // BRAIN_PATH containing spaces or shell metacharacters stays inert.
+        const [cliBin, ...cliArgs] = brain.cliCommand();
+        const proc = Bun.spawn(
+          ["bash", "-c", '"$0" "$@" 2>&1', cliBin!, ...cliArgs, "sync"],
+          {
+            cwd: brainPath,
+            stdout: "pipe",
+            stderr: "pipe",
+            env: subprocessEnv("brainCli", { NO_COLOR: "1" }),
+          }
+        );
 
-      const reader = proc.stdout.getReader();
-      const decoder = new TextDecoder();
-      let buffer = "";
-      try {
-        while (true) {
-          const { done, value } = await reader.read();
-          if (done) break;
-          buffer += decoder.decode(value, { stream: true });
-          const lines = buffer.split("\n");
-          buffer = lines.pop() || "";
-          for (const line of lines) {
-            if (line.trim()) {
-              await send({ type: "progress", text: line });
+        // Keep draining even when the SSE reader disconnects. The repository
+        // stays reserved until the actual sync process has exited.
+        const stderrDone = new Response(proc.stderr).text().catch(() => "");
+        const reader = proc.stdout.getReader();
+        const decoder = new TextDecoder();
+        let buffer = "";
+        try {
+          while (true) {
+            const { done, value } = await reader.read();
+            if (done) break;
+            buffer += decoder.decode(value, { stream: true });
+            const lines = buffer.split("\n");
+            buffer = lines.pop() || "";
+            for (const line of lines) {
+              if (line.trim()) {
+                await send({ type: "progress", text: line });
+              }
             }
           }
+          if (buffer.trim()) {
+            await send({ type: "progress", text: buffer });
+          }
+        } catch {} finally {
+          clearInterval(keepalive);
         }
-        if (buffer.trim()) {
-          await send({ type: "progress", text: buffer });
-        }
-      } catch {} finally {
-        clearInterval(keepalive);
-      }
 
-      const exitCode = await proc.exited;
+        const exitCode = await proc.exited;
+        await stderrDone;
 
-      // Rebuild voice keyterms cache after a successful sync.
-      if (exitCode === 0) {
-        try {
-          const cache = buildKeyterms(keyterms);
-          writeCache(keyterms, cache);
-          await send({
-            type: "progress",
-            text: `[voice] Rebuilt keyterms cache (${cache.count} terms)`,
-          });
-        } catch (err) {
-          await send({
-            type: "progress",
-            text: `[voice] Keyterm rebuild failed: ${
-              err instanceof Error ? err.message : String(err)
-            }`,
-          });
+        // Rebuild voice keyterms cache after a successful sync.
+        if (exitCode === 0) {
+          try {
+            const cache = buildKeyterms(keyterms);
+            writeCache(keyterms, cache);
+            await send({
+              type: "progress",
+              text: `[voice] Rebuilt keyterms cache (${cache.count} terms)`,
+            });
+          } catch (err) {
+            await send({
+              type: "progress",
+              text: `[voice] Keyterm rebuild failed: ${
+                err instanceof Error ? err.message : String(err)
+              }`,
+            });
+          }
         }
-      }
 
-      await send({
-        type: "done",
-        success: exitCode === 0,
-        text:
-          exitCode === 0 ? "Sync completed" : `Sync failed (exit ${exitCode})`,
-      });
+        await send({
+          type: "done",
+          success: exitCode === 0,
+          text:
+            exitCode === 0 ? "Sync completed" : `Sync failed (exit ${exitCode})`,
+        });
+      } catch (error) {
+        await send({ type: "done", success: false, text: error instanceof Error ? error.message : "Sync failed" });
+      } finally {
+        clearInterval(keepalive);
+        syncingRoots.delete(syncRoot);
+      }
     });
   })
 
+  // Recovery after a successful capture whose indexing failed. Coalesce
+  // concurrent retries and never submit the captured content a second time.
+  .post("/brain/index", requireJson(), async (c) => {
+    try {
+      if (!indexing) indexing = brain.index().finally(() => { indexing = null; });
+      await indexing;
+      return c.json({ success: true });
+    } catch (err) {
+      return c.json({ error: err instanceof Error ? err.message : "Indexing failed" }, 500);
+    }
+  })
+
   .post("/brain/add", requireJson(), async (c) => {
     const result = await readJsonBody<{
       content: string;
@@ -303,12 +340,12 @@ export function createBrainRoutes(deps: BrainRoutesDeps): Hono {
       return c.json({ error: "Field 'content' is required" }, 400);
     }
     try {
-      await brain.add(body.content, {
+      const outcome = await brain.add(body.content, {
         type: body.type,
         title: body.title,
         tags: body.tags,
       });
-      return c.json({ success: true });
+      return c.json({ success: true, ...outcome });
     } catch (err) {
       return c.json(
         { error: err instanceof Error ? err.message : "Add failed" },

package/src/routes/files.ts

@@ -29,6 +29,7 @@ function errorResponse(err: unknown, log?: Logger): { body: { error: string; siz
 
 export function createFilesRoutes(deps: { brainRoot: string; log?: Logger }): Hono {
   const { brainRoot, log } = deps;
+  let wikilinkBuild: Promise<void> | null = null;
   let wikilinkCache: { generatedAt: number; map: Record<string, string> } | null = null;
   return new Hono()
   .get("/files/tree", async (c) => {
@@ -87,13 +88,17 @@ export function createFilesRoutes(deps: { brainRoot: string; log?: Logger }): Ho
     const now = Date.now();
     try {
       if (refresh || !wikilinkCache || now - wikilinkCache.generatedAt > WIKILINK_TTL_MS) {
-        const map = await buildWikilinkMap(brainRoot);
-        wikilinkCache = { generatedAt: now, map };
+        if (!wikilinkBuild) {
+          wikilinkBuild = buildWikilinkMap(brainRoot).then((map) => {
+            wikilinkCache = { generatedAt: Date.now(), map };
+          }).finally(() => { wikilinkBuild = null; });
+        }
+        await wikilinkBuild;
       }
       return c.json({
-        generatedAt: wikilinkCache.generatedAt,
-        count: Object.keys(wikilinkCache.map).length,
-        slugs: wikilinkCache.map,
+        generatedAt: wikilinkCache!.generatedAt,
+        count: Object.keys(wikilinkCache!.map).length,
+        slugs: wikilinkCache!.map,
       });
     } catch (err) {
       const { body, status } = errorResponse(err, log);

package/src/routes/push.ts

@@ -2,6 +2,7 @@ import { Hono } from "hono";
 import { z } from "zod";
 
 import type { PushSender } from "../activity/push-sender.js";
+import type { AppEnv } from "../app-env.js";
 import { readJsonBody } from "../middleware/body-limit.js";
 import { requireJson } from "../middleware/origin.js";
 
@@ -26,10 +27,10 @@ const unsubscribeSchema = z.object({
   endpoint: z.url().max(2048),
 });
 
-export function createPushRoutes(deps: { sender: PushSender }): Hono {
+export function createPushRoutes(deps: { sender: PushSender }) {
   const { sender } = deps;
 
-  return new Hono()
+  return new Hono<AppEnv>()
     .get("/push/public-key", (c) => {
       try {
         return c.json({ publicKey: sender.publicKey() });
@@ -45,7 +46,7 @@ export function createPushRoutes(deps: { sender: PushSender }): Hono {
       try {
         // Endpoints are capability URLs — list only metadata.
         return c.json({
-          subscriptions: sender.subscriptions().map((s) => ({
+          subscriptions: sender.subscriptions(c.get("principal")!.id).map((s) => ({
             label: s.label,
             createdAt: s.createdAt,
             lastUsedAt: s.lastUsedAt,
@@ -66,7 +67,10 @@ export function createPushRoutes(deps: { sender: PushSender }): Hono {
         const result = await readJsonBody(c);
         if (result instanceof Response) return result;
         const body = subscribeSchema.parse(result);
-        sender.subscribe(body.subscription, body.label);
+        const principal = c.get("principal")!;
+        if (!sender.subscribe(body.subscription, principal.id, body.label)) {
+          return c.json({ error: "Authentication required" }, 401);
+        }
         return c.json({ ok: true });
       } catch (err) {
         return c.json(
@@ -81,7 +85,9 @@ export function createPushRoutes(deps: { sender: PushSender }): Hono {
         const result = await readJsonBody(c);
         if (result instanceof Response) return result;
         const body = unsubscribeSchema.parse(result);
-        return c.json({ removed: sender.unsubscribe(body.endpoint) });
+        return c.json({
+          removed: sender.unsubscribe(body.endpoint, c.get("principal")!.id),
+        });
       } catch (err) {
         return c.json(
           { error: err instanceof Error ? err.message : "Bad request" },

package/src/routes/sessions.ts

@@ -1,5 +1,6 @@
 import { Hono } from "hono";
 import type { Database } from "bun:sqlite";
+import type { AgentBackend } from "@schlessera/brain-ui-sdk/server";
 import type { BackendRegistry } from "../agent/backend.js";
 
 export function createSessionRoutes(deps: {
@@ -7,6 +8,30 @@ export function createSessionRoutes(deps: {
   db: Database;
 }): Hono {
   const { registry, db } = deps;
+  const pending = new Map<AgentBackend, ReturnType<AgentBackend["listSessions"]>>();
+
+  async function listSessions(backend: AgentBackend) {
+    let work = pending.get(backend);
+    if (!work) {
+      work = Promise.resolve().then(() => backend.listSessions());
+      pending.set(backend, work);
+      const clear = () => { if (pending.get(backend) === work) pending.delete(backend); };
+      void work.then(clear, clear);
+    }
+    // Backends have no cancellation API. Reuse unfinished work so retries
+    // cannot pile up scans behind a stalled backend.
+    let timer: ReturnType<typeof setTimeout> | undefined;
+    try {
+      return await Promise.race([
+        work,
+        new Promise<never>((_, reject) => {
+          timer = setTimeout(() => reject(new Error("Session listing timed out")), 3_000);
+        }),
+      ]);
+    } finally {
+      clearTimeout(timer);
+    }
+  }
 
   function getStoredBackendId(sessionId: string): string | null {
     const row = db
@@ -30,28 +55,28 @@ export function createSessionRoutes(deps: {
             .all() as Array<{ id: string; cost: number | null; turns: number | null }>
         ).map((r) => [r.id, r])
       );
-      const sessions = (
-        await Promise.all(
-          backends.map(async (backend) =>
-            (await backend.listSessions()).map((session) => {
-              const stored = accounting.get(session.id);
-              return {
-                ...session,
-                ...(stored?.cost && session.totalCostUsd === 0
-                  ? { totalCostUsd: stored.cost }
-                  : {}),
-                ...(stored?.turns && session.numTurns === 0
-                  ? { numTurns: stored.turns }
-                  : {}),
-                backendId: backend.id,
-              };
-            })
-          )
+      const results = await Promise.allSettled(
+        backends.map(async (backend) =>
+          (await listSessions(backend)).map((session) => {
+            const stored = accounting.get(session.id);
+            return {
+              ...session,
+              ...(stored?.cost && session.totalCostUsd === 0
+                ? { totalCostUsd: stored.cost }
+                : {}),
+              ...(stored?.turns && session.numTurns === 0
+                ? { numTurns: stored.turns }
+                : {}),
+              backendId: backend.id,
+            };
+          })
         )
-      )
-        .flat()
+      );
+      const sessions = results.flatMap((result) => result.status === "fulfilled" ? result.value : [])
         .sort((a, b) => b.lastActiveAt - a.lastActiveAt);
-      return c.json({ sessions });
+      const unavailableBackends = results.flatMap((result, index) =>
+        result.status === "rejected" ? [backends[index]!.id] : []);
+      return c.json({ sessions, ...(unavailableBackends.length ? { unavailableBackends } : {}) });
     } catch (err) {
       return c.json(
         { error: err instanceof Error ? err.message : "Failed to list sessions" },

package/src/share/staging.ts

@@ -1,5 +1,5 @@
 import type { Logger } from "@opentelemetry/api-logs";
-import { mkdir, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+import { mkdir, readdir, rename, rm, writeFile, realpath, lstat } from "node:fs/promises";
 import { join } from "node:path";
 import {
   SHARE_MAX_FILES,
@@ -406,9 +406,15 @@ export async function pruneShareStaging(
   now = Date.now(),
   log?: Logger
 ): Promise<number> {
-  const root = shareStagingRoot(brainPath);
+  let root: string;
   let entries;
   try {
+    root = await safeResolve(SHARE_STAGING_DIR, brainPath);
+    // Even an internal symlink could point at unrelated content. Only prune
+    // the actual staging directory; the brain root itself may be a symlink.
+    if (await realpath(root) !== join(await realpath(brainPath), SHARE_STAGING_DIR)) {
+      throw new Error("Share staging directory must not traverse a symlink");
+    }
     entries = await readdir(root, { withFileTypes: true });
   } catch (err) {
     // Nothing staged yet is the ordinary case. Anything else — a permission
@@ -430,8 +436,9 @@ export async function pruneShareStaging(
     const path = join(root, entry.name);
     const ttl = entry.name.startsWith(".") ? PARTIAL_TTL_MS : SHARE_STAGING_TTL_MS;
     try {
-      const info = await stat(path);
-      if (now - info.mtimeMs <= ttl) continue;
+      await safeResolve(`${SHARE_STAGING_DIR}/${entry.name}`, brainPath);
+      const info = await lstat(path);
+      if (!info.isDirectory() || now - info.mtimeMs <= ttl) continue;
       await rm(path, { recursive: true, force: true });
       removed += 1;
     } catch {