@dotsetlabs/dotclaw 2.4.0 → 2.6.0

package/dist/container-runner.js

@@ -360,8 +360,50 @@ function isContainerRunning(name) {
     }
 }
 const daemonConfig = runtime.host.container.daemon;
-function readDaemonStatus(groupFolder) {
-    const statusPath = path.join(DATA_DIR, 'ipc', groupFolder, 'daemon_status.json');
+const DAEMON_BOOTSTRAP_GRACE_MS = Math.max(daemonConfig.gracePeriodMs, daemonConfig.heartbeatMaxAgeMs);
+const daemonBootstrapUntil = new Map();
+function markDaemonBootstrapping(groupFolder) {
+    daemonBootstrapUntil.set(groupFolder, Date.now() + DAEMON_BOOTSTRAP_GRACE_MS);
+}
+function isDaemonBootstrapping(groupFolder, nowMs = Date.now()) {
+    const until = daemonBootstrapUntil.get(groupFolder);
+    if (!until)
+        return false;
+    if (until <= nowMs) {
+        daemonBootstrapUntil.delete(groupFolder);
+        return false;
+    }
+    return true;
+}
+function consumeMemoryExtractionError(groupFolder) {
+    const statusPath = path.join(DATA_DIR, 'ipc', groupFolder, 'memory_extraction_error.json');
+    try {
+        if (!fs.existsSync(statusPath))
+            return undefined;
+        const raw = fs.readFileSync(statusPath, 'utf-8').trim();
+        try {
+            const parsed = JSON.parse(raw);
+            if (typeof parsed.error === 'string' && parsed.error.trim()) {
+                return parsed.error.trim();
+            }
+        }
+        catch {
+            if (raw)
+                return raw;
+        }
+    }
+    catch {
+        return undefined;
+    }
+    finally {
+        try {
+            fs.unlinkSync(statusPath);
+        }
+        catch { /* ignore */ }
+    }
+    return undefined;
+}
+function readDaemonStatusFromPath(statusPath) {
     try {
         if (!fs.existsSync(statusPath))
             return null;
@@ -372,6 +414,10 @@ function readDaemonStatus(groupFolder) {
         return null;
     }
 }
+function readDaemonStatus(groupFolder) {
+    const statusPath = path.join(DATA_DIR, 'ipc', groupFolder, 'daemon_status.json');
+    return readDaemonStatusFromPath(statusPath);
+}
 /**
  * 3-state health check: healthy / busy / dead
  *
@@ -444,8 +490,7 @@ export function gracefulRestartDaemonContainer(group, isMain) {
         }
     }
     // Start new container
-    const mounts = buildVolumeMounts(group, isMain);
-    ensureDaemonContainer(mounts, group.folder);
+    ensureDaemonContainer(group, isMain);
     logger.info({ groupFolder: group.folder }, 'Daemon container restarted (graceful)');
 }
 /**
@@ -459,8 +504,7 @@ export function restartDaemonContainer(group, isMain) {
     catch {
         // Ignore if container doesn't exist
     }
-    const mounts = buildVolumeMounts(group, isMain);
-    ensureDaemonContainer(mounts, group.folder);
+    ensureDaemonContainer(group, isMain);
     logger.info({ groupFolder: group.folder }, 'Daemon container restarted (force)');
 }
 // Track daemon health check state
@@ -478,6 +522,7 @@ export function suppressHealthChecks(durationMs) {
 export function resetUnhealthyDaemons() {
     unhealthyDaemons.clear();
     healthCheckRestartTimestamps.clear();
+    daemonBootstrapUntil.clear();
 }
 /**
  * Perform health check on all daemon containers and restart if needed.
@@ -497,6 +542,7 @@ export function performDaemonHealthChecks(getRegisteredGroups, mainGroupFolder)
         // Skip if container isn't running (may be intentionally stopped)
         if (!isContainerRunning(containerName)) {
             unhealthyDaemons.delete(group.folder);
+            daemonBootstrapUntil.delete(group.folder);
             continue;
         }
         const health = checkDaemonHealth(group.folder);
@@ -579,28 +625,58 @@ export function stopDaemonHealthCheckLoop() {
         healthCheckInterval = null;
     }
 }
-function ensureDaemonContainer(mounts, groupFolder) {
+function ensureDaemonContainer(group, isMain) {
+    sanitizeGroupFolder(group.folder);
+    const groupFolder = group.folder;
     const containerName = getDaemonContainerName(groupFolder);
-    if (isContainerRunning(containerName))
+    const health = checkDaemonHealth(groupFolder);
+    if (health.state === 'healthy' || health.state === 'busy') {
         return;
-    try {
-        execSync(`docker rm -f ${containerName}`, { stdio: 'ignore', timeout: 15_000 });
     }
-    catch {
-        // ignore if container doesn't exist
+    const running = isContainerRunning(containerName);
+    if (running && isDaemonBootstrapping(groupFolder)) {
+        return;
+    }
+    const mounts = buildVolumeMounts(group, isMain);
+    if (running) {
+        logger.warn({
+            groupFolder,
+            ageMs: health.ageMs,
+            daemonState: health.daemonState
+        }, 'Daemon container running but unhealthy; restarting before request');
+        try {
+            execSync(`docker rm -f ${containerName}`, { stdio: 'ignore', timeout: 15_000 });
+        }
+        catch {
+            // ignore cleanup failure and attempt fresh start
+        }
+    }
+    else {
+        daemonBootstrapUntil.delete(groupFolder);
+        try {
+            execSync(`docker rm -f ${containerName}`, { stdio: 'ignore', timeout: 15_000 });
+        }
+        catch {
+            // ignore if container doesn't exist
+        }
     }
     const args = buildDaemonArgs(mounts, containerName, groupFolder);
     const result = spawnSync('docker', args, { stdio: 'ignore' });
     if (result.status !== 0) {
+        // Concurrent starts can lose the name race while the daemon is actually up.
+        if (isContainerRunning(containerName)) {
+            markDaemonBootstrapping(groupFolder);
+            return;
+        }
         logger.error({ groupFolder, status: result.status }, 'Failed to start daemon container');
         throw new Error(`Failed to start daemon container for ${groupFolder}`);
     }
+    markDaemonBootstrapping(groupFolder);
 }
 export function warmGroupContainer(group, isMain) {
     if (CONTAINER_MODE !== 'daemon')
         return;
-    const mounts = buildVolumeMounts(group, isMain);
-    ensureDaemonContainer(mounts, group.folder);
+    ensureDaemonContainer(group, isMain);
 }
 function writeAgentRequest(groupFolder, payload) {
     const id = generateId('agent');
@@ -611,64 +687,206 @@ function writeAgentRequest(groupFolder, payload) {
     const requestPath = path.join(requestsDir, `${id}.json`);
     const responsePath = path.join(responsesDir, `${id}.json`);
     const tempPath = `${requestPath}.tmp`;
-    fs.writeFileSync(tempPath, JSON.stringify({ id, input: payload }, null, 2));
+    fs.writeFileSync(tempPath, JSON.stringify({ id, input: payload }));
     fs.renameSync(tempPath, requestPath);
     return { id, requestPath, responsePath };
 }
-async function waitForAgentResponse(responsePath, timeoutMs, abortSignal) {
-    const start = Date.now();
-    while (Date.now() - start < timeoutMs) {
-        if (abortSignal?.aborted) {
-            throw new Error('Agent run preempted');
+class FileChangeSignal {
+    abortSignal;
+    watcher = null;
+    pending = false;
+    waiter = null;
+    abortHandler;
+    constructor(watchDir, abortSignal) {
+        this.abortSignal = abortSignal;
+        try {
+            this.watcher = fs.watch(watchDir, { persistent: false }, () => this.notify());
+            this.watcher.on('error', () => {
+                if (this.watcher) {
+                    try {
+                        this.watcher.close();
+                    }
+                    catch { /* ignore */ }
+                    this.watcher = null;
+                }
+                this.notify();
+            });
         }
-        if (fs.existsSync(responsePath)) {
-            let raw;
-            try {
-                raw = fs.readFileSync(responsePath, 'utf-8');
-            }
-            catch (readErr) {
-                const code = readErr?.code;
-                if (code === 'ENOENT') {
-                    // File disappeared between existsSync and readFileSync; continue polling
-                    await new Promise(resolve => setTimeout(resolve, CONTAINER_DAEMON_POLL_MS));
-                    continue;
+        catch {
+            this.watcher = null;
+        }
+        if (this.abortSignal) {
+            this.abortHandler = () => this.notify();
+            this.abortSignal.addEventListener('abort', this.abortHandler);
+        }
+        else {
+            this.abortHandler = null;
+        }
+    }
+    notify() {
+        if (this.waiter) {
+            const wake = this.waiter;
+            this.waiter = null;
+            wake();
+            return;
+        }
+        this.pending = true;
+    }
+    async wait(timeoutMs) {
+        if (this.pending) {
+            this.pending = false;
+            return;
+        }
+        await new Promise((resolve) => {
+            let settled = false;
+            const finish = () => {
+                if (settled)
+                    return;
+                settled = true;
+                if (this.waiter === finish)
+                    this.waiter = null;
+                clearTimeout(timer);
+                resolve();
+            };
+            const timer = setTimeout(finish, Math.max(10, timeoutMs));
+            this.waiter = finish;
+        });
+    }
+    close() {
+        if (this.abortSignal && this.abortHandler) {
+            this.abortSignal.removeEventListener('abort', this.abortHandler);
+        }
+        if (this.watcher) {
+            this.watcher.close();
+            this.watcher = null;
+        }
+        this.notify();
+    }
+}
+function isContainerOutputPayload(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    const status = value.status;
+    return status === 'success' || status === 'error';
+}
+export async function waitForAgentResponse(responsePath, timeoutMs, abortSignal, options) {
+    const RESPONSE_PARSE_MAX_RETRIES = 8;
+    const pollMs = Math.max(25, CONTAINER_DAEMON_POLL_MS);
+    const parseRetryMs = Math.max(20, Math.floor(pollMs / 2));
+    const maxExtensionMs = Math.max(0, Math.floor(options?.maxExtensionMs
+        ?? Math.min(120_000, Math.max(30_000, Math.floor(timeoutMs * 0.5)))));
+    const start = Date.now();
+    let deadline = start + timeoutMs;
+    let extendedMs = 0;
+    const waitSignal = new FileChangeSignal(path.dirname(responsePath), abortSignal);
+    let parseFailures = 0;
+    let lastParseError = '';
+    try {
+        for (;;) {
+            while (Date.now() < deadline) {
+                if (abortSignal?.aborted) {
+                    throw new Error('Agent run preempted');
                 }
-                throw readErr;
-            }
-            try {
-                const parsed = JSON.parse(raw);
-                fs.unlinkSync(responsePath);
-                return parsed;
-            }
-            catch (parseErr) {
-                // Partial read during atomic rename can produce invalid JSON — retry up to 3 times
-                let retryParsed = null;
-                for (let parseRetry = 0; parseRetry < 3; parseRetry++) {
-                    await new Promise(resolve => setTimeout(resolve, CONTAINER_DAEMON_POLL_MS));
+                if (fs.existsSync(responsePath)) {
+                    let raw;
                     try {
-                        const retryRaw = fs.readFileSync(responsePath, 'utf-8');
-                        retryParsed = JSON.parse(retryRaw);
-                        break;
+                        raw = fs.readFileSync(responsePath, 'utf-8');
                     }
-                    catch {
-                        // continue retrying
+                    catch (readErr) {
+                        const code = readErr?.code;
+                        if (code === 'ENOENT') {
+                            await waitSignal.wait(pollMs);
+                            continue;
+                        }
+                        throw readErr;
                     }
-                }
-                if (retryParsed) {
                     try {
-                        fs.unlinkSync(responsePath);
+                        const parsed = JSON.parse(raw);
+                        if (!isContainerOutputPayload(parsed)) {
+                            throw new Error('Missing required "status" field');
+                        }
+                        try {
+                            fs.unlinkSync(responsePath);
+                        }
+                        catch { /* ignore */ }
+                        return parsed;
+                    }
+                    catch (parseErr) {
+                        parseFailures += 1;
+                        lastParseError = parseErr instanceof Error ? parseErr.message : String(parseErr);
+                        if (parseFailures >= RESPONSE_PARSE_MAX_RETRIES) {
+                            try {
+                                fs.unlinkSync(responsePath);
+                            }
+                            catch { /* ignore */ }
+                            throw new Error(`Failed to parse daemon response after ${parseFailures} attempts: ${lastParseError}`);
+                        }
+                        await waitSignal.wait(parseRetryMs);
+                        if (fs.existsSync(responsePath)) {
+                            let stat;
+                            try {
+                                stat = fs.statSync(responsePath);
+                            }
+                            catch (statErr) {
+                                const code = statErr?.code;
+                                if (code === 'ENOENT')
+                                    continue;
+                                throw statErr;
+                            }
+                            if (Date.now() - stat.mtimeMs > 5_000) {
+                                try {
+                                    fs.unlinkSync(responsePath);
+                                }
+                                catch { /* ignore */ }
+                                throw new Error(`Stale daemon response file: ${lastParseError}`);
+                            }
+                        }
+                        continue;
                     }
-                    catch { /* ignore */ }
-                    return retryParsed;
                 }
-                try {
-                    fs.unlinkSync(responsePath);
+                await waitSignal.wait(pollMs);
+            }
+            // Soft timeout extension: if daemon is actively processing this request with fresh heartbeat,
+            // grant bounded extra time to avoid false timeout/restart thrash on long turns.
+            const groupFolder = options?.groupFolder;
+            const requestId = options?.requestId;
+            const daemonStatusPath = options?.daemonStatusPath;
+            if ((groupFolder || daemonStatusPath) && maxExtensionMs > 0 && extendedMs < maxExtensionMs) {
+                const status = daemonStatusPath
+                    ? readDaemonStatusFromPath(daemonStatusPath)
+                    : readDaemonStatus(groupFolder);
+                if (status && status.state === 'processing') {
+                    if (!requestId || !status.request_id || status.request_id === requestId) {
+                        const now = Date.now();
+                        const heartbeatAgeMs = Number.isFinite(status.ts) ? now - status.ts : Number.POSITIVE_INFINITY;
+                        const freshnessBudgetMs = Math.max(daemonConfig.heartbeatMaxAgeMs * 2, 15_000);
+                        if (heartbeatAgeMs <= freshnessBudgetMs) {
+                            const remainingExtensionMs = maxExtensionMs - extendedMs;
+                            if (remainingExtensionMs > 0) {
+                                const stepExtensionMs = Math.min(remainingExtensionMs, Math.max(15_000, Math.floor(timeoutMs * 0.25)));
+                                extendedMs += stepExtensionMs;
+                                deadline = now + stepExtensionMs;
+                                logger.warn({
+                                    groupFolder,
+                                    requestId: requestId || status.request_id || null,
+                                    heartbeatAgeMs,
+                                    extendedMs,
+                                    maxExtensionMs
+                                }, 'Extending daemon response wait for active processing request');
+                                continue;
+                            }
+                        }
+                    }
                 }
-                catch { /* ignore */ }
-                throw new Error(`Failed to parse daemon response: ${parseErr instanceof Error ? parseErr.message : String(parseErr)}`);
             }
+            break;
         }
-        await new Promise(resolve => setTimeout(resolve, CONTAINER_DAEMON_POLL_MS));
+    }
+    finally {
+        waitSignal.close();
+    }
+    if (lastParseError) {
+        throw new Error(`Daemon response timeout after ${timeoutMs}ms (last parse error: ${lastParseError})`);
     }
     throw new Error(`Daemon response timeout after ${timeoutMs}ms`);
 }
@@ -687,6 +905,20 @@ function removeContainerById(containerId, reason) {
     logger.warn({ containerId, reason }, 'Removing container');
     spawn('docker', ['rm', '-f', containerId], { stdio: 'ignore' });
 }
+export function shouldRetryDaemonRequestError(errorMessage) {
+    if (!errorMessage)
+        return false;
+    const lower = errorMessage.toLowerCase();
+    if (/preempted|aborted|interrupted|cancelled|canceled/.test(lower)) {
+        return false;
+    }
+    return /daemon response timeout|failed to parse daemon response|stale daemon response file/.test(lower);
+}
+function isDaemonTimeoutError(errorMessage) {
+    if (!errorMessage)
+        return false;
+    return /daemon response timeout/i.test(errorMessage);
+}
 export async function runContainerAgent(group, input, options) {
     sanitizeGroupFolder(group.folder);
     if (CONTAINER_MODE === 'daemon') {
@@ -823,31 +1055,35 @@ export async function runContainerAgent(group, input, options) {
             }
             cleanupCid();
             const duration = Date.now() - startTime;
-            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-            const logFile = path.join(logsDir, `container-${timestamp}.log`);
             const isVerbose = runtime.host.logLevel === 'debug' || runtime.host.logLevel === 'trace';
-            const logLines = [
-                `=== Container Run Log ===`,
-                `Timestamp: ${new Date().toISOString()}`,
-                `Group: ${group.name}`,
-                `IsMain: ${input.isMain}`,
-                `Duration: ${duration}ms`,
-                `Exit Code: ${code}`,
-                `Stdout Truncated: ${stdoutTruncated}`,
-                `Stderr Truncated: ${stderrTruncated}`,
-                ``
-            ];
-            if (isVerbose) {
-                logLines.push(`=== Input ===`, JSON.stringify(input, null, 2), ``, `=== Container Args ===`, containerArgs.join(' '), ``, `=== Mounts ===`, mounts.map(m => `${m.hostPath} -> ${m.containerPath}${m.readonly ? ' (ro)' : ''}`).join('\n'), ``, `=== Stderr${stderrTruncated ? ' (TRUNCATED)' : ''} ===`, stderr, ``, `=== Stdout${stdoutTruncated ? ' (TRUNCATED)' : ''} ===`, stdout);
-            }
-            else {
-                logLines.push(`=== Input Summary ===`, `Prompt length: ${input.prompt.length} chars`, `Session ID: ${input.sessionId || 'new'}`, ``, `=== Mounts ===`, mounts.map(m => `${m.containerPath}${m.readonly ? ' (ro)' : ''}`).join('\n'), ``);
-                if (code !== 0) {
-                    logLines.push(`=== Stderr (last 500 chars) ===`, stderr.slice(-500), ``);
+            const shouldWriteLog = isVerbose || code !== 0 || stdoutTruncated || stderrTruncated;
+            let logFile;
+            if (shouldWriteLog) {
+                const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+                logFile = path.join(logsDir, `container-${timestamp}.log`);
+                const logLines = [
+                    `=== Container Run Log ===`,
+                    `Timestamp: ${new Date().toISOString()}`,
+                    `Group: ${group.name}`,
+                    `IsMain: ${input.isMain}`,
+                    `Duration: ${duration}ms`,
+                    `Exit Code: ${code}`,
+                    `Stdout Truncated: ${stdoutTruncated}`,
+                    `Stderr Truncated: ${stderrTruncated}`,
+                    ``
+                ];
+                if (isVerbose) {
+                    logLines.push(`=== Input ===`, JSON.stringify(input, null, 2), ``, `=== Container Args ===`, containerArgs.join(' '), ``, `=== Mounts ===`, mounts.map(m => `${m.hostPath} -> ${m.containerPath}${m.readonly ? ' (ro)' : ''}`).join('\n'), ``, `=== Stderr${stderrTruncated ? ' (TRUNCATED)' : ''} ===`, stderr, ``, `=== Stdout${stdoutTruncated ? ' (TRUNCATED)' : ''} ===`, stdout);
                 }
+                else {
+                    logLines.push(`=== Input Summary ===`, `Prompt length: ${input.prompt.length} chars`, `Session ID: ${input.sessionId || 'new'}`, ``, `=== Mounts ===`, mounts.map(m => `${m.containerPath}${m.readonly ? ' (ro)' : ''}`).join('\n'), ``);
+                    if (code !== 0) {
+                        logLines.push(`=== Stderr (last 500 chars) ===`, stderr.slice(-500), ``);
+                    }
+                }
+                fs.writeFileSync(logFile, logLines.join('\n'));
+                logger.debug({ logFile, verbose: isVerbose }, 'Container log written');
             }
-            fs.writeFileSync(logFile, logLines.join('\n'));
-            logger.debug({ logFile, verbose: isVerbose }, 'Container log written');
             if (code !== 0) {
                 logger.error({
                     group: group.name,
@@ -928,81 +1164,118 @@ async function runContainerAgentDaemon(group, input, options) {
     const startTime = Date.now();
     const groupDir = path.join(GROUPS_DIR, group.folder);
     fs.mkdirSync(groupDir, { recursive: true });
-    const mounts = buildVolumeMounts(group, input.isMain);
-    ensureDaemonContainer(mounts, group.folder);
-    const { id: requestId, responsePath, requestPath } = writeAgentRequest(group.folder, input);
-    const requestsDir = path.join(DATA_DIR, 'ipc', group.folder, 'agent_requests');
     const timeoutMs = options?.timeoutMs || group.containerConfig?.timeout || CONTAINER_TIMEOUT;
     const abortSignal = options?.abortSignal;
-    const abortHandler = () => {
-        logger.warn({ group: group.name }, 'Daemon run preempted');
-        // Write cancel sentinel so daemon can detect the abort
-        const cancelPath = path.join(requestsDir, `${requestId}.cancel`);
-        try {
-            fs.writeFileSync(cancelPath, '');
-        }
-        catch { /* ignore */ }
-        try {
-            if (fs.existsSync(requestPath))
-                fs.unlinkSync(requestPath);
-        }
-        catch {
-            // ignore cleanup failure
+    const requestsDir = path.join(DATA_DIR, 'ipc', group.folder, 'agent_requests');
+    const maxAttempts = 2;
+    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+        ensureDaemonContainer(group, input.isMain);
+        const { id: requestId, responsePath, requestPath } = writeAgentRequest(group.folder, input);
+        let aborted = false;
+        const abortHandler = () => {
+            aborted = true;
+            logger.warn({ group: group.name }, 'Daemon run preempted');
+            const cancelPath = path.join(requestsDir, `${requestId}.cancel`);
+            try {
+                fs.writeFileSync(cancelPath, '');
+            }
+            catch { /* ignore */ }
+            try {
+                if (fs.existsSync(requestPath))
+                    fs.unlinkSync(requestPath);
+            }
+            catch {
+                // ignore cleanup failure
+            }
+            try {
+                if (fs.existsSync(responsePath))
+                    fs.unlinkSync(responsePath);
+            }
+            catch {
+                // ignore cleanup failure
+            }
+        };
+        if (abortSignal) {
+            if (abortSignal.aborted) {
+                abortHandler();
+                return {
+                    status: 'error',
+                    result: null,
+                    error: 'Daemon run preempted'
+                };
+            }
+            abortSignal.addEventListener('abort', abortHandler, { once: true });
         }
         try {
-            if (fs.existsSync(responsePath))
-                fs.unlinkSync(responsePath);
-        }
-        catch {
-            // ignore cleanup failure
+            const output = await waitForAgentResponse(responsePath, timeoutMs, abortSignal, {
+                groupFolder: group.folder,
+                requestId
+            });
+            const memoryExtractionError = consumeMemoryExtractionError(group.folder);
+            return {
+                ...output,
+                memory_extraction_error: output.memory_extraction_error || memoryExtractionError,
+                latency_ms: output.latency_ms ?? (Date.now() - startTime)
+            };
         }
-    };
-    if (abortSignal) {
-        if (abortSignal.aborted) {
-            abortHandler();
+        catch (err) {
+            const errorMessage = err instanceof Error ? err.message : String(err);
+            logger.error({ group: group.name, error: errorMessage, attempt }, 'Daemon agent error');
+            try {
+                if (fs.existsSync(requestPath))
+                    fs.unlinkSync(requestPath);
+            }
+            catch {
+                // ignore cleanup failure
+            }
+            try {
+                if (fs.existsSync(responsePath))
+                    fs.unlinkSync(responsePath);
+            }
+            catch {
+                // ignore cleanup failure
+            }
+            if (!aborted && !abortSignal?.aborted && attempt < maxAttempts && shouldRetryDaemonRequestError(errorMessage)) {
+                logger.warn({ group: group.name, attempt, error: errorMessage }, 'Retrying daemon request after restart');
+                try {
+                    gracefulRestartDaemonContainer(group, input.isMain);
+                    // Timeout errors usually indicate a stuck/slow daemon turn.
+                    // Avoid spending another full request timeout on the same model;
+                    // restart once and return the timeout so host-level failover can act.
+                    if (isDaemonTimeoutError(errorMessage)) {
+                        return {
+                            status: 'error',
+                            result: null,
+                            error: errorMessage
+                        };
+                    }
+                    continue;
+                }
+                catch (restartErr) {
+                    logger.error({
+                        group: group.name,
+                        attempt,
+                        error: restartErr instanceof Error ? restartErr.message : String(restartErr)
+                    }, 'Daemon restart failed during retry recovery');
+                }
+            }
             return {
                 status: 'error',
                 result: null,
-                error: 'Daemon run preempted'
+                error: errorMessage
             };
         }
-        abortSignal.addEventListener('abort', abortHandler, { once: true });
-    }
-    try {
-        const output = await waitForAgentResponse(responsePath, timeoutMs, abortSignal);
-        return {
-            ...output,
-            latency_ms: output.latency_ms ?? (Date.now() - startTime)
-        };
-    }
-    catch (err) {
-        const errorMessage = err instanceof Error ? err.message : String(err);
-        logger.error({ group: group.name, error: errorMessage }, 'Daemon agent error');
-        try {
-            if (fs.existsSync(requestPath))
-                fs.unlinkSync(requestPath);
-        }
-        catch {
-            // ignore cleanup failure
-        }
-        try {
-            if (fs.existsSync(responsePath))
-                fs.unlinkSync(responsePath);
-        }
-        catch {
-            // ignore cleanup failure
-        }
-        return {
-            status: 'error',
-            result: null,
-            error: errorMessage
-        };
-    }
-    finally {
-        if (abortSignal) {
-            abortSignal.removeEventListener('abort', abortHandler);
+        finally {
+            if (abortSignal) {
+                abortSignal.removeEventListener('abort', abortHandler);
+            }
         }
     }
+    return {
+        status: 'error',
+        result: null,
+        error: 'Daemon request failed'
+    };
 }
 /**
  * Stop all Docker containers belonging to this instance.
@@ -1010,6 +1283,7 @@ async function runContainerAgentDaemon(group, input, options) {
  */
 export function cleanupInstanceContainers() {
     try {
+        daemonBootstrapUntil.clear();
         let filterArgs;
         if (CONTAINER_INSTANCE_ID) {
             filterArgs = `--filter "label=dotclaw.instance=${CONTAINER_INSTANCE_ID}"`;