lsd-pi 1.1.4 → 1.1.6

package/src/resources/extensions/memory/dream.ts

@@ -58,27 +58,29 @@ function readJsonFile(path: string): Record<string, unknown> {
 }
 
 function parseAutoDreamSettings(source: Record<string, unknown>): Partial<AutoDreamSettings> {
+    // 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 as {
+    const nested = (memory && typeof memory === 'object') ? memory as {
         autoDream?: unknown;
         autoDreamMinHours?: unknown;
         autoDreamMinSessions?: unknown;
-    };
+    } : 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,
+        ...(enabledSource !== undefined ? { enabled: enabledSource } : {}),
         minHours:
-            typeof settings.autoDreamMinHours === 'number' && Number.isFinite(settings.autoDreamMinHours)
-                ? Math.max(1, settings.autoDreamMinHours)
+            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))
+            nested && typeof nested.autoDreamMinSessions === 'number' && Number.isFinite(nested.autoDreamMinSessions)
+                ? Math.max(1, Math.floor(nested.autoDreamMinSessions))
                 : DEFAULT_AUTO_DREAM_SETTINGS.minSessions,
     };
 }
@@ -383,6 +385,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 {
@@ -454,6 +463,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, [
@@ -488,9 +534,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');
 }
 
@@ -504,6 +559,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) : [];
@@ -539,7 +596,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);
@@ -548,12 +607,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);
@@ -563,12 +630,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');
 });
 `;
 

package/src/resources/extensions/memory/tests/auto-extract.test.ts

@@ -1,158 +1,214 @@
 import test, { describe } from 'node:test';
 import assert from 'node:assert/strict';
+import vm from 'node:vm';
 import { mkdirSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { buildTranscriptSummary, buildExtractionPrompt, stripAnsiForAutoExtractLog } from '../auto-extract.js';
+import { buildTranscriptSummary, buildExtractionPrompt, stripAnsiForAutoExtractLog, classifyAutoExtractLogLine, buildAutoExtractHelperScript } from '../auto-extract.js';
 
 function makeTempDir(): string {
-  const dir = join(tmpdir(), `mem-extract-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-  mkdirSync(dir, { recursive: true });
-  return dir;
+    const dir = join(tmpdir(), `mem-extract-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    return dir;
 }
 
 describe('buildTranscriptSummary', () => {
-  test('returns transcript even for a short conversation when there is user-authored content', () => {
-    const entries = [
-      { type: 'message', message: { role: 'user', content: 'hello' } },
-      { type: 'message', message: { role: 'assistant', content: 'hi' } },
-    ];
-    const summary = buildTranscriptSummary(entries);
-    assert.ok(summary.includes('User: hello'));
-    assert.ok(summary.includes('Assistant: hi'));
-  });
-
-  test('returns empty string for empty array', () => {
-    assert.equal(buildTranscriptSummary([]), '');
-  });
-
-  test('returns empty string when there is no user-authored content', () => {
-    const entries = [
-      { type: 'message', message: { role: 'assistant', content: 'hi' } },
-    ];
-    assert.equal(buildTranscriptSummary(entries), '');
-  });
-
-  test('extracts user and assistant text messages', () => {
-    const entries = [
-      { type: 'message', message: { role: 'user', content: 'hello' } },
-      { type: 'message', message: { role: 'assistant', content: 'hi there' } },
-      { type: 'message', message: { role: 'user', content: 'how are you' } },
-    ];
-    const summary = buildTranscriptSummary(entries);
-    assert.ok(summary.includes('User: hello'));
-    assert.ok(summary.includes('Assistant: hi there'));
-    assert.ok(summary.includes('User: how are you'));
-  });
-
-  test('skips entries where type !== message', () => {
-    const entries = [
-      { type: 'other', data: 'ignored' },
-      { type: 'message', message: { role: 'user', content: 'hello' } },
-      { type: 'tool_result', id: '1', content: 'ignored' },
-      { type: 'message', message: { role: 'assistant', content: 'hi' } },
-      { type: 'message', message: { role: 'user', content: 'test' } },
-    ];
-    const summary = buildTranscriptSummary(entries);
-    assert.ok(summary.includes('User: hello'));
-    assert.ok(summary.includes('Assistant: hi'));
-    assert.ok(summary.includes('User: test'));
-  });
-
-  test('handles array content (multi-part), includes only text', () => {
-    const entries = [
-      { type: 'message', message: { role: 'user', content: [{ type: 'text', text: 'hello' }, { type: 'tool_use', id: '1', name: 'bash', input: {} }] } },
-      { type: 'message', message: { role: 'assistant', content: 'response' } },
-      { type: 'message', message: { role: 'user', content: 'end' } },
-    ];
-    const summary = buildTranscriptSummary(entries);
-    assert.ok(summary.includes('User: hello'));
-    assert.ok(!summary.includes('tool_use'));
-    assert.ok(summary.includes('Assistant: response'));
-    assert.ok(summary.includes('User: end'));
-  });
-
-  test('truncates messages over 2000 chars', () => {
-    const longText = 'a'.repeat(3000);
-    const entries = [
-      { type: 'message', message: { role: 'user', content: 'start' } },
-      { type: 'message', message: { role: 'assistant', content: longText } },
-      { type: 'message', message: { role: 'user', content: 'end' } },
-    ];
-    const summary = buildTranscriptSummary(entries);
-    assert.ok(summary.includes('…'));
-    assert.ok(summary.length < 4000); // Should be truncated
-  });
-
-  test('labels user messages with User: and assistant with Assistant:', () => {
-    const entries = [
-      { type: 'message', message: { role: 'user', content: 'question' } },
-      { type: 'message', message: { role: 'assistant', content: 'answer' } },
-      { type: 'message', message: { role: 'user', content: 'thanks' } },
-    ];
-    const summary = buildTranscriptSummary(entries);
-    assert.ok(summary.includes('User:'));
-    assert.ok(summary.includes('Assistant:'));
-  });
+    test('returns transcript even for a short conversation when there is user-authored content', () => {
+        const entries = [
+            { type: 'message', message: { role: 'user', content: 'hello' } },
+            { type: 'message', message: { role: 'assistant', content: 'hi' } },
+        ];
+        const summary = buildTranscriptSummary(entries);
+        assert.ok(summary.includes('User: hello'));
+        assert.ok(summary.includes('Assistant: hi'));
+    });
+
+    test('returns empty string for empty array', () => {
+        assert.equal(buildTranscriptSummary([]), '');
+    });
+
+    test('returns empty string when there is no user-authored content', () => {
+        const entries = [
+            { type: 'message', message: { role: 'assistant', content: 'hi' } },
+        ];
+        assert.equal(buildTranscriptSummary(entries), '');
+    });
+
+    test('extracts user and assistant text messages', () => {
+        const entries = [
+            { type: 'message', message: { role: 'user', content: 'hello' } },
+            { type: 'message', message: { role: 'assistant', content: 'hi there' } },
+            { type: 'message', message: { role: 'user', content: 'how are you' } },
+        ];
+        const summary = buildTranscriptSummary(entries);
+        assert.ok(summary.includes('User: hello'));
+        assert.ok(summary.includes('Assistant: hi there'));
+        assert.ok(summary.includes('User: how are you'));
+    });
+
+    test('skips entries where type !== message', () => {
+        const entries = [
+            { type: 'other', data: 'ignored' },
+            { type: 'message', message: { role: 'user', content: 'hello' } },
+            { type: 'tool_result', id: '1', content: 'ignored' },
+            { type: 'message', message: { role: 'assistant', content: 'hi' } },
+            { type: 'message', message: { role: 'user', content: 'test' } },
+        ];
+        const summary = buildTranscriptSummary(entries);
+        assert.ok(summary.includes('User: hello'));
+        assert.ok(summary.includes('Assistant: hi'));
+        assert.ok(summary.includes('User: test'));
+    });
+
+    test('handles array content (multi-part), includes only text', () => {
+        const entries = [
+            { type: 'message', message: { role: 'user', content: [{ type: 'text', text: 'hello' }, { type: 'tool_use', id: '1', name: 'bash', input: {} }] } },
+            { type: 'message', message: { role: 'assistant', content: 'response' } },
+            { type: 'message', message: { role: 'user', content: 'end' } },
+        ];
+        const summary = buildTranscriptSummary(entries);
+        assert.ok(summary.includes('User: hello'));
+        assert.ok(!summary.includes('tool_use'));
+        assert.ok(summary.includes('Assistant: response'));
+        assert.ok(summary.includes('User: end'));
+    });
+
+    test('truncates messages over 2000 chars', () => {
+        const longText = 'a'.repeat(3000);
+        const entries = [
+            { type: 'message', message: { role: 'user', content: 'start' } },
+            { type: 'message', message: { role: 'assistant', content: longText } },
+            { type: 'message', message: { role: 'user', content: 'end' } },
+        ];
+        const summary = buildTranscriptSummary(entries);
+        assert.ok(summary.includes('…'));
+        assert.ok(summary.length < 4000); // Should be truncated
+    });
+
+    test('labels user messages with User: and assistant with Assistant:', () => {
+        const entries = [
+            { type: 'message', message: { role: 'user', content: 'question' } },
+            { type: 'message', message: { role: 'assistant', content: 'answer' } },
+            { type: 'message', message: { role: 'user', content: 'thanks' } },
+        ];
+        const summary = buildTranscriptSummary(entries);
+        assert.ok(summary.includes('User:'));
+        assert.ok(summary.includes('Assistant:'));
+    });
+});
+
+describe('buildAutoExtractHelperScript', () => {
+    test('preserves regex escapes in the generated helper source', () => {
+        const script = buildAutoExtractHelperScript();
+
+        assert.ok(script.includes(String.raw`const CACHE_TIMER_RE = /^\[phase\]\s+cache-timer(?:\s*:\s*.*)?\s*$/i;`));
+        assert.ok(script.includes(String.raw`const SESSION_ENDED_RE = /^\[agent\]\s+Session ended/;`));
+        assert.ok(script.includes(String.raw`const HEADLESS_STATUS_RE = /^\[headless\]\s+Status:\s+(\w+)\s*$/i;`));
+        assert.ok(script.includes(String.raw`const parts = pendingLogText.split(/\r?\n/);`));
+        assert.ok(script.includes(`appendFileSync(logPath, kept.join('\\n') + '\\n')`));
+    });
+
+    test('generates syntactically valid helper code', () => {
+        const script = buildAutoExtractHelperScript();
+        assert.doesNotThrow(() => new vm.Script(script));
+    });
 });
 
 describe('buildExtractionPrompt', () => {
-  test('strips ANSI codes so session-end and cache-timer lines can be classified', () => {
-    const coloredSessionEnd = '\u001b[36m[agent]   Session ended\u001b[0m';
-    const coloredCacheTimer = '\u001b[36m[phase]   cache-timer\u001b[0m';
-
-    assert.equal(stripAnsiForAutoExtractLog(coloredSessionEnd), '[agent]   Session ended');
-    assert.equal(stripAnsiForAutoExtractLog(coloredCacheTimer), '[phase]   cache-timer');
-  });
-
-  test('contains the memory directory path in output', () => {
-    const memoryDir = '/tmp/test-memory';
-    const entries = [
-      { type: 'message', message: { role: 'user', content: 'test1' } },
-      { type: 'message', message: { role: 'assistant', content: 'test2' } },
-      { type: 'message', message: { role: 'user', content: 'test3' } },
-    ];
-    const prompt = buildExtractionPrompt(memoryDir, buildTranscriptSummary(entries));
-    assert.ok(prompt.includes(memoryDir));
-  });
-
-  test('contains the transcript in output', () => {
-    const memoryDir = '/tmp/test-memory';
-    const entries = [
-      { type: 'message', message: { role: 'user', content: 'hello world' } },
-      { type: 'message', message: { role: 'assistant', content: 'response' } },
-      { type: 'message', message: { role: 'user', content: 'end' } },
-    ];
-    const prompt = buildExtractionPrompt(memoryDir, buildTranscriptSummary(entries));
-    assert.ok(prompt.includes('User: hello world'));
-    assert.ok(prompt.includes('Assistant: response'));
-  });
-
-  test('contains "None yet" when memory dir is empty', () => {
-    const memoryDir = makeTempDir();
-    const cleanup = () => rmSync(memoryDir, { recursive: true, force: true });
-
-    try {
-      const entries = [
-        { type: 'message', message: { role: 'user', content: 'test1' } },
-        { type: 'message', message: { role: 'assistant', content: 'test2' } },
-        { type: 'message', message: { role: 'user', content: 'test3' } },
-      ];
-      const prompt = buildExtractionPrompt(memoryDir, buildTranscriptSummary(entries));
-      assert.ok(prompt.includes('None yet'));
-    } finally {
-      cleanup();
-    }
-  });
-
-  test('contains extraction rules (Save ONLY)', () => {
-    const memoryDir = '/tmp/test-memory';
-    const entries = [
-      { type: 'message', message: { role: 'user', content: 'test1' } },
-      { type: 'message', message: { role: 'assistant', content: 'test2' } },
-      { type: 'message', message: { role: 'user', content: 'test3' } },
-    ];
-    const prompt = buildExtractionPrompt(memoryDir, buildTranscriptSummary(entries));
-    assert.ok(prompt.includes('Save ONLY'));
-  });
+    test('strips ANSI codes so session-end and cache-timer lines can be classified', () => {
+        const coloredSessionEnd = '\u001b[36m[agent]   Session ended\u001b[0m';
+        const coloredCacheTimer = '\u001b[36m[phase]   cache-timer\u001b[0m';
+
+        assert.equal(stripAnsiForAutoExtractLog(coloredSessionEnd), '[agent]   Session ended');
+        assert.equal(stripAnsiForAutoExtractLog(coloredCacheTimer), '[phase]   cache-timer');
+    });
+
+    test('classifies cache-timer lines as ignorable noise', () => {
+        assert.deepEqual(classifyAutoExtractLogLine('[phase]   cache-timer'), {
+            stripped: '[phase]   cache-timer',
+            keep: false,
+            completion: 'none',
+            completionReason: null,
+        });
+    });
+
+    test('classifies cache-timer lines with rendered values as ignorable noise', () => {
+        assert.deepEqual(classifyAutoExtractLogLine('[phase]   cache-timer: ⏱ 0:05'), {
+            stripped: '[phase]   cache-timer: ⏱ 0:05',
+            keep: false,
+            completion: 'none',
+            completionReason: null,
+        });
+    });
+
+    test('classifies headless completion as a successful terminal signal', () => {
+        assert.deepEqual(classifyAutoExtractLogLine('[headless] Status: complete'), {
+            stripped: '[headless] Status: complete',
+            keep: true,
+            completion: 'success',
+            completionReason: 'headless_status_complete',
+        });
+    });
+
+    test('classifies non-complete headless statuses as failures', () => {
+        assert.deepEqual(classifyAutoExtractLogLine('[headless] Status: timeout'), {
+            stripped: '[headless] Status: timeout',
+            keep: true,
+            completion: 'failure',
+            completionReason: 'headless_status_timeout',
+        });
+    });
+
+    test('contains the memory directory path in output', () => {
+        const memoryDir = '/tmp/test-memory';
+        const entries = [
+            { type: 'message', message: { role: 'user', content: 'test1' } },
+            { type: 'message', message: { role: 'assistant', content: 'test2' } },
+            { type: 'message', message: { role: 'user', content: 'test3' } },
+        ];
+        const prompt = buildExtractionPrompt(memoryDir, buildTranscriptSummary(entries));
+        assert.ok(prompt.includes(memoryDir));
+    });
+
+    test('contains the transcript in output', () => {
+        const memoryDir = '/tmp/test-memory';
+        const entries = [
+            { type: 'message', message: { role: 'user', content: 'hello world' } },
+            { type: 'message', message: { role: 'assistant', content: 'response' } },
+            { type: 'message', message: { role: 'user', content: 'end' } },
+        ];
+        const prompt = buildExtractionPrompt(memoryDir, buildTranscriptSummary(entries));
+        assert.ok(prompt.includes('User: hello world'));
+        assert.ok(prompt.includes('Assistant: response'));
+    });
+
+    test('contains "None yet" when memory dir is empty', () => {
+        const memoryDir = makeTempDir();
+        const cleanup = () => rmSync(memoryDir, { recursive: true, force: true });
+
+        try {
+            const entries = [
+                { type: 'message', message: { role: 'user', content: 'test1' } },
+                { type: 'message', message: { role: 'assistant', content: 'test2' } },
+                { type: 'message', message: { role: 'user', content: 'test3' } },
+            ];
+            const prompt = buildExtractionPrompt(memoryDir, buildTranscriptSummary(entries));
+            assert.ok(prompt.includes('None yet'));
+        } finally {
+            cleanup();
+        }
+    });
+
+    test('contains extraction rules (Save ONLY)', () => {
+        const memoryDir = '/tmp/test-memory';
+        const entries = [
+            { type: 'message', message: { role: 'user', content: 'test1' } },
+            { type: 'message', message: { role: 'assistant', content: 'test2' } },
+            { type: 'message', message: { role: 'user', content: 'test3' } },
+        ];
+        const prompt = buildExtractionPrompt(memoryDir, buildTranscriptSummary(entries));
+        assert.ok(prompt.includes('Save ONLY'));
+        assert.ok(prompt.includes('raw code snippets'));
+        assert.ok(!prompt.includes('Do NOT save: code patterns, architecture'));
+    });
 });

package/src/resources/extensions/shared/rtk.js

@@ -0,0 +1,112 @@
+import { spawnSync } from 'node:child_process'
+import { existsSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { delimiter, join } from 'node:path'
+
+const GSD_RTK_PATH_ENV = 'GSD_RTK_PATH'
+const GSD_RTK_DISABLED_ENV = 'GSD_RTK_DISABLED'
+const GSD_RTK_REWRITE_TIMEOUT_MS_ENV = 'GSD_RTK_REWRITE_TIMEOUT_MS'
+const RTK_TELEMETRY_DISABLED_ENV = 'RTK_TELEMETRY_DISABLED'
+const RTK_REWRITE_TIMEOUT_MS = 5_000
+
+function isTruthy(value) {
+  if (!value) return false
+  const normalized = value.trim().toLowerCase()
+  return normalized === '1' || normalized === 'true' || normalized === 'yes'
+}
+
+function getRewriteTimeoutMs(env = process.env) {
+  const configured = Number.parseInt(env[GSD_RTK_REWRITE_TIMEOUT_MS_ENV] ?? '', 10)
+  if (Number.isFinite(configured) && configured > 0) return configured
+  return RTK_REWRITE_TIMEOUT_MS
+}
+
+export function isRtkEnabled(env = process.env) {
+  return !isTruthy(env[GSD_RTK_DISABLED_ENV])
+}
+
+export function buildRtkEnv(env = process.env) {
+  return {
+    ...env,
+    [RTK_TELEMETRY_DISABLED_ENV]: '1',
+  }
+}
+
+function getManagedRtkDir(env = process.env) {
+  return join(env.GSD_HOME || join(homedir(), '.lsd'), 'agent', 'bin')
+}
+
+function getRtkBinaryName(platform = process.platform) {
+  return platform === 'win32' ? 'rtk.exe' : 'rtk'
+}
+
+function getPathValue(env) {
+  const pathKey = Object.keys(env).find((key) => key.toLowerCase() === 'path')
+  return pathKey ? env[pathKey] : env.PATH
+}
+
+function resolvePathCandidates(pathValue) {
+  if (!pathValue) return []
+  return pathValue
+    .split(delimiter)
+    .map((part) => part.trim())
+    .filter(Boolean)
+}
+
+function resolveSystemRtkPath(pathValue, platform = process.platform) {
+  const candidates = platform === 'win32'
+    ? ['rtk.exe', 'rtk.cmd', 'rtk.bat', 'rtk']
+    : ['rtk']
+
+  for (const dir of resolvePathCandidates(pathValue)) {
+    for (const candidate of candidates) {
+      const fullPath = join(dir, candidate)
+      if (existsSync(fullPath)) return fullPath
+    }
+  }
+
+  return null
+}
+
+export function resolveRtkBinaryPath(options = {}) {
+  const env = options.env ?? process.env
+  const platform = options.platform ?? process.platform
+
+  const explicitPath = options.binaryPath ?? env[GSD_RTK_PATH_ENV]
+  if (explicitPath && existsSync(explicitPath)) return explicitPath
+
+  const managedDir = getManagedRtkDir(env)
+  const managedPath = join(managedDir, getRtkBinaryName(platform))
+  if (existsSync(managedPath)) return managedPath
+  if (platform === 'win32') {
+    const managedCmd = join(managedDir, 'rtk.cmd')
+    if (existsSync(managedCmd)) return managedCmd
+  }
+
+  return resolveSystemRtkPath(options.pathValue ?? getPathValue(env), platform)
+}
+
+export function rewriteCommandWithRtk(command, options = {}) {
+  const env = options.env ?? process.env
+
+  if (!command.trim()) return command
+  if (!isRtkEnabled(env)) return command
+
+  const binaryPath = options.binaryPath ?? resolveRtkBinaryPath({ env })
+  if (!binaryPath) return command
+
+  const run = options.spawnSyncImpl ?? spawnSync
+  const result = run(binaryPath, ['rewrite', command], {
+    encoding: 'utf-8',
+    env: buildRtkEnv(env),
+    stdio: ['ignore', 'pipe', 'ignore'],
+    timeout: getRewriteTimeoutMs(env),
+    shell: /\.(cmd|bat)$/i.test(binaryPath),
+  })
+
+  if (result.error) return command
+  if (result.status !== 0 && result.status !== 3) return command
+
+  const rewritten = (result.stdout ?? '').trimEnd()
+  return rewritten || command
+}