@playcraft/cli 0.1.56-beta → 0.1.58-beta

package/dist/workspace-runtime/batch/deliver.js

@@ -1,13 +1,62 @@
+import { randomUUID } from 'node:crypto';
 import { constants } from 'node:fs';
-import { lstat, open } from 'node:fs/promises';
+import { lstat, mkdir, open, rm, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { hashOperationPayload, sandboxBatchMemberDeliverSchema, } from '@playcraft/common/cloud-workspace/runtime';
+import { claimBatchDirectory, withDirectoryOwner } from '../server/directory-access.js';
+import { runDeveloperCommand } from '../workspaces/developer-command.js';
 import { workspaceRoot } from '../workspaces/registry.js';
 import { groupExited, runProcessGroup, stopProcessGroup } from './processes.js';
+import { stopMemberWriters } from './writer-proof.js';
 import { memberStatus, readMember, readStopMarker, serializeRun, writeMember, } from './records.js';
 /** Base build writes dist/index.html. Channel packaging stays on export playable (`--mode full`). */
 function buildCommand() {
-    return (process.env.PLAYCRAFT_BATCH_BUILD_COMMAND ?? 'CI=1 playcraft build --mode base --output dist .');
+    return (process.env.PLAYCRAFT_BATCH_BUILD_COMMAND
+        ?? 'umask 002 && CI=1 playcraft build --mode base --output dist .');
+}
+/**
+ * The batch build runs as the runtime identity while the agent wrote the tree as the development
+ * identity. Directories the agent created private (browser profiles, tool caches) are unreadable to
+ * the build user, and the build's pre-build scan fails hard on the first one — which is how a
+ * delivered-looking member used to end as `batch_build_failed`. Only the owning identity may chmod,
+ * so the repair has to run through the launcher rather than the runtime user.
+ */
+const PERMISSION_REPAIR_COMMAND = [
+    'find . \\( -path ./node_modules -o -path ./.git \\) -prune -o',
+    '\\( -type d \\( -not -perm -040 -o -not -perm -010 \\) -o -type f -not -perm -040 \\)',
+    '-exec chmod g+rX {} +',
+].join(' ');
+const BUILD_LOG_LIMIT = 64 * 1024;
+/** Best effort: a failed repair is recorded in the log and never hides the build's own error. */
+async function repairGroupAccess(state, root, runId) {
+    let output = '';
+    try {
+        const outcome = await runDeveloperCommand(state, {
+            processId: `batch-deliver-repair-${runId}-${randomUUID()}`,
+            cwd: root,
+            command: PERMISSION_REPAIR_COMMAND,
+            timeoutMs: 30_000,
+            onOutput: (chunk) => {
+                output = (output + String(chunk)).slice(-BUILD_LOG_LIMIT);
+            },
+        });
+        if (outcome.code !== 0)
+            output += `\n[repair] exit ${outcome.code ?? 'unknown'}${outcome.timedOut ? ' (timeout)' : ''}`;
+    }
+    catch (error) {
+        output += `\n[repair] failed: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    return output;
+}
+/** Keeps the build's own stderr next to the run so a failure is diagnosable without a re-run. */
+async function writeBuildLog(state, runId, text) {
+    const directory = join(state.config.stateDir, 'batch-temp', runId);
+    await mkdir(directory, { recursive: true });
+    await writeFile(join(directory, 'build.log'), text.slice(-BUILD_LOG_LIMIT));
+}
+/** A build command that writes nothing must not inherit an earlier run's index.html as success. */
+async function clearBuiltHtml(root) {
+    await rm(join(root, 'dist', 'index.html'), { force: true }).catch(() => undefined);
 }
 async function readBuiltHtml(root) {
     const htmlPath = join(root, 'dist', 'index.html');
@@ -67,86 +116,97 @@ export async function deliverBatchMember(state, body) {
             existing.state === 'completed') {
             throw new Error('batch_command_conflict');
         }
-        const root = await workspaceRoot(state, command.workspaceId, command.directoryName);
-        let record = await writeMember(state, {
-            runId: command.runId,
-            ownerFence: command.ownerFence,
-            occupancyId: command.occupancyId,
-            workspaceId: command.workspaceId,
-            directoryName: command.directoryName,
-            phase: 'deliver',
-            state: 'running',
-            writersStopped: false,
-            holding: true,
-            stopRequested: false,
-            processes: existing?.processes ?? [],
-            sessionId: existing?.sessionId,
-            operationId: existing?.operationId,
-            commandHash: { ...existing?.commandHash, deliver: hash },
-            snapshotDigest: existing?.snapshotDigest,
-            branchName: existing?.branchName,
-            updatedAt: new Date().toISOString(),
-            sourceCommit: existing?.sourceCommit ??
-                state.journal
-                    .getWorkspace(command.workspaceId)
-                    ?.directories?.find((directory) => directory.directoryName === command.directoryName)
-                    ?.sourceCommit,
-            beforeTree: existing?.beforeTree,
-        });
-        try {
-            if (await readStopMarker(state, command.runId))
-                return memberStatus(await markStopped(state, command, record));
-            const built = await runProcessGroup(root, buildCommand(), 'build', async (process) => {
-                record = await writeMember(state, { ...record, processes: [...record.processes, process] });
-            });
-            record = await writeMember(state, {
-                ...record,
-                processes: record.processes.map((process) => process.pid === built.process.pid ? built.process : process),
+        await claimBatchDirectory(state, command);
+        return withDirectoryOwner(state, command, `run:${command.runId}`, async () => {
+            const root = await workspaceRoot(state, command.workspaceId, command.directoryName);
+            let record = await writeMember(state, {
+                runId: command.runId,
+                ownerFence: command.ownerFence,
+                occupancyId: command.occupancyId,
+                workspaceId: command.workspaceId,
+                directoryName: command.directoryName,
+                phase: 'deliver',
+                state: 'running',
+                writersStopped: false,
+                holding: true,
+                stopRequested: false,
+                processes: existing?.processes ?? [],
+                sessionId: existing?.sessionId,
+                operationId: existing?.operationId,
+                commandHash: { ...existing?.commandHash, deliver: hash },
+                snapshotDigest: existing?.snapshotDigest,
+                branchName: existing?.branchName,
+                updatedAt: new Date().toISOString(),
+                sourceCommit: existing?.sourceCommit ??
+                    state.journal
+                        .getWorkspace(command.workspaceId)
+                        ?.directories?.find((directory) => directory.directoryName === command.directoryName)
+                        ?.sourceCommit,
+                beforeTree: existing?.beforeTree,
             });
-            if (await readStopMarker(state, command.runId))
-                return memberStatus(await markStopped(state, command, record));
-            if (built.code !== 0)
-                throw new Error('batch_build_failed');
-            await readBuiltHtml(root);
-            const writersStopped = await prove(record);
-            if (!writersStopped)
-                return memberStatus(await writeMember(state, {
+            try {
+                if (await readStopMarker(state, command.runId))
+                    return memberStatus(await markStopped(state, command, record));
+                const repairOutput = await repairGroupAccess(state, root, command.runId);
+                await clearBuiltHtml(root);
+                const built = await runProcessGroup(root, buildCommand(), 'build', async (process) => {
+                    record = await writeMember(state, { ...record, processes: [...record.processes, process] });
+                });
+                record = await writeMember(state, {
                     ...record,
-                    state: 'stopping',
-                    writersStopped: false,
-                    holding: true,
-                }));
-            if (await readStopMarker(state, command.runId))
-                return memberStatus(await markStopped(state, command, record));
-            record = await writeMember(state, {
-                ...record,
-                state: 'completed',
-                writersStopped: true,
-                holding: false,
-                error: undefined,
-                evidence: { verified: true },
-            });
-            return memberStatus(record);
-        }
-        catch (error) {
-            const code = error instanceof Error && /^[a-z0-9_]+$/.test(error.message)
-                ? error.message
-                : 'batch_deliver_failed';
-            const writersStopped = await prove(record);
-            record = await writeMember(state, {
-                ...record,
-                state: writersStopped ? 'failed' : 'stopping',
-                writersStopped,
-                holding: !writersStopped,
-                error: code,
-            });
-            return memberStatus(record);
-        }
+                    processes: record.processes.map((process) => process.pid === built.process.pid ? built.process : process),
+                });
+                if (await readStopMarker(state, command.runId))
+                    return memberStatus(await markStopped(state, command, record));
+                const buildLog = [repairOutput, built.output].filter(Boolean).join('\n');
+                if (built.code !== 0) {
+                    await writeBuildLog(state, command.runId, buildLog).catch(() => undefined);
+                    const tail = built.output.trim().split('\n').slice(-3).join(' | ').slice(0, 400);
+                    if (tail)
+                        console.warn(`[workspace-runtime] batch build failed run=${command.runId} code=${built.code}: ${tail}`);
+                    throw new Error('batch_build_failed');
+                }
+                await writeBuildLog(state, command.runId, buildLog).catch(() => undefined);
+                await readBuiltHtml(root);
+                const writersStopped = await prove(record);
+                if (!writersStopped)
+                    return memberStatus(await writeMember(state, {
+                        ...record,
+                        state: 'stopping',
+                        writersStopped: false,
+                        holding: true,
+                    }));
+                if (await readStopMarker(state, command.runId))
+                    return memberStatus(await markStopped(state, command, record));
+                record = await writeMember(state, {
+                    ...record,
+                    state: 'completed',
+                    writersStopped: true,
+                    holding: false,
+                    error: undefined,
+                    evidence: { verified: true },
+                });
+                return memberStatus(record);
+            }
+            catch (error) {
+                const code = error instanceof Error && /^[a-z0-9_]+$/.test(error.message)
+                    ? error.message
+                    : 'batch_deliver_failed';
+                const writersStopped = await prove(record);
+                record = await writeMember(state, {
+                    ...record,
+                    state: writersStopped ? 'failed' : 'stopping',
+                    writersStopped,
+                    holding: !writersStopped,
+                    error: code,
+                });
+                return memberStatus(record);
+            }
+        });
     });
 }
 async function markStopped(state, command, existing) {
-    if (existing)
-        await prove(existing);
+    const writersStopped = await stopMemberWriters(state, existing);
     return writeMember(state, {
         runId: command.runId,
         ownerFence: command.ownerFence,
@@ -154,9 +214,9 @@ async function markStopped(state, command, existing) {
         workspaceId: command.workspaceId,
         directoryName: command.directoryName,
         phase: 'deliver',
-        state: 'stopped',
-        writersStopped: true,
-        holding: false,
+        state: writersStopped ? 'stopped' : 'stopping',
+        writersStopped,
+        holding: !writersStopped,
         stopRequested: true,
         processes: existing?.processes ?? [],
         sessionId: existing?.sessionId,

package/dist/workspace-runtime/batch/freeze.js

@@ -9,6 +9,7 @@ import { filesystemObjectStore, readSnapshot, serializeFreeze, sourceCacheDir, w
 import { assertSourceIdentity, readSourceCandidate, writeSourceCandidate } from './source-candidate.js';
 import { BatchSourceFreezeError, sourceFreezeError } from './source-failure.js';
 import { publishSourceCandidate } from './source-publish.js';
+import { clearDirectoryFreeze, withDirectoryFreeze } from '../server/directory-access.js';
 async function usagePercent(path) {
     const disk = await statfs(path);
     if (disk.blocks <= 0)
@@ -21,11 +22,8 @@ async function stopManagedWriters(state, workspaceId, directoryName) {
     for (const write of state.journal.listManagedWrites()) {
         if (write.stoppedAt || write.workspaceId !== scope)
             continue;
-        if (write.pid !== undefined) {
-            const stopped = await stopBackgroundWriter(write.pid);
-            if (!stopped)
-                continue;
-        }
+        if (write.pid === undefined || !await stopBackgroundWriter(write.pid))
+            continue;
         await state.journal.putManagedWrite({ ...write, stoppedAt: new Date().toISOString() });
     }
 }
@@ -34,7 +32,14 @@ export async function freezeBatchSource(state, body, options) {
     if (!parsed.success)
         throw new Error('invalid_batch_request');
     const request = parsed.data;
-    return serializeFreeze(async () => {
+    const frozen = await readSnapshot(state, request.batchId);
+    if (frozen) {
+        assertSourceIdentity(state, request, frozen, await readSourceCandidate(state, request.batchId));
+        await clearDirectoryFreeze(state, request.batchId);
+        return batchSourceFreezeResultSchema.parse({ status: 'frozen', snapshot: frozen });
+    }
+    return withDirectoryFreeze(state, { workspaceId: request.workspaceId,
+        directoryName: request.sourceDirectoryName, batchId: request.batchId }, () => serializeFreeze(async () => {
         let candidate;
         let source;
         try {
@@ -60,6 +65,7 @@ export async function freezeBatchSource(state, body, options) {
                 const cache = sourceCacheDir(state, request.batchId);
                 await rm(cache, { recursive: true, force: true });
                 const captured = await captureIndependentSource(source, cache);
+                // private
                 await writeFile(`${cache}.digest`, captured.digest, { mode: 0o600 });
                 const binding = state.journal.getWorkspace(request.workspaceId);
                 const snapshot = {
@@ -97,5 +103,11 @@ export async function freezeBatchSource(state, body, options) {
             throw await sourceFreezeError(state, request.batchId, { code: 'batch_source_verification_failed', stage: 'verify', retryable: true, outcome: 'unknown' }, error);
         }
         return batchSourceFreezeResultSchema.parse({ status: 'frozen', snapshot: candidate.snapshot });
+    }), () => stopManagedWriters(state, request.workspaceId, request.sourceDirectoryName), {
+        signal: options?.signal, deadline: 'deadline' in request && typeof request.deadline === 'string' ? request.deadline : undefined,
+    }).catch(async (error) => {
+        if (error instanceof Error && error.message === 'directory_access_cancelled')
+            throw await sourceFreezeError(state, request.batchId, { code: 'source_freeze_timeout', stage: 'capture', retryable: false, outcome: 'not_published' });
+        throw error;
     });
 }

package/dist/workspace-runtime/batch/generate.js

@@ -4,12 +4,14 @@ import { join } from 'node:path';
 import { setTimeout as delay } from 'node:timers/promises';
 import { hashOperationPayload, operationScopeKey, sandboxBatchMemberGenerateSchema, } from '@playcraft/common/cloud-workspace/runtime';
 import { attachNativeCollector, executeOperation } from '../server/dispatch.js';
+import { claimBatchDirectory, withDirectoryOwner } from '../server/directory-access.js';
 import { workspaceRoot } from '../workspaces/registry.js';
 import { snapshotWorkspaceTree } from '../workspaces/git.js';
 import { requireBatchContentChanges } from './content-changes.js';
 import { bindMemberPolicy, memberExecutionPolicy } from './policy.js';
 import { groupExited, stopProcessGroup } from './processes.js';
 import { memberStatus, readMember, readStopMarker, serializeRun, writeMember } from './records.js';
+import { stopMemberWriters } from './writer-proof.js';
 function hashCommand(value) {
     return hashOperationPayload(value);
 }
@@ -74,63 +76,69 @@ export async function generateBatchMember(state, body) {
         }
         if (existing && existing.ownerFence === command.ownerFence && existing.commandHash?.generate && existing.commandHash.generate !== hash)
             throw new Error('batch_command_conflict');
-        const root = await workspaceRoot(state, command.workspaceId, command.directoryName);
-        const sessionId = command.sessionId ?? existing?.sessionId ?? `member-${command.runId}`;
-        const tempDir = join(state.config.stateDir, 'batch-temp', command.runId);
-        await mkdir(tempDir, { recursive: true, mode: 0o700 });
-        const policy = memberExecutionPolicy(root, tempDir);
-        await bindMemberPolicy(state, sessionId, policy);
-        const modelConfigId = command.model && /^[0-9a-f-]{36}$/i.test(command.model) ? command.model : undefined;
-        const turnPayload = { text: command.prompt, permissionMode: 'auto', ...(modelConfigId ? { modelConfigId } : {}) };
-        const turnKey = operation(state, { kind: 'session.turn', clientRequestId: `batch-turn:${command.runId}`, sessionId, workspaceId: command.workspaceId, directoryName: command.directoryName, payload: turnPayload });
-        const prior = state.journal.getOperation(turnKey.scopeKey);
-        if (prior && prior.payloadHash !== turnKey.record.payloadHash)
-            throw new Error('batch_command_conflict');
-        const sourceCommit = existing?.sourceCommit ?? state.journal.getWorkspace(command.workspaceId)?.directories?.find(directory => directory.directoryName === command.directoryName)?.sourceCommit;
-        const beforeTree = existing?.beforeTree ?? (prior ? sourceCommit : await snapshotWorkspaceTree(root));
-        let record = await writeMember(state, {
-            runId: command.runId, ownerFence: command.ownerFence, occupancyId: command.occupancyId, workspaceId: command.workspaceId,
-            directoryName: command.directoryName, phase: 'generate', state: prior ? (prior.status === 'uncertain' ? 'unknown' : prior.status === 'completed' ? 'completed' : 'running') : 'running',
-            writersStopped: false, holding: true, stopRequested: false, processes: existing?.processes ?? [], sessionId,
-            operationId: prior?.operationId, commandHash: { ...existing?.commandHash, generate: hash },
-            snapshotDigest: existing?.snapshotDigest, branchName: existing?.branchName, headCommit: existing?.headCommit,
-            sourceCommit, beforeTree,
-            updatedAt: new Date().toISOString(),
-        });
-        if (prior)
-            return memberStatus(await finishGenerate(state, record, prior, root));
-        if (!state.native?.ready()) {
-            record = await writeMember(state, { ...record, state: 'failed', writersStopped: true, holding: false, error: 'capability_unavailable' });
-            return memberStatus(record);
-        }
-        const terminals = new Map();
-        const unsubscribe = state.native.onCollected?.((event) => {
-            const threadId = threadIdOf(event);
-            const terminal = turnTerminal(event);
-            if (!threadId || !terminal)
-                return;
-            if (terminals.get(threadId) === 'needs_user')
-                return;
-            terminals.set(threadId, terminal);
-        });
-        try {
-            if (!state.journal.getSession(sessionId)) {
-                const created = operation(state, { kind: 'session.create', clientRequestId: `batch-create:${command.runId}`, sessionId, workspaceId: command.workspaceId, directoryName: command.directoryName, payload: { permissionMode: 'auto', ...(modelConfigId ? { modelConfigId } : {}) } });
-                if (!state.journal.getOperation(created.scopeKey))
-                    await executeOperation(state, created.scopeKey, created.record, { permissionMode: 'auto', ...(modelConfigId ? { modelConfigId } : {}) });
+        if (existing && !existing.holding && existing.writersStopped)
+            return memberStatus(existing);
+        await claimBatchDirectory(state, command);
+        return withDirectoryOwner(state, command, `run:${command.runId}`, async () => {
+            const root = await workspaceRoot(state, command.workspaceId, command.directoryName);
+            const sessionId = command.sessionId ?? existing?.sessionId ?? `member-${command.runId}`;
+            const tempDir = join(state.config.stateDir, 'batch-temp', command.runId);
+            // private
+            await mkdir(tempDir, { recursive: true, mode: 0o700 });
+            const policy = memberExecutionPolicy(root, tempDir);
+            await bindMemberPolicy(state, sessionId, policy);
+            const modelConfigId = command.model && /^[0-9a-f-]{36}$/i.test(command.model) ? command.model : undefined;
+            const turnPayload = { text: command.prompt, permissionMode: 'auto', ...(modelConfigId ? { modelConfigId } : {}) };
+            const turnKey = operation(state, { kind: 'session.turn', clientRequestId: `batch-turn:${command.runId}`, sessionId, workspaceId: command.workspaceId, directoryName: command.directoryName, payload: turnPayload });
+            const prior = state.journal.getOperation(turnKey.scopeKey);
+            if (prior && prior.payloadHash !== turnKey.record.payloadHash)
+                throw new Error('batch_command_conflict');
+            const sourceCommit = existing?.sourceCommit ?? state.journal.getWorkspace(command.workspaceId)?.directories?.find(directory => directory.directoryName === command.directoryName)?.sourceCommit;
+            const beforeTree = existing?.beforeTree ?? (prior ? sourceCommit : await snapshotWorkspaceTree(root));
+            let record = await writeMember(state, {
+                runId: command.runId, ownerFence: command.ownerFence, occupancyId: command.occupancyId, workspaceId: command.workspaceId,
+                directoryName: command.directoryName, phase: 'generate', state: prior ? (prior.status === 'uncertain' ? 'unknown' : prior.status === 'completed' ? 'completed' : 'running') : 'running',
+                writersStopped: false, holding: true, stopRequested: false, processes: existing?.processes ?? [], sessionId,
+                operationId: prior?.operationId, commandHash: { ...existing?.commandHash, generate: hash },
+                snapshotDigest: existing?.snapshotDigest, branchName: existing?.branchName, headCommit: existing?.headCommit,
+                sourceCommit, beforeTree,
+                updatedAt: new Date().toISOString(),
+            });
+            if (prior)
+                return memberStatus(await finishGenerate(state, record, prior, root));
+            if (!state.native?.ready()) {
+                record = await writeMember(state, { ...record, state: 'failed', writersStopped: true, holding: false, error: 'capability_unavailable' });
+                return memberStatus(record);
             }
-            if (await readStopMarker(state, command.runId))
-                return memberStatus(await stoppedRecord(state, command, record));
-            const started = await executeOperation(state, turnKey.scopeKey, turnKey.record, turnPayload);
-            record = await writeMember(state, { ...record, operationId: started.operationId, sessionId });
-            return memberStatus(await finishGenerate(state, record, started, root, () => {
-                const threadId = state.journal.getSession(sessionId)?.threadId;
-                return threadId ? terminals.get(threadId) : undefined;
-            }));
-        }
-        finally {
-            unsubscribe?.();
-        }
+            const terminals = new Map();
+            const unsubscribe = state.native.onCollected?.((event) => {
+                const threadId = threadIdOf(event);
+                const terminal = turnTerminal(event);
+                if (!threadId || !terminal)
+                    return;
+                if (terminals.get(threadId) === 'needs_user')
+                    return;
+                terminals.set(threadId, terminal);
+            });
+            try {
+                if (!state.journal.getSession(sessionId)) {
+                    const created = operation(state, { kind: 'session.create', clientRequestId: `batch-create:${command.runId}`, sessionId, workspaceId: command.workspaceId, directoryName: command.directoryName, payload: { permissionMode: 'auto', ...(modelConfigId ? { modelConfigId } : {}) } });
+                    if (!state.journal.getOperation(created.scopeKey))
+                        await executeOperation(state, created.scopeKey, created.record, { permissionMode: 'auto', ...(modelConfigId ? { modelConfigId } : {}) });
+                }
+                if (await readStopMarker(state, command.runId))
+                    return memberStatus(await stoppedRecord(state, command, record));
+                const started = await executeOperation(state, turnKey.scopeKey, turnKey.record, turnPayload);
+                record = await writeMember(state, { ...record, operationId: started.operationId, sessionId });
+                return memberStatus(await finishGenerate(state, record, started, root, () => {
+                    const threadId = state.journal.getSession(sessionId)?.threadId;
+                    return threadId ? terminals.get(threadId) : undefined;
+                }));
+            }
+            finally {
+                unsubscribe?.();
+            }
+        });
     });
 }
 async function finishGenerate(state, record, started, root, early) {
@@ -142,7 +150,7 @@ async function finishGenerate(state, record, started, root, early) {
         return writeMember(state, { ...record, state: 'unknown', writersStopped: false, holding: true, operationId: started.operationId, error: 'native_receipt_lost' });
     }
     if (!terminal && started.status === 'failed') {
-        const writersStopped = await proveStopped(record);
+        const writersStopped = await stopMemberWriters(state, record);
         return writeMember(state, { ...record, state: writersStopped ? 'failed' : 'stopping', writersStopped, holding: !writersStopped, operationId: started.operationId, error: started.error ?? 'batch_turn_failed' });
     }
     const deadline = Date.now() + 5_000;
@@ -161,10 +169,7 @@ async function finishGenerate(state, record, started, root, early) {
             await delay(15);
     }
     if (terminal === 'needs_user') {
-        const session = state.journal.getSession(sessionId);
-        if (session?.threadId)
-            await state.native?.interrupt?.({ sessionId, threadId: session.threadId }).catch(() => undefined);
-        const writersStopped = await proveStopped(record);
+        const writersStopped = await stopMemberWriters(state, record);
         if (await readStopMarker(state, record.runId))
             return stoppedRecord(state, record, record);
         return writeMember(state, {
@@ -236,11 +241,10 @@ async function completeGeneration(state, record, root) {
     return writeMember(state, { ...record, state: 'completed', writersStopped: true, holding: true, headCommit: head, error: undefined });
 }
 async function stoppedRecord(state, command, existing) {
-    if (existing)
-        await proveStopped(existing);
+    const writersStopped = await stopMemberWriters(state, existing);
     return writeMember(state, {
         runId: command.runId, ownerFence: command.ownerFence, occupancyId: command.occupancyId, workspaceId: command.workspaceId,
-        directoryName: command.directoryName, phase: existing?.phase ?? 'generate', state: 'stopped', writersStopped: true, holding: false,
+        directoryName: command.directoryName, phase: existing?.phase ?? 'generate', state: writersStopped ? 'stopped' : 'stopping', writersStopped, holding: !writersStopped,
         stopRequested: true, processes: existing?.processes ?? [], sessionId: existing?.sessionId, operationId: existing?.operationId,
         headCommit: existing?.headCommit, evidence: existing?.evidence, commandHash: existing?.commandHash, snapshotDigest: existing?.snapshotDigest,
         branchName: existing?.branchName, updatedAt: new Date().toISOString(),