mtech-ai-local-runner 0.1.73 → 0.1.75

package/dist/src/workspace/registered-submodules.js

@@ -0,0 +1,204 @@
+import { constants } from 'node:fs';
+import { lstat, mkdir, open, readdir, realpath, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createHash } from 'node:crypto';
+const CONFIG = '[core]\n\trepositoryformatversion = 0\n\tfilemode = true\n\tbare = true\n';
+const LIMIT = 16;
+function validPath(path) { return path.length <= 200 && path.split('/').length <= 8 && path.split('/').every(part => /^[A-Za-z0-9][A-Za-z0-9._-]*$/.test(part) && !['private', 'env'].includes(part.toLowerCase())); }
+function fail() { throw Error('Registered submodule ownership or pin mismatch'); }
+async function readPlainMetadata(file, limit) {
+    const named = await lstat(file);
+    if (!named.isFile() || named.isSymbolicLink() || named.nlink !== 1 || named.size > limit || await realpath(file) !== file || (process.getuid && named.uid !== process.getuid()))
+        fail();
+    const handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+    try {
+        const before = await handle.stat();
+        if (!before.isFile() || before.nlink !== 1 || before.ino !== named.ino || before.dev !== named.dev || before.size !== named.size)
+            fail();
+        const bytes = Buffer.alloc(limit + 1), read = await handle.read(bytes, 0, bytes.length, 0), [after, current] = await Promise.all([handle.stat(), lstat(file)]);
+        if (read.bytesRead !== before.size || read.bytesRead > limit || [after, current].some(stat => !stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.ino !== before.ino || stat.dev !== before.dev || stat.size !== before.size || stat.mtimeMs !== before.mtimeMs || stat.ctimeMs !== before.ctimeMs))
+            fail();
+        return bytes.subarray(0, read.bytesRead).toString('utf8');
+    }
+    finally {
+        await handle.close();
+    }
+}
+/** Eight independent paths at a time; all entries still receive the same ownership checks. */
+async function assertOwnedTree(root, allowObjectHardlinks = false) {
+    const pending = [root];
+    let entries = 1;
+    while (pending.length) {
+        const children = await Promise.all(pending.splice(0, 8).map(async (path) => {
+            const stat = await lstat(path);
+            if (stat.isSymbolicLink() || (process.getuid && stat.uid !== process.getuid()) || await realpath(path) !== path)
+                fail();
+            if (stat.isDirectory())
+                return (await readdir(path)).map(name => join(path, name));
+            if (!stat.isFile() || (!allowObjectHardlinks && stat.nlink !== 1))
+                fail();
+            return [];
+        }));
+        for (const paths of children) {
+            entries += paths.length;
+            if (entries > 10000)
+                fail();
+            pending.push(...paths);
+        }
+    }
+}
+/** Object lookup must stay inside the owned store for every later consumer too. */
+export async function assertOwnedGitObjectStorage(mirror) {
+    const present = async (path) => { try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    } };
+    for (const path of [mirror, join(mirror, 'objects'), join(mirror, 'objects/info'), join(mirror, 'refs')]) {
+        const stat = await lstat(path);
+        if (!stat.isDirectory() || stat.isSymbolicLink() || (process.getuid && stat.uid !== process.getuid()) || await realpath(path) !== path)
+            fail();
+    }
+    // Local mirror clones can hardlink immutable objects; metadata never may be hardlinked.
+    await assertOwnedTree(join(mirror, 'objects'), true);
+    // A bare mirror has no common-directory redirect; linked worktree records are validated separately.
+    for (const path of [join(mirror, 'commondir'), join(mirror, 'objects/info/alternates'), join(mirror, 'objects/info/http-alternates'), join(mirror, 'refs/replace')])
+        if (await present(path))
+            fail();
+    const packed = join(mirror, 'packed-refs');
+    if (await present(packed)) {
+        if (/(^|\n)[^\n]*[ \t]refs\/replace(?:\/|[\r\n]|$)/.test(await readPlainMetadata(packed, 1024 * 1024)))
+            fail();
+    }
+}
+export class RegisteredSubmoduleMaterializer {
+    client;
+    profiles;
+    constructor(client, profiles) {
+        this.client = client;
+        if (profiles.length > 32)
+            fail();
+        const scopes = new Set();
+        this.profiles = Object.freeze(profiles.map(profile => {
+            const scope = profile.repositoryKey + ':' + profile.contractBaseCommitSha;
+            if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/.test(profile.repositoryKey) || !(/^[a-f0-9]{40}$/).test(profile.contractBaseCommitSha) || scopes.has(scope) || profile.submodules.length > LIMIT)
+                fail();
+            scopes.add(scope);
+            const paths = [];
+            const submodules = profile.submodules.map(item => {
+                if (!validPath(item.path) || paths.some(path => path === item.path || path.startsWith(item.path + '/') || item.path.startsWith(path + '/')))
+                    fail();
+                paths.push(item.path);
+                // Exact, trusted provider coordinates only; Git helper/ext protocols are forbidden.
+                if (item.providerUrl.length > 2048 || /[?#]/.test(item.providerUrl) || !(/^(https:\/\/[^\s]+|ssh:\/\/[^\s]+|git@[A-Za-z0-9.-]+:[A-Za-z0-9_./-]+|\/[^\0\r\n]+)$/).test(item.providerUrl) || item.providerUrl.includes('/../'))
+                    fail();
+                if (item.providerUrl.startsWith('https:') || item.providerUrl.startsWith('ssh:')) {
+                    const url = new URL(item.providerUrl);
+                    if (url.username || url.password || !url.hostname)
+                        fail();
+                }
+                return Object.freeze({ ...item });
+            });
+            return Object.freeze({ ...profile, submodules: Object.freeze(submodules) });
+        }));
+    }
+    pins(output) {
+        if (output.length > 1024 * 1024)
+            fail();
+        const result = new Map();
+        let count = 0;
+        for (const entry of output.split('\0').filter(Boolean)) {
+            if (++count > 10000)
+                fail();
+            const match = /^(\d{6}) (blob|tree|commit) ([a-f0-9]{40})\t(.+)$/.exec(entry);
+            if (!match)
+                fail();
+            if (match[1] === '160000') {
+                if (match[2] !== 'commit' || !validPath(match[4]) || result.size >= LIMIT)
+                    fail();
+                if (result.has(match[4]))
+                    fail();
+                result.set(match[4], match[3]);
+            }
+        }
+        return result;
+    }
+    async directory(path) { const stat = await lstat(path); if (!stat.isDirectory() || stat.isSymbolicLink() || await realpath(path) !== path || (process.getuid && stat.uid !== process.getuid()))
+        fail(); }
+    async present(path) { try {
+        await lstat(path);
+        return true;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return false;
+        throw error;
+    } }
+    /** Validate the complete owned mirror tree before Git can follow refs/config/object redirects. */
+    async mirror(path) {
+        await assertOwnedTree(path);
+        await assertOwnedGitObjectStorage(path);
+        if (await readPlainMetadata(join(path, 'config'), Buffer.byteLength(CONFIG)) !== CONFIG)
+            fail();
+    }
+    async materialize(input) {
+        const pins = this.pins((await input.git(['--no-replace-objects', 'ls-tree', '-rz', '--full-tree', input.parent])).stdout);
+        const rootPins = input.contractBase === input.parent ? pins : this.pins((await input.git(['--no-replace-objects', 'ls-tree', '-rz', '--full-tree', input.contractBase])).stdout);
+        const profile = this.profiles.find(p => p.repositoryKey === input.repositoryKey && p.contractBaseCommitSha === input.contractBase);
+        const allowed = profile?.submodules ?? [];
+        if (rootPins.size !== pins.size || pins.size !== allowed.length || allowed.some(item => !rootPins.has(item.path) || !pins.has(item.path)))
+            fail();
+        if (pins.size === 0)
+            return;
+        const namespace = join(input.root, 'submodule-mirrors');
+        if (!await this.present(namespace))
+            await mkdir(namespace, { mode: 0o700 });
+        await this.directory(namespace);
+        for (const item of allowed) {
+            const sha = pins.get(item.path);
+            // Identity includes workspace and context, preventing other generations/jobs from donating metadata.
+            const key = createHash('sha256').update(JSON.stringify([input.repositoryKey, input.contractBase, input.workspace, input.contextFingerprint, item.path, item.providerUrl])).digest('hex');
+            const mirror = join(namespace, key + '.git'), checkout = join(input.workspace, item.path);
+            const config = ['--no-replace-objects', '-c', 'core.hooksPath=/dev/null', '-c', 'core.fsmonitor=false', '-c', 'submodule.recurse=false', '-c', 'protocol.allow=never', '-c', `protocol.${item.providerUrl.startsWith('/') ? 'file' : item.providerUrl.startsWith('https:') ? 'https' : 'ssh'}.allow=always`];
+            const run = async (args) => { await this.mirror(mirror); return this.client.run([...config, '--git-dir', mirror, ...args]); };
+            // Refuse every existing path component redirect before accessing the checkout.
+            let current = input.workspace;
+            for (const part of item.path.split('/')) {
+                current = join(current, part);
+                if (await this.present(current))
+                    await this.directory(current);
+                else
+                    await mkdir(current, { mode: 0o700 });
+            }
+            if (await this.present(join(checkout, '.git'))) {
+                await this.mirror(mirror);
+                await input.assertMetadata(checkout, mirror);
+            }
+            else {
+                if ((await readdir(checkout)).length)
+                    fail();
+                if (!await this.present(mirror)) {
+                    await this.client.run([...config, 'init', '--bare', '--template=', mirror]);
+                    await writeFile(join(mirror, 'config'), CONFIG, { mode: 0o600 });
+                }
+                await run(['fetch', '--no-tags', '--depth=1', item.providerUrl, sha]);
+                await run(['cat-file', '-e', `${sha}^{commit}`]);
+                // Nested submodules have no registration authority in this profile version.
+                if (this.pins((await run(['ls-tree', '-rz', '--full-tree', sha])).stdout).size)
+                    fail();
+                await run(['worktree', 'add', '--detach', checkout, sha]);
+            }
+            const checkoutGit = async (args) => { await this.mirror(mirror); await input.assertMetadata(checkout, mirror); return this.client.run([...config, '-C', checkout, ...args]); };
+            if ((await checkoutGit(['rev-parse', 'HEAD'])).stdout.trim() !== sha)
+                fail();
+            if (this.pins((await checkoutGit(['ls-tree', '-rz', '--full-tree', sha])).stdout).size)
+                fail();
+            if ((await checkoutGit(['status', '--porcelain', '--untracked-files=all'])).stdout !== '')
+                fail();
+        }
+    }
+}

package/dist/src/workspace/workspace-manager.js

@@ -1,13 +1,39 @@
-import { access, mkdir, realpath, rename, writeFile } from "node:fs/promises";
-import { createHash } from "node:crypto";
-import { resolve, join, sep } from "node:path";
+import { validateAttemptContext, attemptContextFingerprint } from '../verification/continuation-runner-contract.js';
+import { access, lstat, mkdir, open, readFile, realpath, rename, writeFile } from "node:fs/promises";
+import { constants } from 'node:fs';
+import { createHash, randomUUID } from "node:crypto";
+import { resolve, join, sep, dirname } from "node:path";
+import { assertOwnedGitObjectStorage, RegisteredSubmoduleMaterializer } from './registered-submodules.js';
 import { isP1WorkingBranch } from '../publication/git-snapshot.js';
 export class WorkspaceManager {
     deps;
+    submodules;
     constructor(deps) {
         this.deps = deps;
+        this.submodules = new RegisteredSubmoduleMaterializer(deps.git, deps.registeredSubmodules ?? []);
     }
     async create(input) {
+        input = { ...input };
+        if (input.attemptContext !== undefined || input.attemptContextFingerprint !== undefined) {
+            try {
+                return await this.createManaged(input);
+            }
+            catch {
+                throw new Error('CORRECTION_PARENT_UNAVAILABLE');
+            }
+        }
+        return this.createManaged(input);
+    }
+    async createManaged(input) {
+        const attempt = input.attemptContext === undefined ? undefined : validateAttemptContext(input.attemptContext);
+        if ((input.attemptContextFingerprint !== undefined) !== (attempt !== undefined))
+            throw Error('Invalid attempt context');
+        if (attempt && (input.attemptContextFingerprint !== attemptContextFingerprint(attempt) || input.jobId !== attempt.job_id || input.repositoryKey !== attempt.repository_key || input.baseCommitSha !== attempt.contract_base_commit_sha || input.workingBranch !== attempt.attempt_working_branch || input.p1WorkingBranch !== attempt.attempt_working_branch))
+            throw Error('Attempt identity mismatch');
+        const approvedBase = input.baseCommitSha;
+        if (attempt)
+            input = { ...input, baseCommitSha: attempt.attempt_base_commit_sha };
+        const workspaceKey = attempt ? `${input.jobId}.g${attempt.generation}` : input.jobId;
         if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,190}$/.test(input.jobId))
             throw new Error("Invalid job ID for managed workspace");
         if (!/^[a-zA-Z0-9][a-zA-Z0-9._-]{0,127}$/.test(input.repositoryKey))
@@ -23,48 +49,86 @@ export class WorkspaceManager {
         const mirrorsRoot = join(root, "mirrors");
         const jobsRoot = join(root, "jobs");
         const mirrorPath = join(mirrorsRoot, `${input.repositoryKey}.git`);
-        const workspacePath = join(jobsRoot, input.jobId);
+        const workspacePath = join(jobsRoot, workspaceKey);
         this.assertContained(root, mirrorPath);
         this.assertContained(root, workspacePath);
         await mkdir(mirrorsRoot, { recursive: true, mode: 0o700 });
         await mkdir(jobsRoot, { recursive: true, mode: 0o700 });
+        if (attempt && (await realpath(mirrorsRoot) !== mirrorsRoot || await realpath(jobsRoot) !== jobsRoot))
+            throw Error('Workspace ownership mismatch');
+        if (attempt)
+            for (const owned of [mirrorPath, workspacePath]) {
+                try {
+                    const stat = await lstat(owned);
+                    if (!stat.isDirectory() || stat.isSymbolicLink() || await realpath(owned) !== owned)
+                        throw Error('Workspace ownership mismatch');
+                }
+                catch (error) {
+                    if (error.code !== 'ENOENT')
+                        throw error;
+                }
+            }
+        const manifestPath = join(jobsRoot, `${workspaceKey}.manifest.json`);
+        let priorManifest;
+        if (attempt && (await this.exists(workspacePath) || await this.exists(manifestPath))) {
+            const stat = await lstat(manifestPath);
+            if (!stat.isFile() || stat.nlink !== 1 || stat.isSymbolicLink() || await realpath(manifestPath) !== manifestPath)
+                throw Error('Manifest ownership mismatch');
+            priorManifest = JSON.parse(await readFile(manifestPath, 'utf8'));
+            if (priorManifest.jobId !== input.jobId || priorManifest.generation !== attempt.generation || priorManifest.attemptContextFingerprint !== input.attemptContextFingerprint || priorManifest.contractBaseCommitSha !== approvedBase || priorManifest.baseCommitSha !== input.baseCommitSha || priorManifest.repositoryKey !== input.repositoryKey || priorManifest.remoteFingerprint !== createHash('sha256').update(input.providerUrl).digest('hex') || priorManifest.retentionState !== 'active' || typeof priorManifest.createdAt !== 'string' || !Number.isFinite(Date.parse(priorManifest.createdAt)))
+                throw Error('Manifest identity mismatch');
+        }
+        const managedGit = async (args) => {
+            if (attempt && args[0] === '--git-dir')
+                await assertOwnedGitObjectStorage(mirrorPath);
+            return this.deps.git.run([...(attempt ? ['--no-replace-objects'] : []), ...args]);
+        };
         if (await this.exists(mirrorPath)) {
-            const remote = (await this.deps.git.run(["--git-dir", mirrorPath, "remote", "get-url", "origin"])).stdout.trim();
+            const remote = (await managedGit(["--git-dir", mirrorPath, "remote", "get-url", "origin"])).stdout.trim();
             if (remote !== input.providerUrl)
                 throw new Error("Managed repository remote does not match the registered provider");
         }
         else {
-            await this.deps.git.run(["clone", "--mirror", input.providerUrl, mirrorPath]);
+            await managedGit(["clone", "--mirror", input.providerUrl, mirrorPath]);
         }
         try {
-            await this.deps.git.run(["--git-dir", mirrorPath, "fetch", "--prune", "origin", input.baseCommitSha]);
-            await this.deps.git.run(["--git-dir", mirrorPath, "cat-file", "-e", `${input.baseCommitSha}^{commit}`]);
+            await managedGit(["--git-dir", mirrorPath, "fetch", "--prune", "origin", input.baseCommitSha]);
+            await managedGit(["--git-dir", mirrorPath, "cat-file", "-e", `${input.baseCommitSha}^{commit}`]);
         }
         catch {
             throw new Error(`Repository revision ${input.baseCommitSha} is unavailable`);
         }
         if (!await this.exists(workspacePath)) {
-            await this.deps.git.run(["--git-dir", mirrorPath, "worktree", "add", "--detach", workspacePath, input.baseCommitSha]);
+            await managedGit(["--git-dir", mirrorPath, "worktree", "add", "--detach", workspacePath, input.baseCommitSha]);
         }
         const actualPath = await realpath(workspacePath);
         this.assertContained(root, actualPath);
-        const head = (await this.deps.git.run(["-C", actualPath, "rev-parse", "HEAD"])).stdout.trim();
+        if (attempt && actualPath !== workspacePath)
+            throw Error('Workspace ownership mismatch');
+        const workspaceGit = async (args, noHooks = false) => {
+            if (attempt)
+                await this.assertAttemptGitMetadata(actualPath, mirrorPath);
+            return this.deps.git.run([...(attempt ? ['--no-replace-objects'] : []), ...(noHooks ? ['-c', 'core.hooksPath=/dev/null'] : []), '-C', actualPath, ...args]);
+        };
+        const head = (await workspaceGit(["rev-parse", "HEAD"])).stdout.trim();
         if (head !== input.baseCommitSha)
             throw new Error("Managed workspace HEAD differs from the approved revision");
-        const dirty = (await this.deps.git.run(["-C", actualPath, "status", "--porcelain"])).stdout;
+        if (attempt)
+            await this.submodules.materialize({ workspace: actualPath, root, repositoryKey: input.repositoryKey, contractBase: approvedBase, parent: input.baseCommitSha, contextFingerprint: input.attemptContextFingerprint, git: workspaceGit, assertMetadata: (path, mirror) => this.assertAttemptGitMetadata(path, mirror) });
+        const dirty = (await workspaceGit(["status", "--porcelain"])).stdout;
         if (dirty !== "")
             throw new Error("Managed workspace is dirty before execution");
         if (input.workingBranch) {
             const ref = `refs/heads/${input.workingBranch}`;
-            const current = (await this.deps.git.run(['-C', actualPath, 'rev-parse', '--abbrev-ref', 'HEAD'])).stdout.trim();
+            const current = (await workspaceGit(['rev-parse', '--abbrev-ref', 'HEAD'])).stdout.trim();
             if (current !== 'HEAD' && current !== input.workingBranch)
                 throw new Error('Managed fix branch differs from approval');
-            const existing = (await this.deps.git.run(['-C', actualPath, 'for-each-ref', '--format=%(objectname)', ref])).stdout.trim();
+            const existing = (await workspaceGit(['for-each-ref', '--format=%(objectname)', ref])).stdout.trim();
             if (existing && existing !== input.baseCommitSha)
                 throw new Error('Managed fix branch revision differs from approval');
             if (!existing)
-                await this.deps.git.run(['-c', 'core.hooksPath=/dev/null', '-C', actualPath, 'update-ref', ref, input.baseCommitSha, '0'.repeat(40)]);
-            await this.deps.git.run(['-c', 'core.hooksPath=/dev/null', '-C', actualPath, 'symbolic-ref', 'HEAD', ref]);
+                await workspaceGit(['update-ref', ref, input.baseCommitSha, '0'.repeat(40)], true);
+            await workspaceGit(['symbolic-ref', 'HEAD', ref], true);
         }
         const manifest = {
             jobId: input.jobId,
@@ -73,13 +137,59 @@ export class WorkspaceManager {
             baseCommitSha: head,
             createdAt: new Date().toISOString(),
             retentionState: "active",
+            ...(attempt ? { generation: attempt.generation, contractBaseCommitSha: approvedBase, attemptContextFingerprint: input.attemptContextFingerprint } : {}),
         };
-        const manifestPath = join(jobsRoot, `${input.jobId}.manifest.json`);
-        const temporaryManifestPath = `${manifestPath}.${process.pid}.tmp`;
-        await writeFile(temporaryManifestPath, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
+        if (priorManifest)
+            manifest.createdAt = priorManifest.createdAt;
+        const temporaryManifestPath = `${manifestPath}.${attempt ? randomUUID() : process.pid}.tmp`;
+        await writeFile(temporaryManifestPath, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600, ...(attempt ? { flag: 'wx' } : {}) });
         await rename(temporaryManifestPath, manifestPath);
         return { path: actualPath, mirrorPath, baseCommitSha: head, manifest };
     }
+    /** Validate linked-worktree ownership using plain metadata before invoking Git in it.
+     * A .git file pointing at a same-SHA foreign repository must never authorize writes. */
+    async assertAttemptGitMetadata(workspacePath, mirrorPath) {
+        await assertOwnedGitObjectStorage(mirrorPath);
+        const dotGit = join(workspacePath, '.git');
+        const pointer = await this.readOwnedMetadata(dotGit);
+        const match = /^gitdir: ([^\r\n\0]+)\r?\n?$/.exec(pointer);
+        if (!match)
+            throw Error('Workspace metadata mismatch');
+        const gitDirectory = resolve(workspacePath, match[1]);
+        const metadataRoot = join(mirrorPath, 'worktrees');
+        // Constrain lexically first: never stat/read metadata in a caller-chosen repository.
+        if (dirname(gitDirectory) !== metadataRoot || gitDirectory === metadataRoot)
+            throw Error('Workspace metadata mismatch');
+        for (const directory of [mirrorPath, metadataRoot, gitDirectory]) {
+            const stat = await lstat(directory);
+            if (!stat.isDirectory() || stat.isSymbolicLink() || await realpath(directory) !== directory || (process.getuid && stat.uid !== process.getuid()))
+                throw Error('Workspace metadata mismatch');
+        }
+        const [common, backpointer] = await Promise.all([this.readOwnedMetadata(join(gitDirectory, 'commondir')), this.readOwnedMetadata(join(gitDirectory, 'gitdir')), this.readOwnedMetadata(join(gitDirectory, 'HEAD'))]);
+        const oneLine = (value) => { if (!/^[^\r\n\0]+\r?\n?$/.test(value))
+            throw Error('Workspace metadata mismatch'); return value.replace(/\r?\n$/, ''); };
+        if (resolve(gitDirectory, oneLine(common)) !== mirrorPath || resolve(gitDirectory, oneLine(backpointer)) !== dotGit)
+            throw Error('Workspace metadata mismatch');
+        // HEAD was checked alongside both pointers before this workspace may receive a Git command.
+    }
+    async readOwnedMetadata(file) {
+        const named = await lstat(file);
+        if (!named.isFile() || named.isSymbolicLink() || named.nlink !== 1 || named.size < 1 || named.size > 4096 || await realpath(file) !== file || (process.getuid && named.uid !== process.getuid()))
+            throw Error('Workspace metadata mismatch');
+        const handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW);
+        try {
+            const before = await handle.stat();
+            if (!before.isFile() || before.nlink !== 1 || before.ino !== named.ino || before.dev !== named.dev || before.size !== named.size)
+                throw Error('Workspace metadata mismatch');
+            const bytes = Buffer.alloc(4097), read = await handle.read(bytes, 0, bytes.length, 0), [after, current] = await Promise.all([handle.stat(), lstat(file)]);
+            if (read.bytesRead !== before.size || read.bytesRead > 4096 || [after, current].some(stat => !stat.isFile() || stat.isSymbolicLink() || stat.nlink !== 1 || stat.ino !== before.ino || stat.dev !== before.dev || stat.size !== before.size || stat.mtimeMs !== before.mtimeMs || stat.ctimeMs !== before.ctimeMs))
+                throw Error('Workspace metadata mismatch');
+            return bytes.subarray(0, read.bytesRead).toString('utf8');
+        }
+        finally {
+            await handle.close();
+        }
+    }
     assertContained(root, candidate) {
         const resolved = resolve(candidate);
         if (resolved !== root && !resolved.startsWith(`${root}${sep}`))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mtech-ai-local-runner",
-  "version": "0.1.73",
+  "version": "0.1.75",
   "private": false,
   "license": "UNLICENSED",
   "bin": {