@playcraft/cli 0.1.66 → 0.1.67

package/dist/workspace-runtime/server/directory-access.js

@@ -1,6 +1,6 @@
 import { AsyncLocalStorage } from 'node:async_hooks';
 import { randomUUID } from 'node:crypto';
-import { isTurnControl, takesWorkspaceDirectory, takesExecutionSlot, transitionOperation } from '@playcraft/common/cloud-workspace/runtime';
+import { isTurnControl, takesWorkspaceDirectory, takesExecutionSlot, transitionOperation, } from '@playcraft/common/cloud-workspace/runtime';
 import { listMembers, readSnapshot } from '../batch/records.js';
 const context = new AsyncLocalStorage();
 const gates = new WeakMap();
@@ -8,9 +8,21 @@ const instances = new WeakMap();
 const executing = new WeakMap();
 const freezing = new WeakMap();
 const TERMINAL = new Set(['completed', 'failed', 'interrupted']);
-const EXCLUSIVE_OPERATIONS = new Set(['preview.publish', 'model.preview', 'model.prepare', 'directory.create',
-    'directory.rename', 'directory.delete', 'workspace.references.import', 'skills.update', 'parameter.verify',
-    'checkpoint.create', 'checkpoint.restore']);
+const EXCLUSIVE_OPERATIONS = new Set([
+    'level-editor.transaction',
+    'preview.publish',
+    'model.preview',
+    'model.prepare',
+    'directory.create',
+    'directory.rename',
+    'directory.delete',
+    'workspace.references.import',
+    'skills.update',
+    'parameter.verify',
+    'level-editor.verify',
+    'checkpoint.create',
+    'checkpoint.restore',
+]);
 export function managedDirectoryScope(state, value) {
     if (state.config.workspaceMode !== 'multi')
         return { directoryName: 'basic' };
@@ -18,22 +30,51 @@ export function managedDirectoryScope(state, value) {
     return { workspaceId, directoryName };
 }
 function overlaps(a, b) {
-    return (a.workspaceId ?? '') === (b.workspaceId ?? '') &&
-        ((a.directoryName ?? 'basic') === (b.directoryName ?? 'basic') || a.directoryName === 'root' || b.directoryName === 'root');
+    return ((a.workspaceId ?? '') === (b.workspaceId ?? '') &&
+        ((a.directoryName ?? 'basic') === (b.directoryName ?? 'basic') ||
+            a.directoryName === 'root' ||
+            b.directoryName === 'root'));
 }
 function covers(parent, child) {
-    return (parent.workspaceId ?? '') === (child.workspaceId ?? '') &&
-        (parent.directoryName === 'root' || (parent.directoryName ?? 'basic') === (child.directoryName ?? 'basic'));
+    return ((parent.workspaceId ?? '') === (child.workspaceId ?? '') &&
+        (parent.directoryName === 'root' ||
+            (parent.directoryName ?? 'basic') === (child.directoryName ?? 'basic')));
+}
+// A terminal is an interactive channel, not an ordinary operation. Keep its lease for
+// captures and destructive directory maintenance, but do not serialize normal work behind it.
+function terminalIndependent(a, b) {
+    return ((a.owner.startsWith('terminal:') && b.terminalIndependent === true) ||
+        (b.owner.startsWith('terminal:') && a.terminalIndependent === true));
+}
+function operationTerminalIndependent(operation) {
+    return ![
+        'directory.rename',
+        'directory.delete',
+        'checkpoint.create',
+        'checkpoint.restore',
+        'preview.publish',
+    ].includes(operation.kind);
 }
 export function operationDirectoryMode(operation) {
-    return operation.directoryAccessMode ?? (EXCLUSIVE_OPERATIONS.has(operation.kind) || operation.kind.startsWith('git.') ? 'exclusive' : 'shared');
+    if (operation.kind === 'level-editor.transaction')
+        return 'exclusive';
+    return (operation.directoryAccessMode ??
+        (EXCLUSIVE_OPERATIONS.has(operation.kind) || operation.kind.startsWith('git.')
+            ? 'exclusive'
+            : 'shared'));
 }
 function activeSessionOwner(state, gate, scope, sessionId, except) {
     if (!sessionId)
         return undefined;
-    const operation = state.journal.listOperations().map(item => item.operation).find(item => item.sessionId === sessionId &&
-        item.operationId !== except && ['session.turn', 'session.review', 'session.compact'].includes(item.kind) &&
-        ['dispatched', 'accepted', 'uncertain'].includes(item.status) && covers(item, scope) && gate.has(`operation:${item.operationId}`));
+    const operation = state.journal
+        .listOperations()
+        .map((item) => item.operation)
+        .find((item) => item.sessionId === sessionId &&
+        item.operationId !== except &&
+        ['session.turn', 'session.review', 'session.compact'].includes(item.kind) &&
+        ['dispatched', 'accepted', 'uncertain'].includes(item.status) &&
+        covers(item, scope) &&
+        gate.has(`operation:${item.operationId}`));
     return operation ? `operation:${operation.operationId}` : undefined;
 }
 /** A directory has many ordinary writers, or one build, freeze, maintenance job or member Run. */
@@ -41,20 +82,20 @@ export class DirectoryAccessGate {
     normalize;
     held = new Map();
     pending = [];
-    constructor(normalize = claim => claim) {
+    constructor(normalize = (claim) => claim) {
         this.normalize = normalize;
     }
     claim(input) {
         const claim = this.normalize(input);
         const held = this.held.get(claim.owner);
         if (held) {
-            if (!covers(held, claim) || held.mode === 'shared' && claim.mode === 'exclusive')
+            if (!covers(held, claim) || (held.mode === 'shared' && claim.mode === 'exclusive'))
                 return Promise.reject(new Error('directory_access_upgrade_forbidden'));
             return Promise.resolve();
         }
-        const existing = this.pending.find(item => item.owner === claim.owner);
+        const existing = this.pending.find((item) => item.owner === claim.owner);
         if (existing) {
-            if (!covers(existing, claim) || existing.mode === 'shared' && claim.mode === 'exclusive')
+            if (!covers(existing, claim) || (existing.mode === 'shared' && claim.mode === 'exclusive'))
                 return Promise.reject(new Error('directory_access_upgrade_forbidden'));
             if (existing.paused && !claim.paused) {
                 existing.paused = false;
@@ -64,16 +105,25 @@ export class DirectoryAccessGate {
         }
         let resolve;
         let reject;
-        const ready = new Promise((done, fail) => { resolve = done; reject = fail; });
+        const ready = new Promise((done, fail) => {
+            resolve = done;
+            reject = fail;
+        });
         this.pending.push({ ...claim, ready, resolve, reject });
         this.drain();
         return ready;
     }
-    restore(claim) { this.held.set(claim.owner, this.normalize(claim)); }
-    has(owner) { return this.held.has(owner); }
+    restore(claim) {
+        this.held.set(claim.owner, this.normalize(claim));
+    }
+    has(owner) {
+        return this.held.has(owner);
+    }
     permits(owner, scope, mode) {
         const held = this.held.get(owner);
-        return Boolean(held && covers(held, this.normalize({ ...scope, owner, mode })) && (held.mode === 'exclusive' || mode === 'shared'));
+        return Boolean(held &&
+            covers(held, this.normalize({ ...scope, owner, mode })) &&
+            (held.mode === 'exclusive' || mode === 'shared'));
     }
     tryClaim(claim) {
         const ready = this.claim(claim);
@@ -84,7 +134,7 @@ export class DirectoryAccessGate {
         return false;
     }
     adopt(owner, parentOwner) {
-        const child = this.pending.find(item => item.owner === owner);
+        const child = this.pending.find((item) => item.owner === owner);
         const parent = this.held.get(parentOwner);
         if (!child || !parent || parent.mode !== 'exclusive' || !covers(parent, child))
             return;
@@ -92,21 +142,23 @@ export class DirectoryAccessGate {
         this.drain();
     }
     cancelPending(owner) {
-        if (this.held.has(owner) || !this.pending.some(item => item.owner === owner))
+        if (this.held.has(owner) || !this.pending.some((item) => item.owner === owner))
             return false;
         this.release(owner);
         return true;
     }
     release(owner) {
         this.held.delete(owner);
-        const pending = this.pending.find(item => item.owner === owner);
+        const pending = this.pending.find((item) => item.owner === owner);
         if (pending) {
             this.pending.splice(this.pending.indexOf(pending), 1);
             pending.reject(new Error('directory_access_cancelled'));
         }
         this.drain();
     }
-    owners() { return [...this.held.keys(), ...this.pending.map(item => item.owner)]; }
+    owners() {
+        return [...this.held.keys(), ...this.pending.map((item) => item.owner)];
+    }
     drain() {
         const earlier = [];
         for (const item of [...this.pending]) {
@@ -116,9 +168,26 @@ export class DirectoryAccessGate {
             }
             const parent = item.parentOwner ? this.held.get(item.parentOwner) : undefined;
             const family = parent && covers(parent, item) && (parent.mode === 'exclusive' || item.mode === 'shared');
-            const conflict = [...this.held.values()].some(held => !(family && (held.owner === parent.owner || held.parentOwner === parent.owner)) && overlaps(item, held) &&
-                (item.mode === 'exclusive' || held.mode === 'exclusive' || Boolean(item.sessionId && held.sessionId === item.sessionId)));
-            const queuedWriter = !family && earlier.some(prior => overlaps(item, prior) && (item.mode === 'exclusive' || prior.mode === 'exclusive'));
+            const conflict = [...this.held.values()].some((held) => !(family && (held.owner === parent.owner || held.parentOwner === parent.owner)) &&
+                overlaps(item, held) &&
+                !terminalIndependent(item, held) &&
+                (item.mode === 'exclusive' ||
+                    held.mode === 'exclusive' ||
+                    Boolean(item.sessionId && held.sessionId === item.sessionId)));
+            const queuedWriter = !family &&
+                earlier.some((prior) => {
+                    if (!overlaps(item, prior) ||
+                        terminalIndependent(item, prior) ||
+                        (item.mode !== 'exclusive' && prior.mode !== 'exclusive'))
+                        return false;
+                    // A capture waiting on an open terminal must not form a permanent queue barrier
+                    // for work that is allowed to run beside that terminal.
+                    if (item.terminalIndependent &&
+                        !prior.terminalIndependent &&
+                        [...this.held.values()].some((held) => held.owner.startsWith('terminal:') && overlaps(prior, held)))
+                        return false;
+                    return true;
+                });
             if (conflict || queuedWriter) {
                 earlier.push(item);
                 continue;
@@ -133,32 +202,48 @@ async function gateFor(state) {
     let pending = gates.get(state);
     if (!pending) {
         pending = (async () => {
-            const gate = new DirectoryAccessGate(claim => state.config.workspaceMode === 'multi'
-                ? claim : { ...claim, workspaceId: undefined, directoryName: 'basic' });
+            const gate = new DirectoryAccessGate((claim) => state.config.workspaceMode === 'multi'
+                ? claim
+                : { ...claim, workspaceId: undefined, directoryName: 'basic' });
             instances.set(state, gate);
             const members = await listMembers(state);
             for (const member of members)
                 if (member.holding)
                     gate.restore({ ...member, owner: `run:${member.runId}`, mode: 'exclusive' });
             for (const { operation } of state.journal.listOperations()) {
-                if (!takesWorkspaceDirectory(operation.kind) || isTurnControl(operation.kind) ||
+                if (!takesWorkspaceDirectory(operation.kind) ||
+                    isTurnControl(operation.kind) ||
                     !['dispatched', 'accepted', 'uncertain'].includes(operation.status) ||
-                    members.some(member => member.holding && (member.operationId === operation.operationId || Boolean(member.sessionId && member.sessionId === operation.sessionId))))
+                    members.some((member) => member.holding &&
+                        (member.operationId === operation.operationId ||
+                            Boolean(member.sessionId && member.sessionId === operation.sessionId))))
                     continue;
-                gate.restore({ ...operation, owner: `operation:${operation.operationId}`, mode: operationDirectoryMode(operation) });
+                gate.restore({
+                    ...operation,
+                    owner: `operation:${operation.operationId}`,
+                    mode: operationDirectoryMode(operation),
+                    terminalIndependent: operationTerminalIndependent(operation),
+                });
             }
             for (const terminal of state.journal.listTerminals())
                 if (terminal.status !== 'destroyed')
                     gate.restore({ ...terminal, owner: `terminal:${terminal.terminalId}`, mode: 'shared' });
             for (const writer of state.journal.listManagedWrites())
                 if (!writer.stoppedAt) {
-                    gate.restore({ ...managedDirectoryScope(state, writer.workspaceId), owner: `managed:${writer.writeId}`, mode: writer.directoryAccessMode ?? 'shared' });
+                    gate.restore({
+                        ...managedDirectoryScope(state, writer.workspaceId),
+                        owner: `managed:${writer.writeId}`,
+                        mode: writer.directoryAccessMode ?? 'shared',
+                        terminalIndependent: true,
+                    });
                 }
             const waiting = [];
             for (const barrier of state.journal.directoryBarriers()) {
                 const snapshot = barrier.owner.startsWith('freeze:')
-                    ? await readSnapshot(state, barrier.owner.slice('freeze:'.length)).catch(() => undefined) : undefined;
-                if (snapshot?.sourceWorkspaceId === barrier.workspaceId && snapshot.sourceDirectoryName === barrier.directoryName) {
+                    ? await readSnapshot(state, barrier.owner.slice('freeze:'.length)).catch(() => undefined)
+                    : undefined;
+                if (snapshot?.sourceWorkspaceId === barrier.workspaceId &&
+                    snapshot.sourceDirectoryName === barrier.directoryName) {
                     await state.journal.deleteDirectoryBarrier(barrier.owner);
                     continue;
                 }
@@ -170,19 +255,31 @@ async function gateFor(state) {
                     await state.journal.deleteDirectoryBarrier(barrier.owner);
                     continue;
                 }
-                waiting.push({ claim: { ...barrier, mode: 'exclusive', paused: true }, queuedAt: barrier.queuedAt ?? '' });
+                waiting.push({
+                    claim: { ...barrier, mode: 'exclusive', paused: true },
+                    queuedAt: barrier.queuedAt ?? '',
+                });
                 const timeout = setTimeout(() => {
                     if (gate.cancelPending(barrier.owner))
                         void state.journal.deleteDirectoryBarrier(barrier.owner).catch(() => undefined);
-                }, Math.max(0, Date.parse(barrier.deadline ?? new Date(Date.now() + 60_000).toISOString()) - Date.now()));
+                }, Math.max(0, Date.parse(barrier.deadline ?? new Date(Date.now() + 60_000).toISOString()) -
+                    Date.now()));
                 timeout.unref?.();
             }
             for (const pending of state.journal.deferredDirectoryOperations()) {
                 const operation = state.journal.getOperationById(pending.operationId);
                 if (operation?.status !== 'queued')
                     continue;
-                waiting.push({ claim: { ...operation, owner: `operation:${operation.operationId}`, mode: operationDirectoryMode(operation),
-                        ...(operation.kind.startsWith('session.') ? { sessionId: operation.sessionId } : {}) }, queuedAt: pending.queuedAt ?? operation.createdAt });
+                waiting.push({
+                    claim: {
+                        ...operation,
+                        owner: `operation:${operation.operationId}`,
+                        mode: operationDirectoryMode(operation),
+                        terminalIndependent: operationTerminalIndependent(operation),
+                        ...(operation.kind.startsWith('session.') ? { sessionId: operation.sessionId } : {}),
+                    },
+                    queuedAt: pending.queuedAt ?? operation.createdAt,
+                });
             }
             for (const item of waiting.sort((a, b) => a.queuedAt.localeCompare(b.queuedAt)))
                 void gate.claim(item.claim).catch(() => undefined);
@@ -209,7 +306,9 @@ export function reconcileDirectoryAccess(state) {
                 gate.release(owner);
         }
         else if (owner.startsWith('managed:')) {
-            if (state.journal.listManagedWrites().find(writer => writer.writeId === owner.slice('managed:'.length))?.stoppedAt)
+            if (state.journal
+                .listManagedWrites()
+                .find((writer) => writer.writeId === owner.slice('managed:'.length))?.stoppedAt)
                 gate.release(owner);
         }
     }
@@ -217,8 +316,15 @@ export function reconcileDirectoryAccess(state) {
 export async function holdDirectoryAccess(state, scope, owner, mode = 'shared') {
     const gate = await gateFor(state);
     const inherited = context.getStore();
-    await gate.claim({ ...scope, owner, mode,
-        ...(inherited?.state === state && gate.permits(inherited.claim.owner, scope, mode) ? { parentOwner: inherited.claim.owner } : {}) });
+    await gate.claim({
+        ...scope,
+        owner,
+        mode,
+        ...(owner.startsWith('managed:') ? { terminalIndependent: true } : {}),
+        ...(inherited?.state === state && gate.permits(inherited.claim.owner, scope, mode)
+            ? { parentOwner: inherited.claim.owner }
+            : {}),
+    });
     return () => gate.release(owner);
 }
 /** A build may join its known installer that was queued behind the build's own exclusive lease. */
@@ -245,13 +351,24 @@ export async function assertOperationDirectoryAccess(state, operation, mode) {
 export async function withDirectoryWrite(state, scope, action) {
     const inherited = context.getStore();
     const gate = await gateFor(state);
-    if (inherited?.state === state && gate.permits(inherited.claim.owner, scope, scope.mode ?? 'shared'))
+    if (inherited?.state === state &&
+        gate.permits(inherited.claim.owner, scope, scope.mode ?? 'shared'))
         return action();
-    if (inherited?.state === state && scope.mode === 'exclusive' && gate.permits(inherited.claim.owner, scope, 'shared'))
+    if (inherited?.state === state &&
+        scope.mode === 'exclusive' &&
+        gate.permits(inherited.claim.owner, scope, 'shared'))
         throw new Error('directory_busy');
-    const parentOwner = scope.mode !== 'exclusive' ? activeSessionOwner(state, gate, scope, scope.sessionId) : undefined;
-    const claim = { ...scope, sessionId: undefined, owner: scope.owner ?? `write:${randomUUID()}`, mode: scope.mode ?? 'shared',
-        ...(parentOwner ? { parentOwner } : {}) };
+    const parentOwner = scope.mode !== 'exclusive'
+        ? activeSessionOwner(state, gate, scope, scope.sessionId)
+        : undefined;
+    const claim = {
+        ...scope,
+        sessionId: undefined,
+        owner: scope.owner ?? `write:${randomUUID()}`,
+        mode: scope.mode ?? 'shared',
+        ...(scope.mode !== 'exclusive' ? { terminalIndependent: true } : {}),
+        ...(parentOwner ? { parentOwner } : {}),
+    };
     if (scope.wait === false && !gate.tryClaim(claim))
         throw new Error('directory_busy');
     if (scope.wait !== false)
@@ -265,7 +382,9 @@ export async function withDirectoryWrite(state, scope, action) {
     }
 }
 export async function withOperationDirectoryAccess(state, operation, action, deferred) {
-    if (!takesWorkspaceDirectory(operation.kind) || isTurnControl(operation.kind) || operation.kind === 'runtime.destroy')
+    if (!takesWorkspaceDirectory(operation.kind) ||
+        isTurnControl(operation.kind) ||
+        operation.kind === 'runtime.destroy')
         return action();
     const inherited = context.getStore();
     const mode = operationDirectoryMode(operation);
@@ -278,11 +397,19 @@ export async function withOperationDirectoryAccess(state, operation, action, def
         return state.journal.getOperationById(operation.operationId) ?? operation;
     active.add(operation.operationId);
     const parentOwner = !takesExecutionSlot(operation.kind) && mode === 'shared'
-        ? activeSessionOwner(state, gate, operation, operation.sessionId, operation.operationId) : undefined;
-    const claim = { ...operation, owner: `operation:${operation.operationId}`, mode: operationDirectoryMode(operation),
+        ? activeSessionOwner(state, gate, operation, operation.sessionId, operation.operationId)
+        : undefined;
+    const claim = {
+        ...operation,
+        owner: `operation:${operation.operationId}`,
+        mode: operationDirectoryMode(operation),
+        terminalIndependent: operationTerminalIndependent(operation),
         ...(operation.kind.startsWith('session.') ? { sessionId: operation.sessionId } : {}),
-        ...(parentOwner ? { parentOwner } : {}) };
-    if (inherited?.state === state && mode === 'shared' && gate.permits(inherited.claim.owner, operation, mode))
+        ...(parentOwner ? { parentOwner } : {}),
+    };
+    if (inherited?.state === state &&
+        mode === 'shared' &&
+        gate.permits(inherited.claim.owner, operation, mode))
         claim.parentOwner = inherited.claim.owner;
     const ready = gate.claim(claim);
     const run = async () => {
@@ -315,16 +442,20 @@ export async function withOperationDirectoryAccess(state, operation, action, def
         gate.release(claim.owner);
         throw error;
     }
-    void run().catch(async (error) => {
+    void run()
+        .catch(async (error) => {
         const current = state.journal.getOperationById(operation.operationId);
         if (!current || TERMINAL.has(current.status))
             return;
-        const cancelled = current.status === 'queued' && error instanceof Error && error.message === 'directory_access_cancelled';
+        const cancelled = current.status === 'queued' &&
+            error instanceof Error &&
+            error.message === 'directory_access_cancelled';
         await state.journal.putOperation(deferred.scopeKey, transitionOperation(current, cancelled ? 'interrupted' : 'uncertain', {
             error: cancelled ? 'cancelled' : 'native_receipt_lost',
         }));
         await state.journal.deleteDeferredDirectoryOperation(operation.operationId);
-    }).catch(() => undefined);
+    })
+        .catch(() => undefined);
     return state.journal.getOperationById(operation.operationId) ?? operation;
 }
 /** A queued command is replayed only if it never started; accepted or uncertain work is only observed. */
@@ -332,7 +463,8 @@ export async function restoreDeferredDirectoryOperations(state, execute) {
     for (const pending of state.journal.deferredDirectoryOperations()) {
         const operation = state.journal.getOperationById(pending.operationId);
         if (operation?.status === 'queued') {
-            if (operation.generation !== state.config.generation || operation.runtimeEpoch !== state.runtimeEpoch) {
+            if (operation.generation !== state.config.generation ||
+                operation.runtimeEpoch !== state.runtimeEpoch) {
                 await state.journal.putOperation(pending.scopeKey, transitionOperation(operation, 'failed', { error: 'generation_mismatch' }));
                 continue;
             }
@@ -350,11 +482,13 @@ export function releaseBatchDirectory(state, member) {
         instances.get(state)?.release(`run:${member.runId}`);
 }
 export async function withDirectoryFreeze(state, scope, action, quiesce, options) {
-    const pending = freezing.get(state) ?? new Map();
+    const pending = freezing.get(state) ??
+        new Map();
     freezing.set(state, pending);
     const existing = pending.get(scope.batchId);
     if (existing) {
-        if (existing.scope.workspaceId !== scope.workspaceId || (existing.scope.directoryName ?? 'basic') !== (scope.directoryName ?? 'basic'))
+        if (existing.scope.workspaceId !== scope.workspaceId ||
+            (existing.scope.directoryName ?? 'basic') !== (scope.directoryName ?? 'basic'))
             throw new Error('batch_source_identity_mismatch');
         return existing.task;
     }
@@ -370,13 +504,18 @@ export async function withDirectoryFreeze(state, scope, action, quiesce, options
 }
 async function performDirectoryFreeze(state, scope, action, quiesce, options) {
     const deadline = options?.deadline ?? new Date(Date.now() + 60_000).toISOString();
-    const signal = AbortSignal.any([...(options?.signal ? [options.signal] : []), AbortSignal.timeout(Math.max(0, Date.parse(deadline) - Date.now()))]);
+    const signal = AbortSignal.any([
+        ...(options?.signal ? [options.signal] : []),
+        AbortSignal.timeout(Math.max(0, Date.parse(deadline) - Date.now())),
+    ]);
     if (signal.aborted)
         throw new Error('directory_access_cancelled');
     const owner = `freeze:${scope.batchId}`;
     const gate = await gateFor(state);
-    const previous = state.journal.directoryBarriers().find(barrier => barrier.owner === owner);
-    if (previous && (previous.workspaceId !== scope.workspaceId || previous.directoryName !== (scope.directoryName ?? 'basic')))
+    const previous = state.journal.directoryBarriers().find((barrier) => barrier.owner === owner);
+    if (previous &&
+        (previous.workspaceId !== scope.workspaceId ||
+            previous.directoryName !== (scope.directoryName ?? 'basic')))
         throw new Error('batch_source_identity_mismatch');
     // A restored capture may still have writers. Retrying its publication is not a new admission,
     // and a missing candidate or a lost request cannot provide the old capture's stop proof.
@@ -393,22 +532,38 @@ async function performDirectoryFreeze(state, scope, action, quiesce, options) {
     signal.addEventListener('abort', cancel, { once: true });
     try {
         if (!restoredCapture)
-            await state.journal.putDirectoryBarrier({ owner, workspaceId: scope.workspaceId,
-                directoryName: scope.directoryName ?? 'basic', runtimeEpoch: state.runtimeEpoch, phase: 'pending', deadline });
+            await state.journal.putDirectoryBarrier({
+                owner,
+                workspaceId: scope.workspaceId,
+                directoryName: scope.directoryName ?? 'basic',
+                runtimeEpoch: state.runtimeEpoch,
+                phase: 'pending',
+                deadline,
+            });
         await quiesce?.();
         await claimed;
         if (signal.aborted)
             throw new Error('directory_access_cancelled');
         started = true;
         if (!restoredCapture)
-            await state.journal.putDirectoryBarrier({ owner, workspaceId: scope.workspaceId,
-                directoryName: scope.directoryName ?? 'basic', runtimeEpoch: state.runtimeEpoch, phase: 'capturing', deadline });
+            await state.journal.putDirectoryBarrier({
+                owner,
+                workspaceId: scope.workspaceId,
+                directoryName: scope.directoryName ?? 'basic',
+                runtimeEpoch: state.runtimeEpoch,
+                phase: 'capturing',
+                deadline,
+            });
         return await withDirectoryOwner(state, scope, owner, action);
     }
     finally {
         signal.removeEventListener('abort', cancel);
-        const snapshot = restoredCapture ? await readSnapshot(state, scope.batchId).catch(() => undefined) : undefined;
-        if (!restoredCapture || (snapshot?.sourceWorkspaceId === scope.workspaceId && snapshot.sourceDirectoryName === (scope.directoryName ?? 'basic'))) {
+        const snapshot = restoredCapture
+            ? await readSnapshot(state, scope.batchId).catch(() => undefined)
+            : undefined;
+        if (!restoredCapture ||
+            (snapshot?.sourceWorkspaceId === scope.workspaceId &&
+                snapshot.sourceDirectoryName === (scope.directoryName ?? 'basic'))) {
             await state.journal.deleteDirectoryBarrier(owner);
             gate.release(owner);
         }