@neuralis/brain-core 0.3.1 → 0.3.2

package/dist/src/routes/sources.js

@@ -6,7 +6,7 @@
  *   GET    /sources/:slug                    — get single source config
  *   GET    /sources/kinds                    — list registered source kinds (+ trust, package attribution)
  *   GET    /sources/kinds/:kind/schema       — JSON Schema for admin source form
- *   GET    /sources/discoverable             — well-known unattached source roots (W3E; drive.mount)
+ *   GET    /sources/discoverable             — well-known unattached source roots (W3E; sources.mount)
  *   POST   /sources                          — create source
  *   POST   /sources/preflight                — validate/authorize create without writing
  *   PATCH  /sources                          — update source
@@ -18,9 +18,9 @@
  *   POST   /sources/reset                    — reset sync state (cancels active job)
  *   GET    /sources/sync-status              — job status (?source= single, else all visible)
  *   POST   /sources/enabled                  — light enable/disable toggle (W3K)
- *   GET    /sources/browse                   — browse filesystem directories (drive.mount;
+ *   GET    /sources/browse                   — browse filesystem directories (sources.mount;
  *                                              protected zones + the fs root need
- *                                              drive.mount.privileged)
+ *                                              sources.privileged)
  *   GET    /sources/health                   — get sources health
  *
  * Sync-shaped POSTs return 202 + a SyncQueueJobSnapshot: the run executes on
@@ -45,17 +45,15 @@ import { listScopeDocumentUris, estimateScopedReembed } from '../usecases/vector
 import { embeddingEnabled, resolveActiveEmbeddingShape } from '../config/env.js';
 import { parsePurgeSelector, purgeSourceSelection } from '../usecases/purgeExcludedPoints.js';
 export const pattern = 'sources/*';
-export const feature = 'drive.read';
+export const feature = 'files.read';
 // The module gate is the read tier (listing a source is member-visible); every
 // mutating / enumerating arm escalates in-handler through `hasRouteFeature`.
-// `drive.mount.host` never appears as a literal at a gate — the host-plane arm
-// folds it through `hostPlaneRequiredFeatures()` and enforces each returned id
-// in a loop — so the drift guard carries it as a named exemption row.
+// A host-plane (paired-device) source is attached by its owner under
+// `device.own`, which agent-core's device gate answers — not a gate here.
 export const escalations = [
-    'drive.mount',
-    'drive.mount.privileged',
-    'drive.mount.host',
-    'drive.sync',
+    'sources.mount',
+    'sources.privileged',
+    'sources.sync',
     'platform.vector.maintain',
 ];
 export const GET = async (req, raw) => {
@@ -124,7 +122,7 @@ export const GET = async (req, raw) => {
         const origin = matched?.originPackage ?? null;
         const git = await resolveSourceGit(config, infra, ctx);
         const readable = await rootReadable(infra, ctx, config.source, configCache);
-        const view = await sourceConfigView(req.session, config, infra?.projectRoot ?? '', protectedRoots, readable, !config.sync && matched && isOwnDataZoneDeclaration(matched.originPackage, matched.decl, state.ctx.selfId) ? dataSyncExclude : undefined);
+        const view = await sourceConfigView(req.session, config, infra?.projectRoot ?? '', protectedRoots, readable, deviceAttachVerdict(state, ctx, config.connection), !config.sync && matched && isOwnDataZoneDeclaration(matched.originPackage, matched.decl, state.ctx.selfId) ? dataSyncExclude : undefined);
         return {
             ...toPublicSourceConfig(config, view),
             // DERIVED, never persisted — the same chain the `<runtime_stack>`
@@ -141,7 +139,7 @@ export const GET = async (req, raw) => {
             kind_trust: metadata?.packageTrust ?? null,
             origin_package: origin,
             orphan: !metadata, embedding_enabled: embeddingEnabled(),
-            canMaintain: hasRouteFeature(req.session, 'drive.mount') && hasRouteFeature(req.session, 'drive.sync')
+            canMaintain: hasRouteFeature(req.session, 'sources.mount') && hasRouteFeature(req.session, 'sources.sync')
                 && canAccessScope(config.scope, access, 'write') && readable,
             orphan_hint: metadata ? null : `Package contributing kind "${config.connection.kind}" is missing — remove the source or reinstall the package.`,
             ...(git ? { git } : {}),
@@ -209,8 +207,8 @@ export const POST = async (req, raw) => {
     if (sub === 'purge') {
         const ctx = extractCtx(req);
         await ensureAccess(ctx, state);
-        if (!hasRouteFeature(req.session, 'drive.mount') || !hasRouteFeature(req.session, 'drive.sync')) {
-            return { status: 403, body: { error: 'Index cleanup requires drive.mount and drive.sync.' } };
+        if (!hasRouteFeature(req.session, 'sources.mount') || !hasRouteFeature(req.session, 'sources.sync')) {
+            return { status: 403, body: { error: 'Index cleanup requires sources.mount and sources.sync.' } };
         }
         const body = req.body;
         const source = typeof body?.source === 'string' ? body.source : '';
@@ -392,8 +390,12 @@ async function handleSourcesCreate(req, state, preflight = false) {
         return { status: 400, body: { error: 'recognizesPackages must be a boolean if provided' } };
     }
     await ensureAccess(ctx, state);
-    if (!hasRouteFeature(req.session, 'drive.mount')) {
-        return { status: 403, body: { error: 'Creating sources requires drive.mount.' } };
+    // A source on the caller's OWN paired device: its owner with `device.own`
+    // satisfies the whole attach stack (`sources.mount` included). On the host
+    // plane that is the ONLY way in; every other source meets the stack.
+    const ownDevice = deviceAttachVerdict(state, ctx, connection);
+    if (!ownDevice.allowed && !hasRouteFeature(req.session, 'sources.mount')) {
+        return { status: 403, body: { error: 'Creating sources requires sources.mount.' } };
     }
     if (recognizesPackages !== undefined && !isOwnerOrAdminEffective(req.session)) {
         return { status: 403, body: { error: 'Setting recognizesPackages requires an owner/admin-effective role.' } };
@@ -401,30 +403,31 @@ async function handleSourcesCreate(req, state, preflight = false) {
     if (recognizesPackages === true && connection.kind !== 'local') {
         return { status: 400, body: { error: 'recognizesPackages may only be true for local-kind sources.' } };
     }
-    // fenced-courtyard (HEALTH1 B3) — privileged-root ADD gate. `drive.mount`
+    // fenced-courtyard (HEALTH1 B3) — privileged-root ADD gate. `sources.mount`
     // attaches ordinary sources, but attaching a source rooted IN, OVER, or AT a
     // protected host zone (App Zone, the Neuralis tree, the whole host) requires
-    // the `drive.mount.privileged` feature (not granted below the `admin` tier).
+    // the `sources.privileged` feature (not granted below the `admin` tier).
     // The check is canonical
     // path CONTAINMENT against the SHARED, filter-free protected-root table — NOT
     // exact-root or a client suggestion id (both spoofable via subpath / ancestor /
     // `..` / trailing-slash / a Docker free-root attach with no suggestion). The
     // requested root is resolved with `resolveLocalRoot` — the SAME canonicaliser
     // the connector uses — so the gate sees exactly what will be mounted.
-    // native-nightjar BFIX (B2) — the HOST plane is privileged unconditionally,
-    // BEFORE the root-sensitive container gate below. No root-string inspection
-    // and no `protectedRoots.length` precondition: a host-plane attach is gated
-    // even when the runtime stack is unavailable (fail closed), and a
-    // sub-directory root is gated exactly like `/`.
+    // The HOST plane is decided BEFORE the root-sensitive container gate below:
+    // the device's owner with `device.own`, nobody else, with no root-string
+    // inspection and no `protectedRoots.length` precondition (fail closed even
+    // when the runtime stack is unavailable; a sub-directory is gated like `/`).
     // The container-plane arm is kind-AGNOSTIC (see `missingAttachFeature`).
-    const missingForAttach = await missingAttachFeature(req.session, connection, buildProtectedRoots(state.ctx.platform.runtimeStack()), async (root) => resolveLocalRoot({ configured: root, projectRoot: (await state.infraFactory.getInfra(projectId)).projectRoot ?? '', source }).resolvedRoot);
+    const missingForAttach = await missingAttachFeature(req.session, connection, buildProtectedRoots(state.ctx.platform.runtimeStack()), async (root) => resolveLocalRoot({ configured: root, projectRoot: (await state.infraFactory.getInfra(projectId)).projectRoot ?? '', source }).resolvedRoot, ownDevice);
     if (missingForAttach) {
         return {
             status: 403,
             body: {
-                error: missingForAttach.plane === 'host'
-                    ? `Attaching a host-plane source requires the ${missingForAttach.feature} feature.`
-                    : `Attaching a source rooted in a protected host zone requires the ${missingForAttach.feature} feature.`,
+                error: missingForAttach.plane === 'device'
+                    ? "Only the device's owner may attach a source on it."
+                    : missingForAttach.plane === 'host'
+                        ? `Attaching a host-plane source requires the ${missingForAttach.feature} feature.`
+                        : `Attaching a source rooted in a protected host zone requires the ${missingForAttach.feature} feature.`,
             },
         };
     }
@@ -519,47 +522,11 @@ function isOwnerOrAdminEffective(session) {
 // is containment in BOTH directions (architect MAJOR-1).
 // ---------------------------------------------------------------------------
 /** Feature required to SEE/ADD a high-blast-radius host zone (C8 — no grant below the admin tier). */
-const PRIVILEGED_MOUNT_FEATURE = 'drive.mount.privileged';
-/**
- * Feature required to attach ANY source on the HOST plane (native-nightjar
- * BFIX / B2 — no grant below the admin tier).
- *
- * `drive.mount` is a MANAGER default. The privileged-root machinery above was
- * once scoped to `kind === 'local'`, so a new connector kind that reaches
- * outside the container would have walked straight past it: an ordinary
- * manager could attach a `host-*` source rooted at `/` and get full host
- * read/write over the `fs_*` tools — with no `exec.host`, no owner,
- * no privileged gate. (The container arm is kind-agnostic now — any
- * non-host-plane kind with a string `root` is gated — but rule 1 below is
- * still what makes the HOST plane safe independent of root shape.)
- *
- * Two rules close it, and BOTH always apply on this plane:
- *   1. every host-plane root is privileged BY CONSTRUCTION (there is no
- *      unprivileged host root — see `hostPlaneRequiredFeatures`), and
- *   2. attaching one additionally requires this feature.
- *
- * The operator-owned broker ceiling is the third, out-of-band clamp: even a
- * granted caller only reaches paths the operator declared. The ceiling is the
- * floor; the feature is the audit trail.
- */
-const HOST_PLANE_MOUNT_FEATURE = 'drive.mount.host';
-// `isHostPlaneKind` lives in `@neuralis/package-system/contracts` — imported,
-// never re-declared. Two copies of a plane predicate is how the attach gate and
-// the terminal gate drift apart while both look correct in isolation.
-/**
- * Features required to attach a host-plane source, independent of its root.
- *
- * There is deliberately NO root-sensitivity here: on the host plane every root
- * is a protected zone, so a `/home/me/notes` attach is gated exactly like `/`.
- * Anything less would re-open B2 through a subdirectory.
- */
-function hostPlaneRequiredFeatures() {
-    return [HOST_PLANE_MOUNT_FEATURE, PRIVILEGED_MOUNT_FEATURE];
-}
+const PRIVILEGED_MOUNT_FEATURE = 'sources.privileged';
 /**
  * Build the filter-free protected-root table from the runtime stack. App Zone,
  * the Neuralis source tree, and the whole host (`/`) all require
- * `drive.mount.privileged`. `/` is ALWAYS included (both Docker and native) so
+ * `sources.privileged`. `/` is ALWAYS included (both Docker and native) so
  * the ADD gate catches a raw `config.root:'/'` attach that has no discoverable
  * suggestion under Docker.
  */
@@ -619,18 +586,21 @@ export function requiredFeaturesForRoot(root, protectedRoots, kind, mode = 'cont
  * the listing projection, so "you see the path you could attach" cannot drift
  * from what attaching requires.
  *
- * - Host plane: every `hostPlaneRequiredFeatures()` id, with no root inspection
- *   and no runtime-stack precondition (fail closed when the stack is absent).
+ * - Host plane: the DEVICE's owner holding `device.own` (`ownDevice`,
+ *   agent-core's device gate) and nobody else — a non-owner is refused as
+ *   `device`, an owner without `device.own` is told the feature it lacks; no
+ *   root inspection and no runtime-stack precondition (fail closed).
  * - Container plane, kind-AGNOSTIC: any kind whose config carries a string
  *   `root` — `local`, and every root-bearing kind a package registers later —
  *   resolves through `resolveRoot` (the connector's own canonicaliser) and hits
  *   the SAME containment table. Scoping this to one kind is how a newly
  *   registered root-bearing kind walks straight past the gate.
  */
-async function missingAttachFeature(session, connection, protectedRoots, resolveRoot) {
+async function missingAttachFeature(session, connection, protectedRoots, resolveRoot, ownDevice) {
     if (isHostPlaneKind(connection.kind)) {
-        const feature = hostPlaneRequiredFeatures().find((f) => !hasRouteFeature(session, f));
-        return feature ? { feature, plane: 'host' } : null;
+        if (ownDevice.allowed)
+            return null;
+        return { feature: 'device.own', plane: ownDevice.owner ? 'host' : 'device' };
     }
     if (protectedRoots.length === 0)
         return null;
@@ -641,6 +611,30 @@ async function missingAttachFeature(session, connection, protectedRoots, resolve
     const feature = required.find((f) => !hasRouteFeature(session, f));
     return feature ? { feature, plane: 'zone' } : null;
 }
+/**
+ * Ask agent-core's ONE device gate (`devices.mayAttach`) about the device a
+ * host-plane connection names. brain-core reads `config.device` as an opaque
+ * string and knows no device semantics; no agent-core, no device or a
+ * non-host kind ⇒ `{ allowed: false, owner: false }` (fail closed).
+ */
+function deviceAttachVerdict(state, ctx, connection) {
+    const denied = { allowed: false, owner: false };
+    if (!isHostPlaneKind(connection.kind))
+        return denied;
+    const device = connection.config?.device;
+    if (typeof device !== 'string' || !device)
+        return denied;
+    const session = {
+        userId: ctx.userId,
+        projectId: ctx.projectId,
+        ...(ctx.agentId ? { agentId: ctx.agentId } : {}),
+        callerId: '@neuralis/brain-core',
+        callerTrust: 'first-party',
+        grantedFeatures: ctx.grantedFeatures,
+    };
+    const agentCore = state.ctx.packages?.getPackageApi('@neuralis/agent-core', session);
+    return agentCore?.devices?.mayAttach({ userId: ctx.userId, grantedFeatures: ctx.grantedFeatures }, device) ?? denied;
+}
 /**
  * May this caller READ the source's root — the same per-uri read predicate the
  * listing paths use. Fails closed per row: no config store, or a throwing
@@ -653,16 +647,16 @@ async function rootReadable(infra, ctx, source, configCache) {
 }
 /**
  * The view `toPublicSourceConfig` answers with. The connection config goes to
- * a caller who could attach this source (`drive.mount` plus the gates
+ * a caller who could attach this source (`sources.mount` plus the gates
  * `missingAttachFeature` runs) OR can read its root — the files there already
  * show their host path as `os_uri`, so withholding it from a reader hides
- * nothing; the raw last-sync error goes to a `drive.sync` holder, the tier
+ * nothing; the raw last-sync error goes to a `sources.sync` holder, the tier
  * `sources/sync-status` answers to. A feature, never a role name.
  */
-async function sourceConfigView(session, config, projectRoot, protectedRoots, readable, defaultSyncExclude) {
-    const mayAttach = hasRouteFeature(session, 'drive.mount')
-        && await missingAttachFeature(session, config.connection, protectedRoots, (root) => resolveLocalRoot({ configured: root, projectRoot, source: config.source }).resolvedRoot) === null;
-    return { mayReadPaths: mayAttach || readable, maySeeSyncErrors: hasRouteFeature(session, 'drive.sync'),
+async function sourceConfigView(session, config, projectRoot, protectedRoots, readable, ownDevice, defaultSyncExclude) {
+    const mayAttach = (ownDevice.allowed || hasRouteFeature(session, 'sources.mount'))
+        && await missingAttachFeature(session, config.connection, protectedRoots, (root) => resolveLocalRoot({ configured: root, projectRoot, source: config.source }).resolvedRoot, ownDevice) === null;
+    return { mayReadPaths: mayAttach || readable, maySeeSyncErrors: hasRouteFeature(session, 'sources.sync'),
         ...(defaultSyncExclude ? { defaultSyncExclude } : {}) };
 }
 /** `sourceConfigView` for a single-row answer (single GET, mutation echoes). */
@@ -673,7 +667,7 @@ async function publicViewFor(session, ctx, config, state, infra) {
     }) : null;
     const defaults = matched && isOwnDataZoneDeclaration(matched.originPackage, matched.decl, state.ctx.selfId)
         ? seedExcludedMachineWrittenGlobs(state.ctx.platform.machineWrittenPaths()) : undefined;
-    return sourceConfigView(session, config, infra?.projectRoot ?? '', buildProtectedRoots(state.ctx.platform.runtimeStack()), readable, defaults);
+    return sourceConfigView(session, config, infra?.projectRoot ?? '', buildProtectedRoots(state.ctx.platform.runtimeStack()), readable, deviceAttachVerdict(state, ctx, config.connection), defaults);
 }
 function filterSourceForList(config, ctx, requestedScope, includeObserved) {
     if (requestedScope && config.scope.kind !== requestedScope)
@@ -723,12 +717,9 @@ async function handleSourcesUpdate(req, state) {
         return { status: 400, body: { error: 'recognizesPackages must be a boolean if provided' } };
     }
     await ensureAccess(ctx, state);
-    if (!hasRouteFeature(req.session, 'drive.mount')) {
-        return { status: 403, body: { error: 'Updating sources requires drive.mount.' } };
-    }
     // R2 (architect MINOR-2) — flagging a source `recognizesPackages` creates a
     // code-LOAD surface, so the WRITE is owner/admin-effective only, even though
-    // other source fields are drive.mount. Deny-by-default.
+    // other source fields are sources.mount. Deny-by-default.
     if (recognizesPackages !== undefined && !isOwnerOrAdminEffective(req.session)) {
         return { status: 403, body: { error: 'Setting recognizesPackages requires an owner/admin-effective role.' } };
     }
@@ -737,6 +728,10 @@ async function handleSourcesUpdate(req, state) {
     const existing = await bridge.getSourceConfig(scope, source, toScopeAccessCtx(ctx));
     if (!existing)
         return { status: 404, body: { error: `Source not found: ${source}` } };
+    const ownDevice = deviceAttachVerdict(state, ctx, existing.connection);
+    if (!ownDevice.allowed && !hasRouteFeature(req.session, 'sources.mount')) {
+        return { status: 403, body: { error: 'Updating sources requires sources.mount.' } };
+    }
     if (!canAccessScope(existing.scope, toScopeAccessCtx(ctx), 'write')) {
         return { status: 403, body: { error: 'Forbidden for source scope' } };
     }
@@ -752,22 +747,24 @@ async function handleSourcesUpdate(req, state) {
     if (recognizesPackages === true && existing.connection.kind !== 'local') {
         return { status: 400, body: { error: 'recognizesPackages may only be true for local-kind sources.' } };
     }
-    // native-nightjar BFIX (B2) — PATCH cannot change `connection`, but it CAN
-    // widen an existing host-plane source's permissions (read → write). Editing
-    // one therefore needs the same grants attaching one does; otherwise a
-    // plain-`drive.mount` manager could escalate a read-only host source in place.
+    // PATCH cannot change `connection`, but it CAN widen an existing host-plane
+    // source's permissions (read → write). Editing one therefore needs what
+    // attaching one does — the device's owner with `device.own` — otherwise a
+    // plain-`sources.mount` manager could escalate a read-only host source in place.
     // Same rule for the container plane: a PATCH can widen permissions (read →
     // write) on a source already rooted in a protected zone, so editing one
     // requires the same grants attaching one does — for EVERY root-bearing kind,
     // not just `local`.
-    const missingForEdit = await missingAttachFeature(req.session, existing.connection, buildProtectedRoots(state.ctx.platform.runtimeStack()), async (root) => resolveLocalRoot({ configured: root, projectRoot: (await state.infraFactory.getInfra(projectId)).projectRoot ?? '', source }).resolvedRoot);
+    const missingForEdit = await missingAttachFeature(req.session, existing.connection, buildProtectedRoots(state.ctx.platform.runtimeStack()), async (root) => resolveLocalRoot({ configured: root, projectRoot: (await state.infraFactory.getInfra(projectId)).projectRoot ?? '', source }).resolvedRoot, ownDevice);
     if (missingForEdit) {
         return {
             status: 403,
             body: {
-                error: missingForEdit.plane === 'host'
-                    ? `Editing a host-plane source requires the ${missingForEdit.feature} feature.`
-                    : `Editing a source rooted in a protected host zone requires the ${missingForEdit.feature} feature.`,
+                error: missingForEdit.plane === 'device'
+                    ? "Only the device's owner may edit a source on it."
+                    : missingForEdit.plane === 'host'
+                        ? `Editing a host-plane source requires the ${missingForEdit.feature} feature.`
+                        : `Editing a source rooted in a protected host zone requires the ${missingForEdit.feature} feature.`,
             },
         };
     }
@@ -809,12 +806,14 @@ async function handleSourcesEnabled(req, state) {
         return { status: 400, body: { error: 'enabled must be boolean or "auto"' } };
     }
     await ensureAccess(ctx, state);
-    if (!hasRouteFeature(req.session, 'drive.mount')) {
-        return { status: 403, body: { error: 'Toggling source enabled state requires drive.mount.' } };
-    }
     const bridge = await resolveBridge(state, ctx.projectId);
     const scope = { userId: ctx.userId, projectId: ctx.projectId };
     const existing = await bridge.getSourceConfig(scope, source, toScopeAccessCtx(ctx));
+    // The owner of a paired device manages a source on it with `device.own` —
+    // online or offline (D24).
+    if (!hasRouteFeature(req.session, 'sources.mount') && !(existing && deviceAttachVerdict(state, ctx, existing.connection).allowed)) {
+        return { status: 403, body: { error: 'Toggling source enabled state requires sources.mount.' } };
+    }
     if (!existing)
         return { status: 404, body: { error: `Source not found: ${source}` } };
     if (!canAccessScope(existing.scope, toScopeAccessCtx(ctx), 'write')) {
@@ -832,13 +831,14 @@ async function handleSourcesEnabled(req, state) {
 async function handleSourcesDelete(slug, req, state) {
     const ctx = extractCtx(req);
     await ensureAccess(ctx, state);
-    if (!hasRouteFeature(req.session, 'drive.mount')) {
-        return { status: 403, body: { error: 'Deleting sources requires drive.mount.' } };
-    }
     const bridge = await resolveBridge(state, ctx.projectId);
     const scope = { userId: ctx.userId, projectId: ctx.projectId };
     const configs = await bridge.listSourceConfigs(scope, toScopeAccessCtx(ctx));
     const match = configs.find((c) => c.source.replace(/[^a-zA-Z0-9-]/g, '-') === slug);
+    // The owner of a paired device removes a source on it with `device.own` (D24).
+    if (!hasRouteFeature(req.session, 'sources.mount') && !(match && deviceAttachVerdict(state, ctx, match.connection).allowed)) {
+        return { status: 403, body: { error: 'Deleting sources requires sources.mount.' } };
+    }
     if (!match)
         return { status: 404, body: { error: `Source not found: ${slug}` } };
     if (!canAccessScope(match.scope, toScopeAccessCtx(ctx), 'write')) {
@@ -876,8 +876,8 @@ async function handleSourcesSync(req, state) {
     if (!source)
         return { status: 400, body: { error: 'Missing source' } };
     await ensureAccess(ctx, state);
-    if (!hasRouteFeature(req.session, 'drive.sync')) {
-        return { status: 403, body: { error: 'Sync requires drive.sync.' } };
+    if (!hasRouteFeature(req.session, 'sources.sync')) {
+        return { status: 403, body: { error: 'Sync requires sources.sync.' } };
     }
     const bridge = await resolveBridge(state, projectId);
     const scope = { userId: ctx.userId, projectId };
@@ -906,13 +906,13 @@ async function handleSourcesSync(req, state) {
  * (architect F4): cancel is allowed exactly where the caller could trigger a
  * sync — the same `getSourceConfig(…, access)` visibility check — which
  * deliberately covers background/system jobs on that source (the freeze
- * scenario must be killable by any drive.sync holder who can see the source).
+ * scenario must be killable by any sources.sync holder who can see the source).
  */
 async function handleSourcesCancel(req, state) {
     const ctx = extractCtx(req);
     await ensureAccess(ctx, state);
-    if (!hasRouteFeature(req.session, 'drive.sync')) {
-        return { status: 403, body: { error: 'Cancelling sync requires drive.sync.' } };
+    if (!hasRouteFeature(req.session, 'sources.sync')) {
+        return { status: 403, body: { error: 'Cancelling sync requires sources.sync.' } };
     }
     const bridge = await resolveBridge(state, ctx.projectId);
     const scope = { userId: ctx.userId, projectId: ctx.projectId };
@@ -935,7 +935,7 @@ async function handleSourcesCancel(req, state) {
     return { status: 200, body: { ok: true, cancelled } };
 }
 /**
- * POST /sources/reindex — three operations behind ONE gate (`drive.sync` +
+ * POST /sources/reindex — three operations behind ONE gate (`sources.sync` +
  * source visibility):
  *  - `{source}` — the full re-sync from scratch ("Rescan changes"): markers
  *    cleared, a full job enqueued; unchanged indexed files reuse their vectors,
@@ -951,7 +951,7 @@ async function handleSourcesCancel(req, state) {
  *    `scope:'platform'` (`platform.vector.maintain`, whole source only) it
  *    catches up EVERY writer's points — the way back after a dense clear.
  * The document set is the sync inventory's scope, filtered by the caller's
- * per-uri READ policy before anything is counted — a `drive.sync` holder never
+ * per-uri READ policy before anything is counted — a `sources.sync` holder never
  * learns the size of a file it may not read.
  */
 async function handleSourcesReindex(req, state) {
@@ -965,8 +965,8 @@ async function handleSourcesReindex(req, state) {
     // CLAUDE.md principle 12).
     const ctx = extractCtx(req);
     await ensureAccess(ctx, state);
-    if (!hasRouteFeature(req.session, 'drive.sync')) {
-        return { status: 403, body: { error: 'Reindex requires drive.sync.' } };
+    if (!hasRouteFeature(req.session, 'sources.sync')) {
+        return { status: 403, body: { error: 'Reindex requires sources.sync.' } };
     }
     const force = body?.force === true;
     const embeddingOnly = body?.embeddingOnly === true;
@@ -1089,8 +1089,8 @@ async function handleScopedReembed(ctx, state, bridge, req) {
 async function handleSyncStatus(req, state) {
     const ctx = extractCtx(req);
     await ensureAccess(ctx, state);
-    if (!hasRouteFeature(req.session, 'drive.sync')) {
-        return { status: 403, body: { error: 'Sync status requires drive.sync.' } };
+    if (!hasRouteFeature(req.session, 'sources.sync')) {
+        return { status: 403, body: { error: 'Sync status requires sources.sync.' } };
     }
     const bridge = await resolveBridge(state, ctx.projectId);
     const scope = { userId: ctx.userId, projectId: ctx.projectId };
@@ -1116,10 +1116,10 @@ async function handleSourcesReset(req, state) {
     const ctx = extractCtx(req);
     await ensureAccess(ctx, state);
     // Reset mutates sync markers AND cancels the source's active job — it is
-    // a sync-shaped mutation, so it carries the same drive.sync gate + source
+    // a sync-shaped mutation, so it carries the same sources.sync gate + source
     // visibility check as sync/cancel/reindex (architect MAJOR-2, F4 rule).
-    if (!hasRouteFeature(req.session, 'drive.sync')) {
-        return { status: 403, body: { error: 'Reset requires drive.sync.' } };
+    if (!hasRouteFeature(req.session, 'sources.sync')) {
+        return { status: 403, body: { error: 'Reset requires sources.sync.' } };
     }
     const bridge = await resolveBridge(state, ctx.projectId);
     const scope = { userId: ctx.userId, projectId: ctx.projectId };
@@ -1164,8 +1164,8 @@ async function handleSourcesDiscoverable(req, state) {
     // without this a viewer still read every mount's name and host path. The UI
     // is already fail-soft on a 403 here (`FileTree` gates its fetch on the same
     // feature; `SourcesPanel` catches into an empty list).
-    if (!hasRouteFeature(req.session, 'drive.mount')) {
-        return { status: 403, body: { error: 'Listing discoverable source roots requires the drive.mount feature.' } };
+    if (!hasRouteFeature(req.session, 'sources.mount')) {
+        return { status: 403, body: { error: 'Listing discoverable source roots requires the sources.mount feature.' } };
     }
     const stack = state.ctx.platform.runtimeStack();
     const bridge = await resolveBridge(state, ctx.projectId);
@@ -1368,7 +1368,7 @@ async function handleSourcesDiscoverable(req, state) {
         // Full host — only in native (non-Docker) mode, where `/` IS the host root
         // and is directly readable. In Docker the host is invisible unless bound
         // (`pnpm neuralis:mount add / --slug host`), which then surfaces via the
-        // generic mount loop below. Opt-in, gated by `drive.mount.privileged` (no
+        // generic mount loop below. Opt-in, gated by `sources.privileged` (no
         // grant below the `admin` tier), attach READ-ONLY by default
         // (suggestedAccess) — the whole-host blast radius warrants deny-by-default;
         // the attacher narrows the uri-policy (or widens write) before use.
@@ -1449,15 +1449,15 @@ async function handleSourcesDiscoverable(req, state) {
  * warded-wren (HOST-OSACC-FB9). This handler used to be the one route in the
  * file that checked nothing: no `ensureAccess`, no in-handler feature, no
  * protected-root table, and a raw `err.message` in the body. The route-level
- * `feature = 'drive.read'` is a VIEWER default, so on a native install any
+ * `feature = 'files.read'` is a VIEWER default, so on a native install any
  * signed-in reader could walk the operator's host one level at a time
  * (`?path=/` → `/home` → `/root`), and on win32 enumerate the drive letters.
  *
  * The rule is one sentence: **you may browse exactly what you would be allowed
- * to attach.** The base feature is `drive.mount` — the same gate
+ * to attach.** The base feature is `sources.mount` — the same gate
  * `handleSourcesCreate` gives the act this one prepares — and per-path the
  * SHARED protected-root table decides, so `/`, the App Zone and the Neuralis
- * tree cost `drive.mount.privileged` here exactly as they do at attach time.
+ * tree cost `sources.privileged` here exactly as they do at attach time.
  * `'see'` is the semantically right column; today both columns hold the same
  * feature, so nothing in the suite proves the distinction — it is intent, not
  * enforcement.
@@ -1468,8 +1468,8 @@ async function handleSourcesBrowse(req, state) {
     // Not the security gate — the gates are the feature check below and the
     // per-path table. `ensureAccess` buys uniformity with every sibling handler
     // and the project-override 403 in `extractCtx`.
-    if (!hasRouteFeature(req.session, 'drive.mount')) {
-        return { status: 403, body: { error: 'Browsing filesystem paths requires the drive.mount feature.' } };
+    if (!hasRouteFeature(req.session, 'sources.mount')) {
+        return { status: 403, body: { error: 'Browsing filesystem paths requires the sources.mount feature.' } };
     }
     const { readdir, realpath } = await import('node:fs/promises');
     const { resolve, join, dirname } = await import('node:path');