@bevel-software/platform-core-backend 0.22.0 → 0.24.0

package/dist/modules/workspace/agent-upload.store.js

@@ -0,0 +1,553 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import AdmZip from 'adm-zip';
+import { logger } from '../../shared/logging.js';
+import { MAX_UPLOAD_BYTES } from './upload-limits.js';
+const log = logger('agent-uploads');
+/** How long an issued token, and the bytes sent against it, stay usable. */
+export const UPLOAD_TOKEN_TTL_MS = 15 * 60 * 1000; // 15 minutes
+/** How often the store looks for tokens that have expired. */
+const SWEEP_INTERVAL_MS = 60 * 1000;
+/**
+ * How long past its expiry a CLAIMED record is pinned against the sweep.
+ *
+ * An apply holds its claim while it resolves the branch (which may clone),
+ * reads the bytes, judges every path and commits — work that can outlast a
+ * token whose TTL was nearly up when the apply started. Deleting the source
+ * mid-apply would make the commit land short with no refusal naming the
+ * reason, so a claim keeps its bytes alive. The grace is what stops that from
+ * being forever: an apply that neither consumed nor released within it has
+ * died with its process (the record is in memory, so there is no third
+ * possibility), and the bytes are reclaimed.
+ */
+const CLAIM_GRACE_MS = 10 * 60 * 1000; // 10 minutes
+/**
+ * THE one refusal for every way a token can fail to be usable: it was never
+ * issued, it has already been applied, it has expired, or it belongs to
+ * somebody else. One sentence for all four, deliberately — an answer that
+ * distinguished "no such token" from "not yours" would let anyone holding a
+ * guess learn which guesses exist, and the token is the whole credential this
+ * route has.
+ */
+export const UPLOAD_TOKEN_REFUSAL = 'That upload token cannot be used: it is unknown, already applied, expired, or was issued to someone else. ' +
+    'Call `request_file_upload` for a new one.';
+/**
+ * How many tokens one user may hold open at once.
+ *
+ * A token is permission to put the deployment's whole upload limit on its
+ * disk for a TTL, and to hold a connection open while it arrives. Without a
+ * bound, one caller asks for a hundred and sends against all of them
+ * together. Ten is far more than the route's own use needs — one token carries
+ * a zip of any number of files — and a token is given back the moment it is
+ * applied or expires.
+ */
+export const MAX_OPEN_UPLOADS_PER_USER = 10;
+/** The refusal an over-limit upload gets, naming the limit that applied. */
+export function overLimit(bytes, maxBytes) {
+    return (`That upload is ${bytes} bytes, over this deployment's ${maxBytes} byte upload limit. ` +
+        'Send a smaller file, or split it across several uploads.');
+}
+/** What an upload with no body is told. */
+const EMPTY_UPLOAD = 'That upload carried no bytes. Send the file as the request body — e.g. ' +
+    '`curl -X POST --data-binary @<file> "<uploadUrl>?filename=<name>"`.';
+/** A refusal with the HTTP status the upload route and the apply tool both answer. */
+export class UploadTokenError extends Error {
+    status;
+    constructor(message, status) {
+        super(message);
+        this.status = status;
+        this.name = 'UploadTokenError';
+    }
+}
+/**
+ * The upload tokens an agent lands files with, and the bytes sent against
+ * them.
+ *
+ * An agent that wants to put 27 files on a branch has no way to do it through
+ * a tool argument: the content would have to pass through the model, which
+ * truncates, mangles escape characters and cannot carry a PNG at all. So the
+ * bytes take a route of their own — this store issues a one-time token, the
+ * upload route attaches bytes to it, and `apply_file_upload` lands them.
+ *
+ * Three properties the whole design rests on, because the upload route is the
+ * one endpoint on this server that authenticates by a token alone:
+ *
+ *  - **Unguessable.** 32 random bytes, base64url. Nothing about the token is
+ *    derived from the user, the time or a counter.
+ *  - **Never stored in the clear.** Records are keyed by the token's SHA-256,
+ *    so the store's own memory (and anything that dumps it) holds no usable
+ *    credential.
+ *  - **Bound and single-use.** A record carries the id of the user it was
+ *    issued to and is consumed by the apply that lands it; a second apply, an
+ *    apply by anyone else, and an apply after the expiry all meet
+ *    {@link UPLOAD_TOKEN_REFUSAL}.
+ *
+ * And the bytes land in `root` — a directory beside the workspaces root, not
+ * inside one. No file tool can reach it: every workspace path is resolved
+ * against a branch's checkout, so there is no spelling of a tool argument that
+ * names a file in here. An upload nobody applies is deleted when its token
+ * expires (see {@link startSweeping}), so an abandoned drop costs disk for at
+ * most one TTL.
+ */
+export class AgentUploadStore {
+    records = new Map();
+    root;
+    publicBaseUrl;
+    tokenPrefix;
+    ttlMs;
+    listRoot;
+    maxBytes;
+    maxOpenPerUser;
+    sweepTimer = null;
+    /** The sweep in flight, so a shutdown can wait for it — see {@link drainSweep}. */
+    sweeping = null;
+    /** Set by {@link stopSweeping}: no further sweep deletes anything. */
+    stopped = false;
+    constructor(options) {
+        this.root = options.root;
+        this.publicBaseUrl = options.publicBaseUrl.replace(/\/+$/, '');
+        this.tokenPrefix = options.tokenPrefix ?? '';
+        this.ttlMs = options.ttlMs ?? UPLOAD_TOKEN_TTL_MS;
+        this.listRoot = options.listRoot ?? ((root) => fs.readdir(root));
+        this.maxBytes = options.maxBytes ?? MAX_UPLOAD_BYTES;
+        this.maxOpenPerUser = options.maxOpenPerUser ?? MAX_OPEN_UPLOADS_PER_USER;
+    }
+    /** The URL a token's bytes are sent to. The one spelling of this route's address. */
+    uploadUrlFor(token) {
+        return `${this.publicBaseUrl}/api/agent/uploads/${encodeURIComponent(token)}`;
+    }
+    /**
+     * Mint a token for `user` and answer the terms it is good for. Nothing is
+     * written to disk yet — a token nobody uploads against costs one map entry
+     * until the sweep drops it.
+     */
+    issue(user) {
+        // Counted over what the user still HOLDS: a token that can still be used,
+        // and one whose expiry has passed but whose work has not ended — an upload
+        // still arriving, an apply still reading. Those keep a connection or a file
+        // open exactly as a live token does, so letting them fall out of the count
+        // at expiry would let a caller keep ten slow uploads going and ask for ten
+        // more. An expired record that is doing nothing is waiting for the sweep,
+        // and is not one the user holds.
+        const now = Date.now();
+        let open = 0;
+        for (const record of this.records.values()) {
+            if (record.userId !== user.id)
+                continue;
+            if (record.expiresAt > now || this.pinned(record, now))
+                open += 1;
+        }
+        if (open >= this.maxOpenPerUser) {
+            throw new UploadTokenError(`You already hold ${open} upload tokens, the most one user may have open at once. Apply one of them with ` +
+                '`apply_file_upload`, or wait for one to expire, then ask again. One token carries a zip of any number of files.', 429);
+        }
+        const token = this.tokenPrefix + randomBytes(32).toString('base64url');
+        const expiresAt = Date.now() + this.ttlMs;
+        this.records.set(hash(token), {
+            id: `upload-${Date.now()}-${randomBytes(8).toString('hex')}`,
+            userId: user.id,
+            expiresAt,
+            attaching: false,
+            claimed: false,
+        });
+        // AFTER the record exists, not before. The first sweep runs the moment the
+        // timer starts, and started from an empty map it would be a sweep that
+        // believes nothing is live — this token's own id included.
+        this.startSweeping();
+        return {
+            uploadUrl: this.uploadUrlFor(token),
+            token,
+            expiresAt: new Date(expiresAt).toISOString(),
+            expiresInSeconds: Math.round(this.ttlMs / 1000),
+            maxBytes: this.maxBytes,
+        };
+    }
+    /**
+     * Store the bytes of `body` against `token` and say what was received. One
+     * file per token: a second upload against the same token is refused, so a
+     * token cannot be used to keep replacing bytes an apply is about to land.
+     *
+     * WRITTEN AS THEY ARRIVE, never gathered first. The body is up to the
+     * deployment's whole upload limit, and this is the one route a caller can
+     * send to without a session: held in memory, a handful of uploads at once
+     * cost the process several times that limit each (the chunks, the buffer
+     * they were joined into, the archive read over it). Streamed, an upload in
+     * flight costs one chunk.
+     *
+     * A name ending in `.zip` is read as an archive HERE, once the bytes are on
+     * disk, so the answer can carry the entry count and so a corrupt archive is
+     * refused while the caller is still holding the file — rather than at apply
+     * time, when its token would already be spent.
+     */
+    async receive(token, filename, body) {
+        const record = this.openRecord(token);
+        // RESERVED FIRST, before any `await`: two uploads arriving at once would
+        // otherwise both find the token open, both write, and the apply would land
+        // whichever set of bytes finished last — against a token whose answer
+        // described the other one.
+        record.attaching = true;
+        const stored = path.join(this.root, record.id);
+        let bytes = 0;
+        const received = { filename, bytes: 0, kind: 'file' };
+        try {
+            await fs.mkdir(this.root, { recursive: true });
+            const file = await fs.open(stored, 'w');
+            try {
+                for await (const chunk of body) {
+                    const buf = typeof chunk === 'string' ? Buffer.from(chunk) : chunk;
+                    bytes += buf.byteLength;
+                    // The real total, counted as it arrives: a `content-length` is the
+                    // sender's claim, and a chunked body makes none.
+                    if (bytes > this.maxBytes)
+                        throw new UploadTokenError(overLimit(bytes, this.maxBytes), 413);
+                    // To the last byte: one `write` may put down only part of what it
+                    // was handed and say so in `bytesWritten`, and a chunk counted as
+                    // received while half of it is on disk would land a file shorter
+                    // than the size the answer names.
+                    for (let written = 0; written < buf.byteLength;) {
+                        written += (await file.write(buf, written, buf.byteLength - written)).bytesWritten;
+                    }
+                }
+            }
+            finally {
+                await file.close();
+            }
+            if (bytes === 0)
+                throw new UploadTokenError(EMPTY_UPLOAD, 400);
+            received.bytes = bytes;
+            if (filename.toLowerCase().endsWith('.zip')) {
+                try {
+                    received.entries = new AdmZip(stored).getEntries().length;
+                }
+                catch (err) {
+                    throw new UploadTokenError(`"${filename}" is not a readable .zip archive: ${err instanceof Error ? err.message : String(err)}`, 422);
+                }
+                received.kind = 'zip';
+            }
+        }
+        catch (err) {
+            // Nothing was received, so the token is open again: the sender may retry
+            // with the same one rather than ask for another. Whatever part of the
+            // body reached the disk goes now, rather than at the next sweep.
+            await this.remove(record.id);
+            record.attaching = false;
+            throw err;
+        }
+        // THE TTL MAY HAVE PASSED while the bytes were arriving — a 40 MB upload
+        // over a slow link takes real time, and the token was issued before it
+        // started. The record was pinned against the sweep throughout (see
+        // {@link pinned}), so neither it nor the file could be deleted under the
+        // write; but an expired token cannot be applied, so answering "received"
+        // would hand the sender a success it can do nothing with. The refusal is
+        // the honest answer, and the bytes go with it rather than waiting for a
+        // sweep to notice.
+        if (record.expiresAt <= Date.now()) {
+            this.records.delete(hash(token));
+            await this.remove(record.id);
+            throw new UploadTokenError(UPLOAD_TOKEN_REFUSAL, 404);
+        }
+        record.received = received;
+        return received;
+    }
+    /**
+     * Refuse `token` if it cannot accept bytes — unknown, expired, somebody
+     * else's doing, or already holding a file — and answer its record if it can.
+     *
+     * Exists as its own step so the upload route can ask BEFORE it reads the
+     * body. The route is the one endpoint here authenticated by a token alone,
+     * and buffering up to the deployment's whole upload limit for an invented
+     * token would let a handful of concurrent requests spend the process's
+     * memory on bytes that were never going to be stored.
+     */
+    assertOpen(token) {
+        this.openRecord(token);
+    }
+    /** {@link assertOpen}, with the record it found — the store's own view of it. */
+    openRecord(token) {
+        const record = this.find(token);
+        if (record.received !== undefined || record.attaching) {
+            throw new UploadTokenError(UPLOAD_TOKEN_REFUSAL, 404);
+        }
+        return record;
+    }
+    /**
+     * Hold `token` for an apply by `userId`, and answer where its bytes are.
+     *
+     * A CLAIM rather than a consume, because an apply can be refused whole —
+     * the destination is on a protected branch the caller may not write, the
+     * archive turned out unreadable — and a token spent on a refusal would make
+     * the agent send the same 40 MB again to try a different destination. The
+     * claim is what keeps it single-use meanwhile: a second apply arriving while
+     * the first runs finds the token in use and is refused. The caller
+     * {@link consume}s it once an answer exists, or {@link release}s it on a
+     * refusal that landed nothing.
+     */
+    claim(token, userId) {
+        const record = this.find(token);
+        if (record.userId !== userId || record.claimed || record.received === undefined) {
+            throw new UploadTokenError(UPLOAD_TOKEN_REFUSAL, 404);
+        }
+        record.claimed = true;
+        record.claimedAt = Date.now();
+        return { ...record.received, absolutePath: path.join(this.root, record.id) };
+    }
+    /** Give a claimed token back, unused — the apply refused without landing anything. */
+    release(token) {
+        const record = this.records.get(hash(token));
+        if (record) {
+            record.claimed = false;
+            record.claimedAt = undefined;
+        }
+    }
+    /** Spend the token and delete its bytes. Idempotent. */
+    async consume(token) {
+        const key = hash(token);
+        const record = this.records.get(key);
+        if (!record)
+            return;
+        this.records.delete(key);
+        await this.remove(record.id);
+    }
+    /**
+     * Delete every record whose token has expired, with the bytes it was
+     * holding — then delete any file in the root that no LIVE record claims and
+     * that has outlived every token that could name it.
+     *
+     * The second half is what makes the first one true. A process killed between
+     * the write and the apply leaves a file no map will ever mention again, and
+     * sweeping by what the records DON'T name is the honest reading of the
+     * promise: an upload nobody applied does not stay. By AGE rather than at
+     * once, because a file this map does not name may be another process's (see
+     * the loop below).
+     *
+     * ONE record is kept past its expiry: one an apply has CLAIMED. Those bytes
+     * are being read right now, and a sweep that deleted them would make the
+     * commit land short of what the answer promised. The pin lasts
+     * {@link CLAIM_GRACE_MS}, after which a claim nobody consumed or released
+     * belongs to a dead process and is reclaimed.
+     */
+    async sweepNow() {
+        if (this.stopped)
+            return;
+        const now = Date.now();
+        for (const [key, record] of [...this.records]) {
+            if (record.expiresAt > now)
+                continue;
+            if (this.pinned(record, now))
+                continue;
+            this.records.delete(key);
+            await this.remove(record.id);
+        }
+        let names;
+        try {
+            names = await this.listRoot(this.root);
+        }
+        catch {
+            return; // root not created yet, or unreadable — nothing to reclaim
+        }
+        // Every id a live record is holding — including one whose bytes have not
+        // arrived yet, so an upload in flight is never swept out from under itself,
+        // and one an apply has pinned past its expiry.
+        //
+        // Read AFTER the directory, never before. The gap between the two is a
+        // real one — the readdir is a filesystem round-trip, and this process
+        // serves other requests across it — so a token issued and uploaded during
+        // that gap would appear in `names` while a set taken earlier had never
+        // heard of it, and the sweep would delete bytes somebody had just been
+        // told were received. Taken afterwards, the set is a superset of what the
+        // listing could possibly name.
+        const live = new Set([...this.records.values()].map((r) => r.id));
+        for (const name of names) {
+            // Asked again per name: a stop (an evicted tenant, a shutdown) that
+            // landed while this sweep was reading the directory must not go on to
+            // delete files a replacement store may already have issued ids for.
+            if (this.stopped)
+                return;
+            if (live.has(name))
+                continue;
+            // A file this map does not name is not necessarily nobody's. The records
+            // are ONE PROCESS's memory, and two processes share this directory
+            // whenever a deployment restarts by starting the new one before the old
+            // one has stopped: to each, the other's uploads are files no record
+            // names. So such a file goes only once it is older than any token could
+            // still be good for — its TTL, and the grace an apply holding it is
+            // given. A process that died leaves its files for that long and no
+            // longer; a process that is alive never loses one in use.
+            if (await this.outlivedEveryToken(name, now))
+                await this.remove(name);
+        }
+    }
+    /**
+     * Whether the stored file `name` is older than any token that could still be
+     * naming it, in this process or another. A file that cannot be examined is
+     * left for the next sweep rather than judged.
+     */
+    async outlivedEveryToken(name, now) {
+        try {
+            const { mtimeMs } = await fs.stat(path.join(this.root, name));
+            return now - mtimeMs > this.ttlMs + CLAIM_GRACE_MS;
+        }
+        catch {
+            return false;
+        }
+    }
+    /**
+     * Whether an expired record is held open by work that is still running:
+     * an UPLOAD still writing its bytes, or an APPLY still reading them.
+     *
+     * Both windows can outlast a TTL — a large upload over a slow link, an apply
+     * that clones a branch before it reads — and in both the record's own file is
+     * being written or read right now. A sweep that deleted either would leave a
+     * file no map mentions (the upload writes after the delete) or an apply
+     * reading a path that has gone. The apply's pin has a grace, because a claim
+     * can be abandoned by a process that dies; the upload's needs none, because
+     * `receive` always ends — it clears `attaching` on failure and sets
+     * `received` on success, and one whose TTL passed meanwhile deletes the
+     * record itself rather than leaving it pinned.
+     */
+    pinned(record, now) {
+        if (record.attaching && record.received === undefined)
+            return true;
+        return record.claimed && now - (record.claimedAt ?? now) < CLAIM_GRACE_MS;
+    }
+    /**
+     * Sweep now, and keep sweeping. Started by the first {@link issue} rather
+     * than at boot, so a deployment nobody uploads to runs no timer; idempotent,
+     * and the timer is `unref`'d because nothing here is worth keeping a process
+     * alive for — the records are in memory and go with it.
+     *
+     * The first sweep runs IMMEDIATELY, not one interval later, because the
+     * records are in memory: a process that restarted holds no record of what
+     * the previous one stored, and what that one left behind long enough ago
+     * has no reason to wait a further interval.
+     */
+    startSweeping(intervalMs = SWEEP_INTERVAL_MS) {
+        if (this.sweepTimer)
+            return;
+        this.stopped = false;
+        this.sweep();
+        this.sweepTimer = setInterval(() => this.sweep(), intervalMs);
+        this.sweepTimer.unref?.();
+    }
+    /**
+     * Stop sweeping, for good: the timer is cleared AND a sweep already running
+     * abandons the rest of its work.
+     *
+     * Both halves matter when a graph is stopped — a tenant evicted, the process
+     * shutting down. The root is this tenant's, and a reactivation builds a new
+     * store over the same directory with an empty record map: a sweep left
+     * running from the old store would find the new store's files named by no
+     * record of ITS own and delete them, under an apply that is about to read
+     * them. {@link drainSweep} is how a caller waits for the abandonment to
+     * actually have happened.
+     */
+    stopSweeping() {
+        this.stopped = true;
+        if (this.sweepTimer)
+            clearInterval(this.sweepTimer);
+        this.sweepTimer = null;
+    }
+    /** Wait for the sweep in flight, if any. Pairs with {@link stopSweeping} on shutdown. */
+    async drainSweep() {
+        await this.sweeping;
+    }
+    /** One sweep, with its failure logged and its promise kept for {@link drainSweep}. */
+    sweep() {
+        const running = this.sweepNow()
+            .catch((err) => {
+            log.warn('could not sweep expired uploads:', { err });
+        })
+            .finally(() => {
+            if (this.sweeping === running)
+                this.sweeping = null;
+        });
+        this.sweeping = running;
+    }
+    /** The live record for `token`, or the one refusal. Expiry is judged here. */
+    find(token) {
+        const key = hash(token);
+        const record = this.records.get(key);
+        if (!record)
+            throw new UploadTokenError(UPLOAD_TOKEN_REFUSAL, 404);
+        const now = Date.now();
+        if (record.expiresAt <= now) {
+            // Expired either way — but a record an apply is still reading keeps its
+            // bytes (and its map entry) until that apply ends, for the reason
+            // {@link sweepNow} gives. The refusal is the same; only the deletion waits.
+            if (!this.pinned(record, now)) {
+                this.records.delete(key);
+                void this.remove(record.id);
+            }
+            throw new UploadTokenError(UPLOAD_TOKEN_REFUSAL, 404);
+        }
+        return record;
+    }
+    /** Best-effort delete of one stored upload. Never throws. */
+    async remove(id) {
+        try {
+            await fs.rm(path.join(this.root, id), { force: true });
+        }
+        catch (err) {
+            log.warn(`could not delete the stored upload "${id}":`, { err });
+        }
+    }
+}
+function hash(token) {
+    return createHash('sha256').update(token).digest('hex');
+}
+/**
+ * Refuse a boot whose upload root is not OUTSIDE every workspace.
+ *
+ * The whole safety of this route rests on where the bytes land: they are a
+ * buffer somebody sent, judged by nothing until `apply_file_upload` judges each
+ * path against a branch. A root configured inside `workspacesRoot` would put
+ * that unjudged buffer where the file tools read — `read_file`, `grep`, the
+ * download route — bypassing the access and platform-file rules the apply
+ * exists to apply. The invariant is documented on `AGENT_UPLOADS_ROOT`; this is
+ * it checked, at boot, naming the variable, rather than trusted.
+ *
+ * Both directions and both spellings: equal paths, either containing the
+ * other, and the real paths, so a root that is a LINK into the workspaces tree
+ * is refused too.
+ */
+export async function assertUploadsRootOutsideWorkspaces(uploadsRoot, workspacesRoot) {
+    for (const [uploads, workspaces] of [
+        [path.resolve(uploadsRoot), path.resolve(workspacesRoot)],
+        [await realBase(uploadsRoot), await realBase(workspacesRoot)],
+    ]) {
+        if (uploads === workspaces || contains(workspaces, uploads) || contains(uploads, workspaces)) {
+            throw new Error(`AGENT_UPLOADS_ROOT ("${uploadsRoot}") must be outside WORKSPACES_ROOT ("${workspacesRoot}"): uploaded ` +
+                'bytes are staged there before any access or platform-file rule has judged them, so a root inside a ' +
+                'workspace would let the file tools read them. Point it at a sibling directory.');
+        }
+    }
+}
+/** Whether `child` is inside `parent`. Paths already resolved. */
+function contains(parent, child) {
+    return child.startsWith(parent.endsWith(path.sep) ? parent : parent + path.sep);
+}
+/**
+ * `dir` with every link on it resolved — as far as it exists. Neither root is
+ * required to exist yet (the store makes its own on the first upload), so the
+ * deepest existing ancestor is resolved and the missing rest joined back on:
+ * a link anywhere along the part that DOES exist is what could redirect the
+ * one into the other.
+ */
+async function realBase(dir) {
+    let existing = path.resolve(dir);
+    const rest = [];
+    for (;;) {
+        try {
+            return path.join(await fs.realpath(existing), ...rest);
+        }
+        catch {
+            const up = path.dirname(existing);
+            if (up === existing)
+                return path.join(existing, ...rest);
+            rest.unshift(path.basename(existing));
+            existing = up;
+        }
+    }
+}
+//# sourceMappingURL=agent-upload.store.js.map

package/dist/modules/workspace/agent-upload.store.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"agent-upload.store.js","sourceRoot":"","sources":["../../../src/modules/workspace/agent-upload.store.ts"],"names":[],"mappings":"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"}

package/dist/modules/workspace/routine-write-policy.d.ts

@@ -1,9 +1,9 @@
 /**
  * Per-run write restriction for background/routine agents.
  *
- * The ontology-session gate ({@link ../workflow/session-ontology.service}) bounds
- * WHICH ontology a run may write; this narrower gate bounds WHAT KIND of file a
- * run may write, by extension. It exists for the `watchlist_check` routine, which is
+ * The agent-access gate ({@link ./agent-access.gate}) lets a deployment decide
+ * WHETHER a run may write a path at all; this narrower gate bounds WHAT KIND of
+ * file a run may write, by extension. It exists for the `watchlist_check` routine, which is
  * allowed to refresh dashboard views (`.html`) but must never touch the
  * knowledge-graph nodes (`.md`) or any other file — a hard, code-level guarantee
  * rather than a prompt request (a prompt-only rule has already proven insufficient).
@@ -11,9 +11,8 @@
  * Keyed by the agent run's `sessionId` (the background agent passes its run id as
  * the session id, which the internal token then carries onto every loopback tool
  * call as `ctx.sessionId`). A restriction lives only for the duration of one
- * in-process run, so the store is a plain in-memory map — no durability needed,
- * unlike the ontology touched-set which must survive restarts and span the MCP
- * proxy. The executor sets the restriction before streaming and clears it after.
+ * in-process run, so the store is a plain in-memory map — no durability needed.
+ * The executor sets the restriction before streaming and clears it after.
  */
 export interface IRoutineWritePolicy {
     /**

package/dist/modules/workspace/routine-write-policy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"routine-write-policy.d.ts","sourceRoot":"","sources":["../../../src/modules/workspace/routine-write-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAIH,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAC7E,wDAAwD;IACxD,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B;;;;OAIG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACxE;;;;OAIG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;CACzD;AAED,qBAAa,yBAA0B,YAAW,mBAAmB;IACnE,wEAAwE;IACxE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAkC;IAE/D,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI;IAI5E,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAI9B,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAcvE,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;CAQxD"}
+{"version":3,"file":"routine-write-policy.d.ts","sourceRoot":"","sources":["../../../src/modules/workspace/routine-write-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAIH,MAAM,WAAW,mBAAmB;IAClC;;;;;OAKG;IACH,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI,CAAC;IAC7E,wDAAwD;IACxD,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B;;;;OAIG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IACxE;;;;OAIG;IACH,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI,CAAC;CACzD;AAED,qBAAa,yBAA0B,YAAW,mBAAmB;IACnE,wEAAwE;IACxE,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAkC;IAE/D,oBAAoB,CAAC,SAAS,EAAE,MAAM,EAAE,UAAU,EAAE,SAAS,MAAM,EAAE,GAAG,IAAI;IAI5E,KAAK,CAAC,SAAS,EAAE,MAAM,GAAG,IAAI;IAI9B,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,EAAE,MAAM,EAAE,MAAM,GAAG,IAAI;IAcvE,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,GAAG,IAAI;CAQxD"}

package/dist/modules/workspace/routine-write-policy.js

@@ -1,9 +1,9 @@
 /**
  * Per-run write restriction for background/routine agents.
  *
- * The ontology-session gate ({@link ../workflow/session-ontology.service}) bounds
- * WHICH ontology a run may write; this narrower gate bounds WHAT KIND of file a
- * run may write, by extension. It exists for the `watchlist_check` routine, which is
+ * The agent-access gate ({@link ./agent-access.gate}) lets a deployment decide
+ * WHETHER a run may write a path at all; this narrower gate bounds WHAT KIND of
+ * file a run may write, by extension. It exists for the `watchlist_check` routine, which is
  * allowed to refresh dashboard views (`.html`) but must never touch the
  * knowledge-graph nodes (`.md`) or any other file — a hard, code-level guarantee
  * rather than a prompt request (a prompt-only rule has already proven insufficient).
@@ -11,9 +11,8 @@
  * Keyed by the agent run's `sessionId` (the background agent passes its run id as
  * the session id, which the internal token then carries onto every loopback tool
  * call as `ctx.sessionId`). A restriction lives only for the duration of one
- * in-process run, so the store is a plain in-memory map — no durability needed,
- * unlike the ontology touched-set which must survive restarts and span the MCP
- * proxy. The executor sets the restriction before streaming and clears it after.
+ * in-process run, so the store is a plain in-memory map — no durability needed.
+ * The executor sets the restriction before streaming and clears it after.
  */
 import { ToolError } from '../tool-helpers/tool.contract.js';
 export class RoutineWritePolicyService {

package/dist/modules/workspace/routine-write-policy.js.map

@@ -1 +1 @@
-{"version":3,"file":"routine-write-policy.js","sourceRoot":"","sources":["../../../src/modules/workspace/routine-write-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AA0B7D,MAAM,OAAO,yBAAyB;IACpC,wEAAwE;IACvD,YAAY,GAAG,IAAI,GAAG,EAAuB,CAAC;IAE/D,oBAAoB,CAAC,SAAiB,EAAE,UAA6B;QACnE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC;IACpF,CAAC;IAED,KAAK,CAAC,SAAiB;QACrB,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACtC,CAAC;IAED,kBAAkB,CAAC,SAA6B,EAAE,MAAc;QAC9D,MAAM,OAAO,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QACzE,IAAI,CAAC,OAAO;YAAE,OAAO;QACrB,MAAM,KAAK,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC;QACnC,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;YAC1B,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC;gBAAE,OAAO;QAClC,CAAC;QACD,MAAM,IAAI,SAAS,CACjB,2BAA2B,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,8BAA8B,MAAM,gBAAgB;YACpG,uEAAuE,EACzE,GAAG,CACJ,CAAC;IACJ,CAAC;IAED,kBAAkB,CAAC,SAA6B;QAC9C,IAAI,SAAS,IAAI,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YAClD,MAAM,IAAI,SAAS,CACjB,sHAAsH,EACtH,GAAG,CACJ,CAAC;QACJ,CAAC;IACH,CAAC;CACF"}
+{"version":3,"file":"routine-write-policy.js","sourceRoot":"","sources":["../../../src/modules/workspace/routine-write-policy.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAAE,SAAS,EAAE,MAAM,kCAAkC,CAAC;AA0B7D,MAAM,OAAO,yBAAyB;IACpC,wEAAwE;IACvD,YAAY,GAAG,IAAI,GAAG,EAAuB,CAAC;IAE/D,oBAAoB,CAAC,SAAiB,EAAE,UAA6B;QACnE,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,EAAE,IAAI,GAAG,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC,CAAC,CAAC;IACpF,CAAC;IAED,KAAK,CAAC,SAAiB;QACrB,IAAI,CAAC,YAAY,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IACtC,CAAC;IAED,kBAAkB,CAAC,SAA6B,EAAE,MAAc;QAC9D,MAAM,OAAO,GAAG,SAAS,CAAC,CAAC,CAAC,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;QACzE,IAAI,CAAC,OAAO;YAAE,OAAO;QACrB,MAAM,KAAK,GAAG,MAAM,CAAC,WAAW,EAAE,CAAC;QACnC,KAAK,MAAM,GAAG,IAAI,OAAO,EAAE,CAAC;YAC1B,IAAI,KAAK,CAAC,QAAQ,CAAC,GAAG,CAAC;gBAAE,OAAO;QAClC,CAAC;QACD,MAAM,IAAI,SAAS,CACjB,2BAA2B,CAAC,GAAG,OAAO,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,8BAA8B,MAAM,gBAAgB;YACpG,uEAAuE,EACzE,GAAG,CACJ,CAAC;IACJ,CAAC;IAED,kBAAkB,CAAC,SAA6B;QAC9C,IAAI,SAAS,IAAI,IAAI,CAAC,YAAY,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;YAClD,MAAM,IAAI,SAAS,CACjB,sHAAsH,EACtH,GAAG,CACJ,CAAC;QACJ,CAAC;IACH,CAAC;CACF"}