@bevel-software/platform-core-backend 0.19.0 → 0.21.0

package/dist/modules/workflow/locking-filesystem.js

@@ -1,553 +0,0 @@
-/**
- * A `LocalFilesystem` that wraps every mutating operation in a workflow
- * lock acquire → super-call → release-with-auto-commit-and-push cycle.
- * This is the agent's file edit surface — Mastra hands the agent the
- * workspace's filesystem tools (write_file / edit_file / etc.), and those
- * call directly into this class, so the agent's edits go through the same
- * lock + commit + push pipeline as the human editor's saves.
- *
- * Per the workflow spec (PLAN.md §2):
- *   - Each tool call is one acquire/release cycle. The agent never holds a
- *     lock while it's "thinking" between tool calls — a fast human editor
- *     can always grab a file the agent isn't actively writing.
- *   - On lock contention (someone else holds the lock) we retry 3× at
- *     2-second intervals (~6s ceiling) then surface a structured error
- *     so the agent can skip the file and continue with the rest of its
- *     turn rather than aborting the whole call.
- *   - Lock-release inside `WorkflowService.releaseLock` is the thing that
- *     actually commits + pushes the file — see that method for the
- *     `commitFile → release → push` sequence. We don't repeat the commit
- *     step here; releasing IS committing.
- *   - `rmdir` is refused. The workflow invariant is "each change touches
- *     exactly one file" and a recursive directory delete violates that.
- *     The agent must delete entries individually via `deleteFile`.
- *   - `mkdir` followed by a `.gitkeep` write is the canonical way to land
- *     "create empty folder" as a one-file change — the locking write of
- *     `.gitkeep` carries the commit.
- *
- * Path conventions: Mastra's `inputPath` is workspace-relative (e.g.
- * `knowledge-base/Knowledge/Foo.md`) — the same shape the human
- * editor's `openFilePath` carries, so locks acquired by the agent and
- * the user collide on the same key. That's why the human can't sneak
- * an edit in while the agent is writing the same file.
- */
-import fs from 'node:fs/promises';
-import { LocalFilesystem, } from '@mastra/core/workspace';
-import { PushNeedsAgentResolutionError } from './workflow.errors.js';
-/** How many times to retry a contended acquire before giving up. */
-const ACQUIRE_RETRY_ATTEMPTS = 3;
-/** Backoff between retries (ms). 3 attempts × 2s ≈ 6s ceiling. */
-const ACQUIRE_RETRY_DELAY_MS = 2_000;
-export class LockingFilesystem extends LocalFilesystem {
-    lockContext;
-    constructor(options, lockContext) {
-        super(options);
-        this.lockContext = lockContext;
-    }
-    async writeFile(inputPath, content, options) {
-        // Pre-disk gate (e.g. reject a roles.yaml edit that would lock out admins).
-        // Runs OUTSIDE the lock so a refusal never acquires/holds one.
-        this.lockContext.validateWrite?.(inputPath, content);
-        // Creator read grant (see LockingFilesystemContext.creatorAccess): planned
-        // BEFORE the write so the topmost-new-directory detection sees the
-        // pre-creation tree. A subtree seed lands first in its own lock+commit
-        // cycle so the grant is on disk before the file it makes visible.
-        const plan = await this.planCreate(inputPath, 'file');
-        if (plan?.kind === 'seed-access-md')
-            await this.seedAccessMd(plan);
-        const toWrite = plan?.kind === 'frontmatter' && typeof content === 'string'
-            ? plan.apply(content)
-            : content;
-        return this.withLock(inputPath, () => super.writeFile(inputPath, toWrite, options));
-    }
-    async appendFile(inputPath, content) {
-        return this.withLock(inputPath, () => super.appendFile(inputPath, content));
-    }
-    async deleteFile(inputPath, options) {
-        return this.withLock(inputPath, () => super.deleteFile(inputPath, options));
-    }
-    async copyFile(src, dest, options) {
-        // Lock on `dest`. `src` is read-only from this op's perspective — copy
-        // creates a new file at dest without disturbing src on disk.
-        return this.withLock(dest, () => super.copyFile(src, dest, options));
-    }
-    async moveFile(src, dest, options) {
-        // A move mutates two paths: the source is deleted and the destination
-        // is created. Only locking `dest` would let a concurrent writer hold
-        // the source's lock and mutate it under us, and would also leave the
-        // source's deletion uncommitted (commitFile is path-scoped — it stages
-        // only the path the lock release names, not "everything dirty").
-        //
-        // Lock both, in deterministic string order so two concurrent moves
-        // can't deadlock by acquiring locks in opposite orders. The releases
-        // unwind in reverse: the outer lock's release commits its path, then
-        // the inner lock's release commits its path — each move lands as two
-        // single-file changes (one delete, one create). Git's rename
-        // detection on log/blame still groups them visually after the fact.
-        if (src === dest) {
-            return this.withLock(dest, () => super.moveFile(src, dest, options));
-        }
-        const [first, second] = src < dest ? [src, dest] : [dest, src];
-        return this.withLock(first, () => this.withLock(second, () => super.moveFile(src, dest, options)));
-    }
-    /**
-     * Write several files and commit them as ONE atomic change — the multi-file
-     * counterpart to `writeFile`, for the rare case where a set of files must
-     * land together or not at all (e.g. a role rename rewriting `roles.yaml` plus
-     * every reference; a partial rewrite would be a silent access drop). Where
-     * `writeFile` takes one lock cycle per file and lets the deferred queue commit
-     * it, this wraps the WHOLE batch in one cycle: acquire every path's lock up
-     * front, write every file to disk, then commit the whole set synchronously as
-     * one change via the workflow service's `commitChanges` (one `git add` + one
-     * `git commit`, then push), and release WITHOUT a per-file commit. Fail-closed:
-     * if any lock can't be acquired, or a write/commit throws, nothing is committed
-     * (the failure-path `releaseLockNoCommit` discards the uncommitted bytes).
-     * The ONE exception is `PushNeedsAgentResolutionError` — a POST-commit
-     * failure (the commit landed, the push didn't): locks release via
-     * `releaseLock` so the enqueued release commit arms the pending-commits
-     * worker's push retry, and the error still propagates to the caller.
-     *
-     * `writes[].path` is workspace-relative (like `writeFile`). We do the disk
-     * write here; `commitChanges` only stages + commits what's on disk (the git
-     * layer never writes content).
-     */
-    async writeFiles(writes, summary, deletes = []) {
-        const { workflow, workspaceId, branch, user } = this.lockContext;
-        // Creator read grants for the batch: transform new markdown files'
-        // content in place, and fold any subtree access.md seeds into the SAME
-        // atomic batch (deduped — several files landing in one new folder share
-        // one seed). Plans are computed against the pre-batch disk state, which
-        // is exactly right: nothing below has hit disk yet. A seed whose path the
-        // caller explicitly writes in this batch is skipped — the caller's bytes
-        // win.
-        const seeds = new Map();
-        const grantedWrites = [];
-        for (const w of writes) {
-            const plan = await this.planCreate(w.path, 'file');
-            if (plan?.kind === 'seed-access-md' && !writes.some((x) => x.path === plan.wsRelPath)) {
-                seeds.set(plan.wsRelPath, plan.apply);
-            }
-            grantedWrites.push(plan?.kind === 'frontmatter' && typeof w.content === 'string'
-                ? { path: w.path, content: plan.apply(w.content) }
-                : w);
-        }
-        writes = grantedWrites;
-        // Pre-disk gate every file BEFORE acquiring any lock (fail-closed): a
-        // refusal must not leave a lock held or a partial batch on disk.
-        if (this.lockContext.validateWrite) {
-            for (const w of writes)
-                this.lockContext.validateWrite(w.path, w.content);
-        }
-        // Deterministic lock order (string sort) so two concurrent batch writes
-        // can't deadlock by acquiring the same paths in opposite orders — the same
-        // discipline `moveFile` uses for its two paths, generalized to N. Deletes are
-        // locked too (a delete mutates that path just like a write).
-        const paths = [...new Set([...writes.map((w) => w.path), ...deletes])].sort();
-        const acquired = [];
-        // Paths whose on-disk bytes THIS batch replaced (caller writes/deletes,
-        // recorded just before each disk op so a mid-write throw still counts).
-        // Deliberately NOT the seed paths: a seed write is an additive merge of
-        // the CURRENT bytes, and a failed one restores its pre-image itself —
-        // only a seed whose restore ALSO failed joins the discard set, via
-        // `failedSeedDiscards` (see the seed loop).
-        const dirtied = new Set();
-        // Seed paths left holding known-partial bytes: the seed write threw
-        // mid-write AND the pre-image restore failed too. These must release
-        // with the discard so the corrupt bytes can't outlive the batch.
-        const failedSeedDiscards = new Set();
-        // Release every acquired lock, each with the semantics its outcome
-        // earned. Three shapes (mirroring the three WorkflowService releases):
-        //
-        //   'discard'   → releaseLockNoCommit: resets the path's working tree to
-        //     HEAD. Only for bytes this batch itself owns — its committed paths
-        //     (clean tree, the discard no-ops), its own failed writes, and a
-        //     failed-restore seed (fail-closed: partial bytes must not land).
-        //   'enqueue'   → releaseLock: enqueues a commit-on-release row. Only
-        //     for the push-retry unwind, and only on the batch's OWN committed
-        //     paths — the enqueued row is the vehicle that retries the push.
-        //   'untouched' → releaseLockUntouched: drops the lock row and nothing
-        //     else. For every path the batch merely LOCKED (a creator seed that
-        //     no-op'd or fully restored itself, a caller path never reached):
-        //     such a path may hold a PRIOR save's dirty bytes whose commit is
-        //     still queued — a discard would silently destroy that landed save,
-        //     and an enqueue would re-attribute its queued row to THIS user and
-        //     reset its retry ladder.
-        const releaseAll = async (modeOf) => {
-            for (const p of acquired) {
-                try {
-                    const mode = modeOf(p);
-                    if (mode === 'discard') {
-                        await workflow.releaseLockNoCommit(workspaceId, branch, p, user);
-                    }
-                    else if (mode === 'enqueue') {
-                        await workflow.releaseLock(workspaceId, branch, p, user);
-                    }
-                    else {
-                        await workflow.releaseLockUntouched(workspaceId, branch, p, user);
-                    }
-                }
-                catch (releaseErr) {
-                    console.warn(`[locking-fs] lock release failed for "${p}" during writeFiles:`, releaseErr instanceof Error ? releaseErr.message : releaseErr);
-                }
-            }
-        };
-        // Acquire every lock before committing a single byte (fail-closed).
-        for (const p of paths) {
-            let holderName = null;
-            let ok = false;
-            for (let attempt = 0; attempt < ACQUIRE_RETRY_ATTEMPTS; attempt++) {
-                const result = await workflow.acquireLock(workspaceId, branch, p, user);
-                if (result.acquired) {
-                    ok = true;
-                    break;
-                }
-                holderName = result.lock.holderName;
-                if (attempt < ACQUIRE_RETRY_ATTEMPTS - 1)
-                    await sleep(ACQUIRE_RETRY_DELAY_MS);
-            }
-            if (!ok) {
-                // Nothing written yet — every held lock is a merely-locked path, so
-                // the unwind must leave disk and queue exactly as they are.
-                await releaseAll(() => 'untouched');
-                throw new Error(`Skipped editing "${p}" — locked by ${holderName ?? 'another user'}. ` +
-                    `Continuing with other edits; try this one again later.`);
-            }
-            acquired.push(p);
-        }
-        // Creator-grant seed locks are BEST-EFFORT, single attempt, acquired
-        // after the caller's paths: a contended access.md must drop that seed
-        // (with a warning), never fail or stall the batch the caller asked for.
-        // Single non-blocking attempts also can't deadlock against another batch.
-        for (const p of [...seeds.keys()].sort()) {
-            if (paths.includes(p))
-                continue; // already locked as a caller path
-            const result = await workflow.acquireLock(workspaceId, branch, p, user);
-            if (result.acquired) {
-                acquired.push(p);
-            }
-            else {
-                seeds.delete(p);
-                console.warn(`[locking-fs] creator access.md seed skipped for "${p}" — locked by ${result.lock.holderName ?? 'another user'}`);
-            }
-        }
-        // The paths this batch actually TOUCHED — the caller's writes + deletes,
-        // plus each seed whose bytes really landed below. Kept separate from
-        // `acquired` (which only tracks held LOCKS): a seed lock is taken before
-        // we know whether the seed write happens, and scoping the commit to a
-        // merely-locked path would sweep in another save's still-queued dirty
-        // bytes on that path under this batch's author/summary.
-        const touched = [...paths];
-        // Seeds whose bytes LANDED, with the pre-image read under their lock:
-        // if the batch's commit then fails, these must be rolled back to that
-        // pre-image (not to HEAD — the pre-image may be a prior save's queued
-        // bytes) so an uncommitted grant can't sit on disk as if it were real.
-        const landedSeeds = new Map();
-        let change;
-        try {
-            // Write/delete every file to disk inside the locks (workspace-relative;
-            // LocalFilesystem resolves against basePath), then commit + push the whole
-            // set as ONE change. `commitChanges` only stages + commits what's on disk.
-            for (const w of writes) {
-                dirtied.add(w.path);
-                await super.writeFile(w.path, w.content);
-            }
-            for (const p of deletes) {
-                dirtied.add(p);
-                await super.deleteFile(p);
-            }
-            // Seeds merge into the CURRENT on-disk bytes (read under the lock) so a
-            // concurrent creator's grant survives; per-seed failures are best-effort.
-            for (const [p, apply] of seeds) {
-                let current = '';
-                let existedBefore = false;
-                const absolute = this.resolveAbsolutePath(p);
-                if (absolute) {
-                    try {
-                        current = await fs.readFile(absolute, 'utf-8');
-                        existedBefore = true;
-                    }
-                    catch {
-                        // Not there yet — the normal case for a brand-new directory.
-                    }
-                }
-                let next;
-                try {
-                    next = apply(current);
-                }
-                catch (err) {
-                    // Plan failed before any bytes moved — the path is untouched.
-                    console.warn(`[locking-fs] creator access.md seed failed for "${p}":`, err instanceof Error ? err.message : err);
-                    continue;
-                }
-                if (next === current)
-                    continue;
-                try {
-                    await super.writeFile(p, next);
-                    touched.push(p);
-                    landedSeeds.set(p, { current, existedBefore });
-                }
-                catch (err) {
-                    // The write itself threw — it may have died MID-WRITE, leaving
-                    // partial bytes on disk. Left alone, those bytes would ride the
-                    // path's release (or the next save) as if they were real content.
-                    // Restore the pre-image we read under this very lock: on success
-                    // the path is byte-identical to before the batch and releases as
-                    // merely-locked; only when even the restore fails does the path
-                    // join the discard set (reset to HEAD on release — fail-closed,
-                    // partial bytes must never land). Residual risk, documented: in
-                    // that double-failure case a prior save's still-queued dirty bytes
-                    // on this path are lost to the discard — accepted, because the
-                    // alternative is committing known-corrupt bytes under their name.
-                    console.warn(`[locking-fs] creator access.md seed failed for "${p}":`, err instanceof Error ? err.message : err);
-                    let restored = false;
-                    try {
-                        if (existedBefore) {
-                            await super.writeFile(p, current);
-                            restored = true;
-                        }
-                        else if (absolute) {
-                            // Didn't exist before — remove whatever the failed write left.
-                            await fs.rm(absolute, { force: true });
-                            restored = true;
-                        }
-                    }
-                    catch {
-                        // Fall through to the discard set.
-                    }
-                    if (!restored) {
-                        failedSeedDiscards.add(p);
-                        console.warn(`[locking-fs] could not restore pre-seed bytes for "${p}" — releasing with discard`);
-                    }
-                }
-            }
-            // Scope the commit to this batch's own paths (caller paths + landed
-            // seeds): on the shared per-branch workspace another save's bytes may be
-            // dirty with their commit still queued, and an unscoped commit would
-            // sweep them in under this batch's author/summary.
-            change = await workflow.commitChanges(workspaceId, user, summary, touched);
-            if (seeds.size > 0)
-                this.lockContext.creatorAccess?.noteAccessFileWritten(workspaceId);
-        }
-        catch (err) {
-            if (err instanceof PushNeedsAgentResolutionError) {
-                // POST-commit failure: the commit LANDED and only the push needs help
-                // (thrown "with the commit intact"). Routing this through the discard
-                // release would strand the landed commit with nothing to retry the
-                // push — the next identical write no-ops against the committed bytes
-                // and the change stays unpublished forever. Release the batch's OWN
-                // committed paths WITH commit-on-release instead (the same posture
-                // AdminLockedCommits takes): each enqueued release commit no-ops on
-                // the clean tree, and the pending-commits worker then notices the
-                // unpushed commits and re-runs the cooperative push ladder. Merely-
-                // locked paths still release untouched — arming the retry never
-                // justifies re-attributing someone else's queued row (see
-                // releaseAll), and `touched` is never empty here (the commit that
-                // just landed had to have paths in scope).
-                const committed = new Set(touched);
-                await releaseAll((p) => committed.has(p) ? 'enqueue' : failedSeedDiscards.has(p) ? 'discard' : 'untouched');
-                throw err;
-            }
-            // A write or the commit threw — nothing of THIS batch should land.
-            // Landed seed bytes are uncommitted now too: roll each back to the
-            // pre-image read under its lock (which may be a prior save's queued
-            // bytes — a discard to HEAD would destroy those), and only a seed
-            // whose rollback ALSO fails joins the discard set, same fail-closed
-            // posture as a failed seed write.
-            for (const [p, pre] of landedSeeds) {
-                try {
-                    if (pre.existedBefore) {
-                        await super.writeFile(p, pre.current);
-                    }
-                    else {
-                        const absolute = this.resolveAbsolutePath(p);
-                        if (absolute)
-                            await fs.rm(absolute, { force: true });
-                    }
-                }
-                catch {
-                    failedSeedDiscards.add(p);
-                    console.warn(`[locking-fs] could not roll back seed bytes for "${p}" after a failed batch — releasing with discard`);
-                }
-            }
-            // The batch's own dirtied paths (and any failed-restore seed) release
-            // no-commit (the discard reverts them). Merely-locked paths — rolled-
-            // back seeds included — release untouched (see releaseAll).
-            await releaseAll((p) => dirtied.has(p) || failedSeedDiscards.has(p) ? 'discard' : 'untouched');
-            throw err;
-        }
-        // Commit already landed synchronously — the `touched` paths are clean
-        // (nothing to discard, nothing to enqueue), so they release no-commit
-        // like the batch's other own-bytes paths; the discard no-ops on the
-        // clean tree, and a failed-restore seed's discard reverts its partial
-        // bytes. A seed lock whose write no-op'd (or fully restored itself)
-        // releases untouched: it was never this batch's to discard OR enqueue.
-        const committed = new Set(touched);
-        await releaseAll((p) => committed.has(p) || failedSeedDiscards.has(p) ? 'discard' : 'untouched');
-        // This batch path commits via `commitChanges`, NOT the per-file queue, so it
-        // skips `runPendingCommit`'s emit — fire the post-commit hook here with the
-        // WHOLE batch as one event, so an expensive subscriber (id-repair rebuilds the
-        // id index) reacts once per batch, not once per file. A no-op commit (clean
-        // tree) changed nothing, so it emits nothing.
-        if (change) {
-            // `touched` = caller paths + any creator-grant seeds that landed in the
-            // same commit — the exact set this batch may have touched.
-            this.lockContext.fileChanges?.emit({ workspaceId, branch, paths: touched, byUser: user });
-        }
-        return change;
-    }
-    async mkdir(inputPath, options) {
-        // Creator read grant: planned BEFORE the dir exists (the plan's
-        // new-directory detection needs the pre-creation tree), seeded right
-        // after — so the new folder's access.md names the acting user under
-        // `read:` before anything else lands in it. Seeding also makes the dir
-        // non-empty, so the .gitkeep below is skipped when the seed targets this
-        // very dir (a deeper mkdir under a seeded ancestor still gets one).
-        const plan = await this.planCreate(inputPath, 'dir');
-        // mkdir itself is not a lockable op (it touches no file content), so we
-        // do the bare super-call without acquiring. The lock + commit happens on
-        // the `.gitkeep` write below — that's the file the workflow change
-        // attaches to. If the dir already has content (rare; e.g. recursive
-        // create where a sibling already exists), we skip the .gitkeep — empty-
-        // folder placeholders are only useful for actually-empty folders.
-        await super.mkdir(inputPath, options);
-        if (plan?.kind === 'seed-access-md')
-            await this.seedAccessMd(plan);
-        const absolutePath = this.resolveAbsolutePath(inputPath);
-        if (!absolutePath)
-            return;
-        let entries;
-        try {
-            entries = await fs.readdir(absolutePath);
-        }
-        catch {
-            // Read-back failed (raced delete? permissions?). Skip the .gitkeep —
-            // recovering here is more complex than the value gained.
-            return;
-        }
-        if (entries.length === 0) {
-            const gitkeepPath = inputPath.endsWith('/')
-                ? `${inputPath}.gitkeep`
-                : `${inputPath}/.gitkeep`;
-            // The .gitkeep write goes through our own lock-aware writeFile, so
-            // the change is committed + pushed on release exactly like any
-            // other agent edit.
-            await this.writeFile(gitkeepPath, '');
-        }
-    }
-    async rmdir(_inputPath, _options) {
-        // Recursive directory removal would commit N file deletions in one
-        // change — violates the one-change-per-file invariant. Force the
-        // caller to delete files one at a time; each `deleteFile` lands as
-        // its own change. The empty parent directory disappears with the
-        // last file (git doesn't track empty folders).
-        throw new Error('Recursive directory removal is not supported through the lock-aware filesystem. ' +
-            'Delete files individually so each removal lands as its own change.');
-    }
-    /**
-     * Land a `seed-access-md` creation-grant plan: under the access.md's own
-     * lock (single acquire+release cycle → one commit), re-read the CURRENT
-     * bytes and splice the grant into them — never a blind overwrite, so a
-     * concurrent creator's just-landed grant on the same new directory
-     * survives. Best-effort by contract: a contended lock, read, write, or
-     * release failure here logs and returns — it must never fail the creation
-     * that triggered the seed.
-     */
-    async seedAccessMd(plan) {
-        try {
-            await this.withLock(plan.wsRelPath, async () => {
-                let current = '';
-                const absolute = this.resolveAbsolutePath(plan.wsRelPath);
-                if (absolute) {
-                    try {
-                        current = await fs.readFile(absolute, 'utf-8');
-                    }
-                    catch {
-                        // Not there yet — the normal case for a brand-new directory.
-                    }
-                }
-                const next = plan.apply(current);
-                if (next !== current)
-                    await super.writeFile(plan.wsRelPath, next);
-            });
-            this.lockContext.creatorAccess?.noteAccessFileWritten(this.lockContext.workspaceId);
-        }
-        catch (err) {
-            console.warn(`[locking-fs] creator access.md seed failed for "${plan.wsRelPath}":`, err instanceof Error ? err.message : err);
-        }
-    }
-    /**
-     * Plan the creator read grant for a pending creation at `inputPath`
-     * (workspace-relative, same shape every override receives). Null when no
-     * planner is wired, the path isn't a grantable KB creation, or planning
-     * fails — the grant is best-effort UX and must never block the write.
-     */
-    async planCreate(inputPath, kind) {
-        const { creatorAccess, workspaceId, user } = this.lockContext;
-        if (!creatorAccess)
-            return null;
-        try {
-            return await creatorAccess.planForCreate(workspaceId, user, inputPath, kind);
-        }
-        catch (err) {
-            console.warn(`[locking-fs] creator read-grant planning failed for "${inputPath}":`, err instanceof Error ? err.message : err);
-            return null;
-        }
-    }
-    /**
-     * Acquire the lock, run `op`, release. The release does the commit +
-     * push via `WorkflowService.releaseLock`. On contention we retry a few
-     * times before surfacing a structured failure — long enough to ride
-     * out a human typing a quick edit, short enough that the agent doesn't
-     * stall a whole turn waiting for someone to step away from a file.
-     */
-    async withLock(inputPath, op) {
-        const { workflow, workspaceId, branch, user } = this.lockContext;
-        let lastHolderName = null;
-        let acquired = false;
-        for (let attempt = 0; attempt < ACQUIRE_RETRY_ATTEMPTS; attempt++) {
-            const result = await workflow.acquireLock(workspaceId, branch, inputPath, user);
-            if (result.acquired) {
-                acquired = true;
-                break;
-            }
-            lastHolderName = result.lock.holderName;
-            if (attempt < ACQUIRE_RETRY_ATTEMPTS - 1) {
-                await sleep(ACQUIRE_RETRY_DELAY_MS);
-            }
-        }
-        if (!acquired) {
-            throw new Error(`Skipped editing "${inputPath}" — locked by ${lastHolderName ?? 'another user'}. ` +
-                `Continuing with other edits; try this one again later.`);
-        }
-        let result;
-        try {
-            result = await op();
-        }
-        catch (err) {
-            // Op failed — drop the lock without committing, so a partial write
-            // before the throw doesn't accidentally land as a committed change
-            // (the normal `releaseLock` would `commitFile` whatever's on disk
-            // for `inputPath`, including the partial state). Best-effort: a
-            // failure to release here surfaces in logs but doesn't override
-            // the original op error the caller actually cares about.
-            try {
-                await workflow.releaseLockNoCommit(workspaceId, branch, inputPath, user);
-            }
-            catch (releaseErr) {
-                console.warn(`[locking-fs] releaseLockNoCommit failed for "${inputPath}" after op error:`, releaseErr instanceof Error ? releaseErr.message : releaseErr);
-            }
-            throw err;
-        }
-        // Op succeeded — release. Under the pending-commits queue the release
-        // just drops the lock and enqueues a commit; the worker handles the
-        // actual `commitFile + push` out of band. The agent's tool call
-        // returns once disk + lock + enqueue are done — the commit lands
-        // moments later (typically <1s) without blocking the agent's turn.
-        await workflow.releaseLock(workspaceId, branch, inputPath, user);
-        return result;
-    }
-}
-function sleep(ms) {
-    return new Promise((resolve) => setTimeout(resolve, ms));
-}
-//# sourceMappingURL=locking-filesystem.js.map

package/dist/modules/workflow/locking-filesystem.js.map

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

package/dist/modules/workflow/read-only-filesystem.d.ts

@@ -1,24 +0,0 @@
-import { LocalFilesystem, type CopyOptions, type FileContent, type RemoveOptions, type WriteOptions } from '@mastra/core/workspace';
-/**
- * A `LocalFilesystem` that permits reads but refuses every mutating operation.
- * Mastra hands the agent the workspace filesystem's tools (write_file /
- * edit_file / delete / mkdir / move / copy); for consumer personas we hand it
- * this instead so those tools exist but fail closed — the agent can read and
- * explore the ontology, but cannot change it.
- *
- * The architect agent keeps the lock-aware `LockingFilesystem` (which commits +
- * pushes); consumer agents get no write path at all.
- */
-export declare class ReadOnlyFilesystem extends LocalFilesystem {
-    private static deny;
-    writeFile(_path: string, _content: FileContent, _options?: WriteOptions): Promise<void>;
-    appendFile(_path: string, _content: FileContent): Promise<void>;
-    deleteFile(_path: string, _options?: RemoveOptions): Promise<void>;
-    copyFile(_src: string, _dest: string, _options?: CopyOptions): Promise<void>;
-    moveFile(_src: string, _dest: string, _options?: CopyOptions): Promise<void>;
-    mkdir(_path: string, _options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    rmdir(_path: string, _options?: RemoveOptions): Promise<void>;
-}
-//# sourceMappingURL=read-only-filesystem.d.ts.map

package/dist/modules/workflow/read-only-filesystem.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"read-only-filesystem.d.ts","sourceRoot":"","sources":["../../../src/modules/workflow/read-only-filesystem.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,KAAK,WAAW,EAChB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,YAAY,EAClB,MAAM,wBAAwB,CAAC;AAEhC;;;;;;;;;GASG;AACH,qBAAa,kBAAmB,SAAQ,eAAe;IACrD,OAAO,CAAC,MAAM,CAAC,IAAI;IAOJ,SAAS,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,EAAE,QAAQ,CAAC,EAAE,YAAY,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvF,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAI/D,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;IAIlE,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5E,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,IAAI,CAAC;IAI5E,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE;QAAE,SAAS,CAAC,EAAE,OAAO,CAAA;KAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAIvE,KAAK,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,IAAI,CAAC;CAG7E"}

package/dist/modules/workflow/read-only-filesystem.js

@@ -1,39 +0,0 @@
-import { LocalFilesystem, } from '@mastra/core/workspace';
-/**
- * A `LocalFilesystem` that permits reads but refuses every mutating operation.
- * Mastra hands the agent the workspace filesystem's tools (write_file /
- * edit_file / delete / mkdir / move / copy); for consumer personas we hand it
- * this instead so those tools exist but fail closed — the agent can read and
- * explore the ontology, but cannot change it.
- *
- * The architect agent keeps the lock-aware `LockingFilesystem` (which commits +
- * pushes); consumer agents get no write path at all.
- */
-export class ReadOnlyFilesystem extends LocalFilesystem {
-    static deny(op) {
-        throw new Error(`This assistant is read-only — "${op}" is not allowed. ` +
-            `It can read and analyze the knowledge base, but cannot modify it.`);
-    }
-    async writeFile(_path, _content, _options) {
-        ReadOnlyFilesystem.deny('write_file');
-    }
-    async appendFile(_path, _content) {
-        ReadOnlyFilesystem.deny('append_file');
-    }
-    async deleteFile(_path, _options) {
-        ReadOnlyFilesystem.deny('delete_file');
-    }
-    async copyFile(_src, _dest, _options) {
-        ReadOnlyFilesystem.deny('copy_file');
-    }
-    async moveFile(_src, _dest, _options) {
-        ReadOnlyFilesystem.deny('move_file');
-    }
-    async mkdir(_path, _options) {
-        ReadOnlyFilesystem.deny('mkdir');
-    }
-    async rmdir(_path, _options) {
-        ReadOnlyFilesystem.deny('rmdir');
-    }
-}
-//# sourceMappingURL=read-only-filesystem.js.map