@@ -95,10 +95,8 @@ export interface ProcessControl {
 export const hostProcesses: ProcessControl = {
   isAlive(pgid, startedAt) {
     try { process.kill(-pgid, 0); } catch { return false; }
-    try {
-      const started = Date.parse(execFileSync('ps', ['-o', 'lstart=', '-p', String(pgid)], { encoding: 'utf8' }).trim());
-      return Number.isFinite(started) && Math.abs(started - startedAt) < 2_000;
-    } catch { return true; } // Alive but unreadable: treat as ours and stop it (fail closed).
+    try { return startTimeMatches(execFileSync('ps', ['-o', 'lstart=', '-p', String(pgid)], { encoding: 'utf8', env: { ...process.env, LC_ALL: 'C' } }), startedAt); }
+    catch { return true; } // Alive but unreadable: treat as ours and stop it (fail closed).
   },
   async terminate(pgid, graceMs) {
     const alive = () => { try { process.kill(-pgid, 0); return true; } catch { return false; } };
@@ -110,6 +108,12 @@ export const hostProcesses: ProcessControl = {
   },
 };
 
+/** Whether `ps -o lstart=` output names the recorded start time. An unreadable time counts as a match (fail closed). */
+export function startTimeMatches(lstart: string, startedAt: number): boolean {
+  const started = Date.parse(lstart.trim());
+  return !Number.isFinite(started) || Math.abs(started - startedAt) < 2_000;
+}
+
 export interface RecoveredStorage { readonly attemptId: string; readonly allocationId: string; readonly handle: unknown }
 export interface RecoveryDeps {
   /** D (#51): stop leftover agent containers, proxies and networks for this owner; keep task storage and return authenticated handles. */
@@ -156,14 +160,17 @@ export async function recoverStartup(o: RecoveryOptions): Promise<RecoveryReport
     const attempt = interrupted.find(a => a.id === storage.attemptId);
     if (!attempt || !WRITABLE_KINDS.includes(attempt.kind)) continue;
     const controller = new AbortController(), timer = setTimeout(() => controller.abort(new Error('Export timed out.')), o.exportDeadlineMs ?? 60_000);
+    const exporting = o.deps.exportTaskDiff(storage.handle, EXPORT_LIMIT, controller.signal);
     try {
-      const diff = await Promise.race([o.deps.exportTaskDiff(storage.handle, EXPORT_LIMIT, controller.signal),
+      const diff = await Promise.race([exporting,
         new Promise<never>((_, reject) => controller.signal.addEventListener('abort', () => reject(controller.signal.reason), { once: true }))]);
       const file = join(o.diagnosticsDir, `${storage.attemptId}.diff`);
       writeFileSync(file, diff.subarray(0, EXPORT_LIMIT), { mode: 0o600 });
       exports[storage.attemptId] = { diagnosticRef: file };
     } catch (error) { exports[storage.attemptId] = { failure: error instanceof Error ? error.message : String(error) }; }
     finally { clearTimeout(timer); }
+    // A timed-out export must stop before step 4 removes its storage. D stops on abort; if it does not, fail closed.
+    if (controller.signal.aborted) await stopped(exporting, o.graceMs ?? 5_000, storage.attemptId);
   }
   // 3. Finalization phase: one transaction; a failure stops startup.
   const finalized = o.store.recoverInterrupted(now(), exports);
@@ -173,24 +180,33 @@ export async function recoverStartup(o: RecoveryOptions): Promise<RecoveryReport
     await o.deps.abortRebase(rebase.planKey, rebase.marker);
   }
   for (const storage of matched) await o.deps.removeTaskFilesystems(storage.handle);
+  // Step 7's set, read after finalization so it also holds preparations an earlier startup already finalized.
+  const blocked = [...new Set([...unowned, ...o.store.unownedPreparations()])];
   const removedDirectories: string[] = [], unknownEntries: string[] = [];
   const attemptsDir = join(o.runnerRoot, o.runnerOwner, 'attempts');
   const rootDev = lstatSync(o.runnerRoot, { throwIfNoEntry: false })?.dev;
   for (const name of lstatSync(attemptsDir, { throwIfNoEntry: false })?.isDirectory() ? readdirSync(attemptsDir) : []) {
     const entry = join(attemptsDir, name), st = lstatSync(entry);
     const owned = st.isDirectory() && !st.isSymbolicLink() && st.dev === rootDev && isUuidV4(name) && o.store.attemptOwner(name) !== null;
     if (!owned) { unknownEntries.push(entry); continue; }
-    if (unowned.includes(name)) continue; // step 7 keeps it for --release-preparation
+    if (blocked.includes(name)) continue; // step 7 keeps it for --release-preparation
     rmSync(entry, { recursive: true, force: true }); removedDirectories.push(entry);
   }
   // 5. Confirmed merges get their closed status and task-closed event.
   const repairedMerges = o.store.reconcileMergedTasks();
   // 7. An unidentifiable preparation child may exist: fail closed until the user releases it.
-  const blocked = [...unowned, ...o.store.unownedPreparations().filter(id => !unowned.includes(id))];
   if (blocked.length) throw new RecoveryBlocked('Preparation started but its process was never recorded; stop it, then run --release-preparation', blocked);
   return { finalized, requeue: finalized.filter(f => f.requeued).map(f => f.planKey), removedDirectories, unknownEntries, unmatchedStorage, repairedMerges };
 }
 
+/** Wait for an aborted export to settle, up to graceMs; otherwise stop startup before its storage is touched. */
+async function stopped(exporting: Promise<unknown>, graceMs: number, attemptId: string): Promise<void> {
+  let timer: ReturnType<typeof setTimeout> | undefined;
+  const settled = await Promise.race([exporting.then(() => true, () => true), new Promise<false>(resolve => { timer = setTimeout(() => resolve(false), graceMs); })]);
+  clearTimeout(timer);
+  if (!settled) throw new RecoveryBlocked('A partial-output export did not stop after its deadline; its task storage was left in place', [attemptId]);
+}
+
 /** --release-preparation: remove an attempt directory only when no process has a file open or a working directory in it. */
 export function releasePreparation(o: { store: Store; runnerRoot: string; runnerOwner: string; attemptId: string; openFiles?: (dir: string) => string[] }): void {
   if (!isUuidV4(o.attemptId) || o.store.attemptOwner(o.attemptId) === null) throw new Error('Unknown attempt.');
@@ -205,6 +221,8 @@ export function releasePreparation(o: { store: Store; runnerRoot: string; runner
 }
 /** Processes with a file open or a working directory under dir. Throws if the check cannot run (fail closed). */
 export function hostOpenFiles(dir: string): string[] {
+  // /proc links and lsof report resolved paths, so compare against the resolved directory.
+  dir = realpathSync(dir);
   if (process.platform === 'linux') {
     const users: string[] = [];
     for (const pid of readdirSync('/proc').filter(name => /^\d+$/.test(name))) {
 
@@ -8,7 +8,7 @@ import { fileURLToPath } from 'node:url';
 import { DatabaseSync } from 'node:sqlite';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { Store } from '../runner/store.ts';
-import { LockHeld, RecoveryBlocked, acquireRunnerLock, recoverStartup, releasePreparation, type RecoveryDeps, type RunnerLock } from '../runner/recovery.ts';
+import { LockHeld, RecoveryBlocked, acquireRunnerLock, hostOpenFiles, recoverStartup, releasePreparation, startTimeMatches, type RecoveryDeps, type RunnerLock } from '../runner/recovery.ts';
 import type { PlanIdentity } from '../core/identity.ts';
 import type { Plan, PlanContext } from '../core/plan.ts';
 
@@ -218,12 +218,27 @@ describe('startup recovery sequence', () => {
     const attempt = admit(id(1)); store.markRunning(id(1), attempt.id);
     const { d, calls } = deps({
       recoverLeftovers: async () => ({ storage: [{ attemptId: attempt.id, allocationId: randomUUID(), handle: 'h' }], unowned: [] }),
-      exportTaskDiff: () => new Promise(() => undefined),
+      // D's export stops a moment after its signal aborts.
+      exportTaskDiff: (_h, _m, signal) => new Promise((_, reject) => signal.addEventListener('abort', () => setTimeout(() => { calls.push('export-stopped'); reject(signal.reason); }, 40), { once: true })),
     });
     await recoverStartup({ store, runnerOwner: token, runnerRoot: join(root, 'r'), diagnosticsDir: join(root, 'd'), deps: d, exportDeadlineMs: 30 });
     expect(store.getAttempt(id(1), attempt.id)).toMatchObject({ state: 'failed', diagnosticRef: null });
     expect(store.getAttempt(id(1), attempt.id).diagnostic).toMatch(/Partial output could not be exported: Export timed out/);
-    expect(calls).toContain('remove:h');
+    // The storage is removed only after the export stopped using it.
+    expect(calls.indexOf('export-stopped')).toBeGreaterThan(-1);
+    expect(calls.indexOf('remove:h')).toBeGreaterThan(calls.indexOf('export-stopped'));
+  });
+  it('stops startup, leaving storage and the attempt untouched, when a timed-out export does not stop', async () => {
+    const { d: root, store, admit } = fixture();
+    const attempt = admit(id(1)); store.markRunning(id(1), attempt.id);
+    const { d, calls } = deps({
+      recoverLeftovers: async () => ({ storage: [{ attemptId: attempt.id, allocationId: randomUUID(), handle: 'h' }], unowned: [] }),
+      exportTaskDiff: () => new Promise(() => undefined),
+    });
+    await expect(recoverStartup({ store, runnerOwner: token, runnerRoot: join(root, 'r'), diagnosticsDir: join(root, 'd'), deps: d, exportDeadlineMs: 30, graceMs: 30 }))
+      .rejects.toThrow(/did not stop/);
+    expect(calls.some(c => c.startsWith('remove'))).toBe(false);
+    expect(store.getAttempt(id(1), attempt.id).state).toBe('running');
   });
   it('removes nothing when the finalization transaction fails', async () => {
     const { d: root, store, admit } = fixture();
@@ -253,9 +268,29 @@ describe('startup recovery sequence', () => {
     const run = () => recoverStartup({ store, runnerOwner: token, runnerRoot, diagnosticsDir: join(root, 'd'), deps: deps().d });
     await expect(run()).rejects.toBeInstanceOf(RecoveryBlocked);
     expect(existsSync(dirPath)).toBe(true);
+    // A second startup finds the attempt already finalized, and still keeps its directory for the release check.
+    await expect(run()).rejects.toBeInstanceOf(RecoveryBlocked);
+    expect(existsSync(dirPath)).toBe(true);
     expect(() => releasePreparation({ store, runnerRoot, runnerOwner: token, attemptId: attempt.id, openFiles: () => ['4242'] })).toThrow(/still using/);
     releasePreparation({ store, runnerRoot, runnerOwner: token, attemptId: attempt.id, openFiles: () => [] });
     expect(existsSync(dirPath)).toBe(false);
     await expect(run()).resolves.toMatchObject({ finalized: [] });
   });
 });
+
+describe('host process checks', () => {
+  it('treats a start time it cannot read as a match, so a live group is still stopped', () => {
+    const at = Date.parse('Sat Sep 26 02:01:04 2026');
+    expect(startTimeMatches('Sat Sep 26 02:01:04 2026\n', at)).toBe(true);
+    expect(startTimeMatches('Sat Sep 26 02:01:04 2026', at + 60_000)).toBe(false);
+    // procps under a Japanese locale; Date.parse cannot read it.
+    expect(startTimeMatches('土  9月 26 02:01:04 2026', at + 60_000)).toBe(true);
+  });
+  it('finds a process working in the attempt directory when the path goes through a symlink', async () => {
+    const root = dir(), real = join(root, 'real'), attempt = join(real, 'attempt');
+    mkdirSync(attempt, { recursive: true }); symlinkSync(real, join(root, 'link'));
+    const child = spawn('sleep', ['30'], { cwd: attempt, stdio: 'ignore' }); children.push(child);
+    await once(child, 'spawn');
+    expect(hostOpenFiles(join(root, 'link', 'attempt'))).toContain(String(child.pid));
+  });
+});