lsd-pi 1.1.4 → 1.1.6

package/dist/resources/extensions/memory/auto-extract.js

@@ -15,9 +15,63 @@ import { getMemoryDir } from './memory-paths.js';
 import { scanMemoryFiles, formatMemoryManifest } from './memory-scan.js';
 import { normalizeSubagentModel } from '../subagent/model-resolution.js';
 const AUTO_EXTRACT_ANSI_PATTERN = /\u001B\[[0-?]*[ -/]*[@-~]/g;
+const AUTO_EXTRACT_CACHE_TIMER_RE = /^\[phase\]\s+cache-timer(?:\s*:\s*.*)?\s*$/i;
+const AUTO_EXTRACT_SESSION_ENDED_RE = /^\[agent\]\s+Session ended/;
+const AUTO_EXTRACT_HEADLESS_STATUS_RE = /^\[headless\]\s+Status:\s+(\w+)\s*$/i;
 export function stripAnsiForAutoExtractLog(text) {
     return text.replace(AUTO_EXTRACT_ANSI_PATTERN, '');
 }
+export function classifyAutoExtractLogLine(rawLine) {
+    const stripped = stripAnsiForAutoExtractLog(rawLine).trim();
+    if (!stripped) {
+        return {
+            stripped,
+            keep: false,
+            completion: 'none',
+            completionReason: null,
+        };
+    }
+    if (AUTO_EXTRACT_CACHE_TIMER_RE.test(stripped)) {
+        return {
+            stripped,
+            keep: false,
+            completion: 'none',
+            completionReason: null,
+        };
+    }
+    if (AUTO_EXTRACT_SESSION_ENDED_RE.test(stripped)) {
+        return {
+            stripped,
+            keep: true,
+            completion: 'success',
+            completionReason: 'session_end_detected',
+        };
+    }
+    const headlessStatusMatch = stripped.match(AUTO_EXTRACT_HEADLESS_STATUS_RE);
+    if (headlessStatusMatch) {
+        const status = headlessStatusMatch[1].toLowerCase();
+        if (status === 'complete') {
+            return {
+                stripped,
+                keep: true,
+                completion: 'success',
+                completionReason: 'headless_status_complete',
+            };
+        }
+        return {
+            stripped,
+            keep: true,
+            completion: 'failure',
+            completionReason: `headless_status_${status}`,
+        };
+    }
+    return {
+        stripped,
+        keep: true,
+        completion: 'none',
+        completionReason: null,
+    };
+}
 /**
  * Build a plain-text transcript from session entries, keeping only
  * human-readable message content (no tool_use / tool_result blocks).
@@ -72,7 +126,7 @@ This directory already exists — write files directly.
 
 Rules:
 - Save ONLY: user preferences/role, feedback/corrections, project context (deadlines, decisions), external references
-- Do NOT save: code patterns, architecture, file paths, git history, debugging steps, ephemeral task details
+- Do NOT save: raw code snippets, low-level implementation details, file paths, git history, one-off debugging steps, ephemeral task details
 - Check existing memories below — update existing files rather than creating duplicates
 - Use frontmatter: ---\\nname: ...\\ndescription: ...\\ntype: user|feedback|project|reference\\n---
 - After writing topic files, update MEMORY.md with one-line index entries
@@ -124,62 +178,8 @@ export function readBudgetMemoryModel() {
         return undefined;
     }
 }
-/**
- * Main entry point — called from the session_shutdown hook.
- *
- * Reads the conversation transcript, builds an extraction prompt,
- * and spawns a detached headless agent to process it.
- * Fire-and-forget: the parent can exit without killing the child.
- */
-export function extractMemories(ctx, cwd) {
-    // Guard: prevent recursive extraction
-    if (process.env.LSD_MEMORY_EXTRACT === '1')
-        return;
-    // Guard: user opt-out
-    if (process.env.CLAUDE_CODE_DISABLE_AUTO_MEMORY)
-        return;
-    const entries = ctx.sessionManager.getEntries();
-    // Guard: need at least one user message to extract from
-    const userMessageCount = entries.filter((e) => e.type === 'message' && e.message?.role === 'user').length;
-    if (userMessageCount < 1)
-        return;
-    const transcript = buildTranscriptSummary(entries);
-    if (!transcript)
-        return;
-    const memoryDir = getMemoryDir(cwd);
-    mkdirSync(memoryDir, { recursive: true });
-    const prompt = buildExtractionPrompt(memoryDir, transcript);
-    const auditPath = join(memoryDir, '.last-auto-extract.txt');
-    const logPath = join(memoryDir, '.last-auto-extract.log');
-    // Write prompt to a temp file so the spawned agent can read it
-    const tmpPromptPath = join(tmpdir(), `lsd-memory-extract-${randomUUID()}.md`);
-    writeFileSync(tmpPromptPath, prompt, 'utf-8');
-    const cliPath = resolveCliPath();
-    const budgetModel = readBudgetMemoryModel();
-    if (!cliPath) {
-        writeFileSync(auditPath, [
-            `timestamp: ${new Date().toISOString()}`,
-            'status: skipped',
-            'reason: cli_path_not_found',
-            `cwd: ${cwd}`,
-            `userMessages: ${userMessageCount}`,
-            `transcriptLength: ${transcript.length}`,
-            `budgetModel: ${budgetModel ?? 'default'}`,
-        ].join('\n') + '\n', 'utf-8');
-        return;
-    }
-    writeFileSync(auditPath, [
-        `timestamp: ${new Date().toISOString()}`,
-        'status: spawning',
-        `cwd: ${cwd}`,
-        `userMessages: ${userMessageCount}`,
-        `transcriptLength: ${transcript.length}`,
-        `cliPath: ${cliPath}`,
-        `budgetModel: ${budgetModel ?? 'default'}`,
-        `logPath: ${logPath}`,
-    ].join('\n') + '\n', 'utf-8');
-    const instruction = 'Extract memories from the transcript above. Write any worth-saving memories to the memory directory, then update MEMORY.md.';
-    const helperScript = `
+export function buildAutoExtractHelperScript() {
+    return String.raw `
 const { spawn } = require('node:child_process');
 const { appendFileSync, writeFileSync, readFileSync, readdirSync, statSync, existsSync } = require('node:fs');
 const { join, delimiter } = require('node:path');
@@ -187,41 +187,67 @@ const { join, delimiter } = require('node:path');
 const [cliPath, cwd, tmpPromptPath, auditPath, logPath, memoryDir, instruction, model, userMessageCount, transcriptLength] = process.argv.slice(1);
 const startedAt = new Date().toISOString();
 let finalized = false;
-let sawSessionEnded = false;
-let sessionEndTimer = null;
+let completionState = null;
+let completionTimer = null;
 let hardTimeout = null;
 let pendingLogText = '';
 const ANSI_PATTERN = /\u001B\[[0-?]*[ -/]*[@-~]/g;
+const CACHE_TIMER_RE = /^\[phase\]\s+cache-timer(?:\s*:\s*.*)?\s*$/i;
+const SESSION_ENDED_RE = /^\[agent\]\s+Session ended/;
+const HEADLESS_STATUS_RE = /^\[headless\]\s+Status:\s+(\w+)\s*$/i;
 
 function stripAnsi(text) {
   return String(text).replace(ANSI_PATTERN, '');
 }
 
+function classifyLogLine(rawLine) {
+  const stripped = stripAnsi(rawLine).trim();
+  if (!stripped) {
+    return { stripped, keep: false, completion: null, completionReason: null };
+  }
+  if (CACHE_TIMER_RE.test(stripped)) {
+    return { stripped, keep: false, completion: null, completionReason: null };
+  }
+  if (SESSION_ENDED_RE.test(stripped)) {
+    return { stripped, keep: true, completion: 'finished', completionReason: 'session_end_detected' };
+  }
+  const headlessStatusMatch = stripped.match(HEADLESS_STATUS_RE);
+  if (headlessStatusMatch) {
+    const status = String(headlessStatusMatch[1] || '').toLowerCase();
+    if (status === 'complete') {
+      return { stripped, keep: true, completion: 'finished', completionReason: 'headless_status_complete' };
+    }
+    return { stripped, keep: true, completion: 'failed', completionReason: 'headless_status_' + status };
+  }
+  return { stripped, keep: true, completion: null, completionReason: null };
+}
+
+function scheduleCompletion(completion, completionReason) {
+  if (!completion || completionState || completionTimer) return;
+  completionState = { completion, completionReason };
+  completionTimer = setTimeout(() => {
+    finalize(completion, completion === 'finished' ? 0 : 1, null, completionReason);
+    try { child.kill('SIGTERM'); } catch {}
+    setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 2000).unref();
+  }, 1500);
+  completionTimer.unref();
+}
+
 function flushLogText(text, force = false) {
   pendingLogText += text;
-  const parts = pendingLogText.split(/\r?\n/);
+  const parts = pendingLogText.split(/(?:\r?\n|\r)/);
   pendingLogText = force ? '' : (parts.pop() ?? '');
 
   const kept = [];
   for (const rawLine of parts) {
-    const line = stripAnsi(rawLine).trim();
-    if (!line) continue;
-    if (/^\[phase\]\s+cache-timer\s*$/.test(line)) continue;
-    kept.push(rawLine);
-    if (/^\[agent\]\s+Session ended/.test(line)) {
-      sawSessionEnded = true;
+    const classified = classifyLogLine(rawLine);
+    if (classified.keep) kept.push(rawLine);
+    if (classified.completion) {
+      scheduleCompletion(classified.completion, classified.completionReason);
     }
   }
 
   if (kept.length > 0) appendFileSync(logPath, kept.join('\n') + '\n');
-  if (sawSessionEnded && !sessionEndTimer) {
-    sessionEndTimer = setTimeout(() => {
-      finalize('finished', 0, null, 'session_end_detected');
-      try { child.kill('SIGTERM'); } catch {}
-      setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 2000).unref();
-    }, 1500);
-    sessionEndTimer.unref();
-  }
 }
 
 function appendLog(chunk) {
@@ -243,7 +269,7 @@ function writeAudit(status, extra = []) {
       'model: ' + (model || 'default'),
       'logPath: ' + logPath,
       ...extra,
-    ].join('\\n') + '\\n', 'utf-8');
+    ].join('\n') + '\n', 'utf-8');
   } catch {}
 }
 
@@ -265,7 +291,7 @@ function newestMemoryMtime(dir) {
 function finalize(status, code, signal, completionReason) {
   if (finalized) return;
   finalized = true;
-  if (sessionEndTimer) clearTimeout(sessionEndTimer);
+  if (completionTimer) clearTimeout(completionTimer);
   if (hardTimeout) clearTimeout(hardTimeout);
   const afterMtime = newestMemoryMtime(memoryDir);
   const logText = existsSync(logPath) ? readFileSync(logPath, 'utf-8') : '';
@@ -292,7 +318,10 @@ const bundledPaths = Array.from(
   new Set(
     [process.env.GSD_BUNDLED_EXTENSION_PATHS, process.env.LSD_BUNDLED_EXTENSION_PATHS]
       .filter(Boolean)
-      .flatMap((value) => String(value).split(delimiter).map((entry) => entry.trim()).filter(Boolean)),
+      .flatMap((value) => String(value).split(delimiter).map((entry) => entry.trim()).filter(Boolean))
+      // Explicitly disable cache-timer extension for auto-memory workers.
+      // It is noisy in headless logs and provides no value for maintenance runs.
+      .filter((entry) => !/[\\/]cache-timer[\\/]/i.test(entry)),
   ),
 );
 for (const extensionPath of bundledPaths) childArgs.push('--extension', extensionPath);
@@ -302,11 +331,25 @@ childArgs.push('--bare', '--context', tmpPromptPath, '--context-text', instructi
 const child = spawn(
   process.execPath,
   childArgs,
-  { cwd, env: { ...process.env, LSD_MEMORY_EXTRACT: '1' }, stdio: ['ignore', 'pipe', 'pipe'] },
+  {
+    cwd,
+    env: {
+      ...process.env,
+      LSD_MEMORY_EXTRACT: '1',
+      // Hard-disable cache timer in maintenance workers.
+      LSD_DISABLE_CACHE_TIMER: '1',
+      // Memory maintenance workers must not run in auto permission mode.
+      // In auto mode, write/edit calls require classifier approval, but headless
+      // maintenance workers have no interactive classifier responder.
+      // Keep writes safe via extension-level path restrictions instead.
+      LUCENT_CODE_PERMISSION_MODE: 'danger-full-access',
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+  },
 );
 
 hardTimeout = setTimeout(() => {
-  finalize('failed', null, 'timeout', sawSessionEnded ? 'hung_after_session_end' : 'timeout');
+  finalize('failed', null, 'timeout', completionState?.completionReason ?? 'timeout');
   try { child.kill('SIGTERM'); } catch {}
   setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 2000).unref();
 }, 120000);
@@ -315,7 +358,7 @@ hardTimeout.unref();
 child.stdout.on('data', appendLog);
 child.stderr.on('data', appendLog);
 child.on('error', (err) => {
-  appendLog(String(err && err.stack ? err.stack : err) + '\\n');
+  appendLog(String(err && err.stack ? err.stack : err) + '\n');
   flushLogText('', true);
   finalize('failed', null, 'spawn_error', String(err && err.message ? err.message : err));
 });
@@ -324,6 +367,79 @@ child.on('exit', (code, signal) => {
   finalize(code === 0 ? 'finished' : 'failed', code, signal, 'child_exit');
 });
 `;
+}
+/**
+ * Main entry point — called from the session_shutdown hook.
+ *
+ * Reads the conversation transcript, builds an extraction prompt,
+ * and spawns a detached headless agent to process it.
+ * Fire-and-forget: the parent can exit without killing the child.
+ */
+function readAutoMemoryEnabled() {
+    try {
+        const settingsPath = join(getAgentDir(), 'settings.json');
+        if (!existsSync(settingsPath))
+            return false;
+        const raw = readFileSync(settingsPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return parsed.autoMemory === true;
+    }
+    catch {
+        return false;
+    }
+}
+export function extractMemories(ctx, cwd) {
+    // Guard: prevent recursive extraction
+    if (process.env.LSD_MEMORY_EXTRACT === '1')
+        return;
+    // Guard: user opt-out via env var
+    if (process.env.CLAUDE_CODE_DISABLE_AUTO_MEMORY)
+        return;
+    // Guard: auto memory must be enabled in settings (default: disabled)
+    if (!readAutoMemoryEnabled())
+        return;
+    const entries = ctx.sessionManager.getEntries();
+    // Guard: need at least one user message to extract from
+    const userMessageCount = entries.filter((e) => e.type === 'message' && e.message?.role === 'user').length;
+    if (userMessageCount < 1)
+        return;
+    const transcript = buildTranscriptSummary(entries);
+    if (!transcript)
+        return;
+    const memoryDir = getMemoryDir(cwd);
+    mkdirSync(memoryDir, { recursive: true });
+    const prompt = buildExtractionPrompt(memoryDir, transcript);
+    const auditPath = join(memoryDir, '.last-auto-extract.txt');
+    const logPath = join(memoryDir, '.last-auto-extract.log');
+    // Write prompt to a temp file so the spawned agent can read it
+    const tmpPromptPath = join(tmpdir(), `lsd-memory-extract-${randomUUID()}.md`);
+    writeFileSync(tmpPromptPath, prompt, 'utf-8');
+    const cliPath = resolveCliPath();
+    const budgetModel = readBudgetMemoryModel();
+    if (!cliPath) {
+        writeFileSync(auditPath, [
+            `timestamp: ${new Date().toISOString()}`,
+            'status: skipped',
+            'reason: cli_path_not_found',
+            `cwd: ${cwd}`,
+            `userMessages: ${userMessageCount}`,
+            `transcriptLength: ${transcript.length}`,
+            `budgetModel: ${budgetModel ?? 'default'}`,
+        ].join('\n') + '\n', 'utf-8');
+        return;
+    }
+    writeFileSync(auditPath, [
+        `timestamp: ${new Date().toISOString()}`,
+        'status: spawning',
+        `cwd: ${cwd}`,
+        `userMessages: ${userMessageCount}`,
+        `transcriptLength: ${transcript.length}`,
+        `cliPath: ${cliPath}`,
+        `budgetModel: ${budgetModel ?? 'default'}`,
+        `logPath: ${logPath}`,
+    ].join('\n') + '\n', 'utf-8');
+    const instruction = 'Extract memories from the transcript above. Write any worth-saving memories to the memory directory, then update MEMORY.md.';
+    const helperScript = buildAutoExtractHelperScript();
     const proc = spawn(process.execPath, [
         '-e',
         helperScript,

package/dist/resources/extensions/memory/dream.js

@@ -34,19 +34,21 @@ function readJsonFile(path) {
     }
 }
 function parseAutoDreamSettings(source) {
+    // Check top-level autoDream field first (set via /settings UI)
+    const topLevel = source.autoDream;
     const memory = source.memory;
-    if (!memory || typeof memory !== 'object')
-        return {};
-    const settings = memory;
+    const nested = (memory && typeof memory === 'object') ? memory : undefined;
+    // Top-level takes precedence for enabled; nested.memory for thresholds
+    const enabledSource = typeof topLevel === 'boolean' ? topLevel
+        : nested && typeof nested.autoDream === 'boolean' ? nested.autoDream
+            : undefined;
     return {
-        enabled: typeof settings.autoDream === 'boolean'
-            ? settings.autoDream
-            : DEFAULT_AUTO_DREAM_SETTINGS.enabled,
-        minHours: typeof settings.autoDreamMinHours === 'number' && Number.isFinite(settings.autoDreamMinHours)
-            ? Math.max(1, settings.autoDreamMinHours)
+        ...(enabledSource !== undefined ? { enabled: enabledSource } : {}),
+        minHours: nested && typeof nested.autoDreamMinHours === 'number' && Number.isFinite(nested.autoDreamMinHours)
+            ? Math.max(1, nested.autoDreamMinHours)
             : DEFAULT_AUTO_DREAM_SETTINGS.minHours,
-        minSessions: typeof settings.autoDreamMinSessions === 'number' && Number.isFinite(settings.autoDreamMinSessions)
-            ? Math.max(1, Math.floor(settings.autoDreamMinSessions))
+        minSessions: nested && typeof nested.autoDreamMinSessions === 'number' && Number.isFinite(nested.autoDreamMinSessions)
+            ? Math.max(1, Math.floor(nested.autoDreamMinSessions))
             : DEFAULT_AUTO_DREAM_SETTINGS.minSessions,
     };
 }
@@ -320,6 +322,13 @@ const { join, delimiter } = require('node:path');
 const [cliPath, cwd, tmpPromptPath, auditPath, logPath, memoryDir, sessionDir, instruction, model, trigger, priorMtime, sessionCount] = process.argv.slice(1);
 let finalized = false;
 let pendingLogText = '';
+let completionState = null;
+let completionTimer = null;
+let hardTimeout = null;
+const ANSI_PATTERN = /\u001B\[[0-?]*[ -/]*[@-~]/g;
+const CACHE_TIMER_RE = /^\[phase\]\s+cache-timer(?:\s*:\s*.*)?\s*$/i;
+const SESSION_ENDED_RE = /^\[agent\]\s+Session ended/;
+const HEADLESS_STATUS_RE = /^\[headless\]\s+Status:\s+(\w+)\s*$/i;
 
 function newestMemoryMtime(dir) {
 	try {
@@ -391,6 +400,43 @@ function pruneBrokenMemoryRefs(dir) {
 	}
 }
 
+function stripAnsi(text) {
+	return String(text).replace(ANSI_PATTERN, '');
+}
+
+function classifyLogLine(rawLine) {
+	const stripped = stripAnsi(rawLine).trim();
+	if (!stripped) {
+		return { stripped, keep: false, completion: null, completionReason: null };
+	}
+	if (CACHE_TIMER_RE.test(stripped)) {
+		return { stripped, keep: false, completion: null, completionReason: null };
+	}
+	if (SESSION_ENDED_RE.test(stripped)) {
+		return { stripped, keep: true, completion: 'finished', completionReason: 'session_end_detected' };
+	}
+	const headlessStatusMatch = stripped.match(HEADLESS_STATUS_RE);
+	if (headlessStatusMatch) {
+		const status = String(headlessStatusMatch[1] || '').toLowerCase();
+		if (status === 'complete') {
+			return { stripped, keep: true, completion: 'finished', completionReason: 'headless_status_complete' };
+		}
+		return { stripped, keep: true, completion: 'failed', completionReason: 'headless_status_' + status };
+	}
+	return { stripped, keep: true, completion: null, completionReason: null };
+}
+
+function scheduleCompletion(completion, completionReason) {
+	if (!completion || completionState || completionTimer) return;
+	completionState = { completion, completionReason };
+	completionTimer = setTimeout(() => {
+		finalize(completion, completion === 'finished' ? 0 : 1, null, completionReason);
+		try { child.kill('SIGTERM'); } catch {}
+		setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 2000).unref();
+	}, 1500);
+	completionTimer.unref();
+}
+
 function writeAudit(status, extra = []) {
 	try {
 		writeFileSync(auditPath, [
@@ -425,9 +471,18 @@ function rollbackLock() {
 
 function flushLogText(text, force = false) {
 	pendingLogText += text;
-	const parts = pendingLogText.split(/\r?\n/);
+	const parts = pendingLogText.split(/(?:\r?\n|\r)/);
 	pendingLogText = force ? '' : (parts.pop() ?? '');
-	const kept = parts.filter((line) => line.trim());
+
+	const kept = [];
+	for (const rawLine of parts) {
+		const classified = classifyLogLine(rawLine);
+		if (classified.keep) kept.push(rawLine);
+		if (classified.completion) {
+			scheduleCompletion(classified.completion, classified.completionReason);
+		}
+	}
+
 	if (kept.length > 0) appendFileSync(logPath, kept.join('\n') + '\n');
 }
 
@@ -441,6 +496,8 @@ function appendLog(chunk) {
 function finalize(status, code, signal, completionReason) {
 	if (finalized) return;
 	finalized = true;
+	if (completionTimer) clearTimeout(completionTimer);
+	if (hardTimeout) clearTimeout(hardTimeout);
 	flushLogText('', true);
 	const beforeBrokenRefs = listBrokenMemoryRefs(memoryDir);
 	const prunedRefs = beforeBrokenRefs.length > 0 ? pruneBrokenMemoryRefs(memoryDir) : [];
@@ -476,7 +533,9 @@ const bundledPaths = Array.from(
 	new Set(
 		[process.env.GSD_BUNDLED_EXTENSION_PATHS, process.env.LSD_BUNDLED_EXTENSION_PATHS]
 			.filter(Boolean)
-			.flatMap((value) => String(value).split(delimiter).map((entry) => entry.trim()).filter(Boolean)),
+			.flatMap((value) => String(value).split(delimiter).map((entry) => entry.trim()).filter(Boolean))
+			// Explicitly disable cache-timer extension for dream workers.
+			.filter((entry) => !/[\\/]cache-timer[\\/]/i.test(entry)),
 	),
 );
 for (const extensionPath of bundledPaths) childArgs.push('--extension', extensionPath);
@@ -485,12 +544,20 @@ childArgs.push('--bare', '--context', tmpPromptPath, '--context-text', instructi
 
 const child = spawn(process.execPath, childArgs, {
 	cwd,
-	env: { ...process.env, LSD_MEMORY_DREAM: '1' },
+	env: {
+		...process.env,
+		LSD_MEMORY_DREAM: '1',
+		// Hard-disable cache timer in maintenance workers.
+		LSD_DISABLE_CACHE_TIMER: '1',
+		// Dream workers run headless and cannot answer auto-mode classifier prompts.
+		// Force non-auto permissions and rely on memory-extension path/tool guards.
+		LUCENT_CODE_PERMISSION_MODE: 'danger-full-access',
+	},
 	stdio: ['ignore', 'pipe', 'pipe'],
 });
 
-const hardTimeout = setTimeout(() => {
-	finalize('failed', null, 'timeout', 'timeout');
+hardTimeout = setTimeout(() => {
+	finalize('failed', null, 'timeout', completionState?.completionReason ?? 'timeout');
 	try { child.kill('SIGTERM'); } catch {}
 	setTimeout(() => { try { child.kill('SIGKILL'); } catch {} }, 2000).unref();
 }, 180000);
@@ -500,12 +567,12 @@ child.stdout.on('data', appendLog);
 child.stderr.on('data', appendLog);
 child.on('error', (err) => {
 	appendLog(String(err && err.stack ? err.stack : err) + '\n');
-	clearTimeout(hardTimeout);
+	flushLogText('', true);
 	finalize('failed', null, 'spawn_error', String(err && err.message ? err.message : err));
 });
 child.on('exit', (code, signal) => {
-	clearTimeout(hardTimeout);
-	finalize(code === 0 ? 'finished' : 'failed', code, signal, 'child_exit');
+	flushLogText('', true);
+	finalize(code === 0 ? 'finished' : 'failed', code, signal, completionState?.completionReason ?? 'child_exit');
 });
 `;
     const proc = spawn(process.execPath, [