lsd-pi 1.1.2 → 1.1.3

package/src/resources/extensions/memory/extension-manifest.json

@@ -5,7 +5,7 @@
   "description": "Persistent file-based memory across sessions",
   "tier": "bundled",
   "provides": {
-    "hooks": ["session_start", "before_agent_start", "session_shutdown"],
-    "commands": ["memories", "remember", "forget"]
+    "hooks": ["session_start", "before_agent_start", "turn_end", "tool_call", "session_shutdown"],
+    "commands": ["memories", "remember", "forget", "dream", "auto-dream"]
   }
 }

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

@@ -8,27 +8,33 @@
  * indexed by a MEMORY.md entrypoint that is always loaded into context.
  */
 
-import type { ExtensionAPI, ExtensionContext } from '@gsd/pi-coding-agent';
+import {
+	isToolCallEventType,
+	type ExtensionAPI,
+} from '@gsd/pi-coding-agent';
 import { readFileSync, existsSync, writeFileSync } from 'node:fs';
 import { getMemoryDir, getMemoryEntrypoint, ensureMemoryDir } from './memory-paths.js';
 import {
-	MEMORY_TYPES,
 	MEMORY_FRONTMATTER_EXAMPLE,
 	TYPES_SECTION,
 	WHAT_NOT_TO_SAVE_SECTION,
 	WHEN_TO_ACCESS_SECTION,
 	TRUSTING_RECALL_SECTION,
 } from './memory-types.js';
-import { scanMemoryFiles, formatMemoryManifest } from './memory-scan.js';
+import { scanMemoryFiles } from './memory-scan.js';
 import { memoryAge } from './memory-age.js';
-import { findRelevantMemories } from './memory-recall.js';
 import { extractMemories } from './auto-extract.js';
+import {
+	formatDreamStatus,
+	isMaintenanceModeToolAllowed,
+	maybeStartAutoDream,
+	readAutoDreamSettings,
+	setProjectAutoDreamEnabled,
+	startDream,
+} from './dream.js';
 
 // ── Constants ────────────────────────────────────────────────────────
 
-/** Name of the entrypoint file that indexes all memories. */
-const ENTRYPOINT_NAME = 'MEMORY.md';
-
 /** Maximum number of lines loaded from MEMORY.md into context. */
 const MAX_ENTRYPOINT_LINES = 200;
 
@@ -144,14 +150,17 @@ ${MEMORY_FRONTMATTER_EXAMPLE.join('\n')}
  * Memory extension for LSD.
  *
  * Lifecycle:
- *   session_start     → bootstrap memory directory & MEMORY.md
+ *   session_start      → bootstrap memory directory & MEMORY.md
  *   before_agent_start → inject memory system prompt
+ *   turn_end           → check auto-dream gates and start background consolidation
  *   session_shutdown   → fire-and-forget auto-extract of new memories
  *
  * Commands:
- *   /memories  — list all saved memories
- *   /remember  — save a memory immediately
- *   /forget    — remove a memory by topic
+ *   /memories    — list all saved memories
+ *   /remember    — save a memory immediately
+ *   /forget      — remove a memory by topic
+ *   /dream       — run memory consolidation now or show dream status
+ *   /auto-dream  — enable/disable/show auto-dream status
  */
 export default function memoryExtension(pi: ExtensionAPI) {
 	let memoryCwd: string = '';
@@ -194,11 +203,52 @@ export default function memoryExtension(pi: ExtensionAPI) {
 		};
 	});
 
+	// ── turn_end: check auto-dream gates ───────────────────────────────
+	pi.on('turn_end', async (_event, ctx) => {
+		if (!memoryCwd) return;
+		const result = maybeStartAutoDream(ctx);
+		if (result.started) {
+			pi.sendMessage({
+				customType: 'memory:auto-dream',
+				content: result.message,
+				display: true,
+			});
+		}
+	});
+
+	// ── tool_call: restrict background maintenance workers ─────────────
+	pi.on('tool_call', async (event, ctx) => {
+		if (!(process.env.LSD_MEMORY_EXTRACT === '1' || process.env.LSD_MEMORY_DREAM === '1')) return;
+
+		if (isMaintenanceModeToolAllowed(event.toolName, event.input as { path?: string; command?: string }, ctx.cwd)) {
+			return;
+		}
+
+		if (isToolCallEventType('write', event) || isToolCallEventType('edit', event)) {
+			return {
+				block: true,
+				reason: `Memory maintenance workers may only write inside the memory directory. Blocked path: ${event.input.path}`,
+			};
+		}
+
+		if (isToolCallEventType('bash', event)) {
+			return {
+				block: true,
+				reason: 'Memory maintenance workers may only run read-only bash commands.',
+			};
+		}
+
+		return {
+			block: true,
+			reason: `Tool ${event.toolName} is blocked for memory maintenance workers.`,
+		};
+	});
+
 	// ── session_shutdown: trigger auto-extract ────────────────────────
 	pi.on('session_shutdown', async (_event, ctx) => {
 		if (!memoryCwd) return;
-		// Don't extract if this IS the extraction agent
-		if (process.env.LSD_MEMORY_EXTRACT === '1') return;
+		// Don't extract if this IS the extraction or dream worker
+		if (process.env.LSD_MEMORY_EXTRACT === '1' || process.env.LSD_MEMORY_DREAM === '1') return;
 		try {
 			extractMemories(ctx, memoryCwd);
 		} catch {
@@ -260,4 +310,75 @@ export default function memoryExtension(pi: ExtensionAPI) {
 			pi.sendUserMessage(`Please find and remove any memories about: ${topic}`);
 		},
 	});
+
+	/**
+	 * /dream — run a consolidation pass now, or show dream status.
+	 */
+	pi.registerCommand('dream', {
+		description: 'Run memory consolidation now or show dream status',
+		handler: async (args, ctx) => {
+			if (!memoryCwd) return;
+			const subcommand = args.trim().toLowerCase();
+			if (subcommand === 'status') {
+				pi.sendMessage({
+					customType: 'memory:dream-status',
+					content: formatDreamStatus(ctx),
+					display: true,
+				});
+				return;
+			}
+
+			const result = startDream(ctx, { trigger: 'manual' });
+			pi.sendMessage({
+				customType: 'memory:dream',
+				content: result.message,
+				display: true,
+			});
+		},
+	});
+
+	/**
+	 * /auto-dream — enable, disable, or inspect project auto-dream.
+	 */
+	pi.registerCommand('auto-dream', {
+		description: 'Enable, disable, or show project auto-dream status',
+		handler: async (args, ctx) => {
+			if (!memoryCwd) return;
+			const subcommand = args.trim().toLowerCase();
+
+			if (subcommand === 'on') {
+				const settings = setProjectAutoDreamEnabled(memoryCwd, true);
+				pi.sendMessage({
+					customType: 'memory:auto-dream-settings',
+					content: `Auto-dream enabled for this project. Thresholds: ${settings.minHours}h / ${settings.minSessions} sessions.`,
+					display: true,
+				});
+				return;
+			}
+
+			if (subcommand === 'off') {
+				const settings = setProjectAutoDreamEnabled(memoryCwd, false);
+				pi.sendMessage({
+					customType: 'memory:auto-dream-settings',
+					content: `Auto-dream disabled for this project. Thresholds remain ${settings.minHours}h / ${settings.minSessions} sessions.`,
+					display: true,
+				});
+				return;
+			}
+
+			const settings = readAutoDreamSettings(memoryCwd);
+			pi.sendMessage({
+				customType: 'memory:auto-dream-status',
+				content: [
+					'Auto-Dream Settings',
+					'',
+					`- Enabled: ${settings.enabled ? 'yes' : 'no'}`,
+					`- Thresholds: ${settings.minHours}h / ${settings.minSessions} sessions`,
+					'',
+					formatDreamStatus(ctx),
+				].join('\n'),
+				display: true,
+			});
+		},
+	});
 }

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

@@ -1,9 +1,9 @@
 import test, { describe } from 'node:test';
 import assert from 'node:assert/strict';
-import { mkdirSync, writeFileSync, rmSync } from 'node:fs';
+import { mkdirSync, rmSync } from 'node:fs';
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
-import { buildTranscriptSummary, buildExtractionPrompt } from '../auto-extract.js';
+import { buildTranscriptSummary, buildExtractionPrompt, stripAnsiForAutoExtractLog } from '../auto-extract.js';
 
 function makeTempDir(): string {
   const dir = join(tmpdir(), `mem-extract-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
@@ -97,6 +97,14 @@ describe('buildTranscriptSummary', () => {
 });
 
 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 = [

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

@@ -0,0 +1,142 @@
+import assert from 'node:assert/strict';
+import { mkdirSync, readFileSync, rmSync, statSync, utimesSync, writeFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import test, { describe } from 'node:test';
+import {
+    __testing,
+    buildConsolidationPrompt,
+    readAutoDreamSettings,
+    setProjectAutoDreamEnabled,
+} from '../dream.js';
+
+function makeTempDir(): string {
+    const dir = join(tmpdir(), `memory-dream-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    return dir;
+}
+
+describe('buildConsolidationPrompt', () => {
+    test('includes the dream consolidation framing and paths', () => {
+        const prompt = buildConsolidationPrompt('/tmp/memory', '/tmp/sessions');
+        assert.match(prompt, /Dream: Memory Consolidation/);
+        assert.match(prompt, /reflective pass over existing memory files/);
+        assert.match(prompt, /Validate every MEMORY\.md link and repair or remove broken pointers/);
+        assert.match(prompt, /always target absolute paths inside \/tmp\/memory/);
+        assert.match(prompt, /\/tmp\/memory/);
+        assert.match(prompt, /\/tmp\/sessions/);
+    });
+});
+
+describe('auto-dream settings', () => {
+    test('writes and reads project auto-dream state', () => {
+        const cwd = makeTempDir();
+        const agentDir = makeTempDir();
+        const previous = process.env.LSD_CODING_AGENT_DIR;
+        process.env.LSD_CODING_AGENT_DIR = agentDir;
+
+        try {
+            const before = readAutoDreamSettings(cwd);
+            assert.equal(before.enabled, false);
+            assert.equal(before.minHours, 24);
+            assert.equal(before.minSessions, 5);
+
+            const after = setProjectAutoDreamEnabled(cwd, true);
+            assert.equal(after.enabled, true);
+            assert.equal(after.minHours, 24);
+            assert.equal(after.minSessions, 5);
+        } finally {
+            if (previous === undefined) {
+                delete process.env.LSD_CODING_AGENT_DIR;
+            } else {
+                process.env.LSD_CODING_AGENT_DIR = previous;
+            }
+            rmSync(cwd, { recursive: true, force: true });
+            rmSync(agentDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe('listBrokenMemoryIndexEntries', () => {
+    test('reports broken MEMORY.md pointers and ignores valid ones', () => {
+        const memoryDir = makeTempDir();
+        const validFile = join(memoryDir, 'feedback.md');
+        const nestedDir = join(memoryDir, 'nested');
+        const entrypoint = join(memoryDir, 'MEMORY.md');
+
+        try {
+            mkdirSync(nestedDir, { recursive: true });
+            writeFileSync(validFile, 'ok\n', 'utf-8');
+            writeFileSync(join(nestedDir, 'present.md'), 'ok\n', 'utf-8');
+            writeFileSync(
+                entrypoint,
+                [
+                    '- [Valid](feedback.md) — ok',
+                    '- [Nested](nested/present.md) — ok',
+                    '- [Missing](missing.md) — missing',
+                    '- [Escapes](../outside.md) — invalid',
+                    '- [External](https://example.com) — ignore',
+                ].join('\n') + '\n',
+                'utf-8',
+            );
+
+            const broken = __testing.listBrokenMemoryIndexEntries(memoryDir);
+            assert.deepEqual(broken, ['../outside.md', 'missing.md']);
+        } finally {
+            rmSync(memoryDir, { recursive: true, force: true });
+        }
+    });
+
+    test('prunes broken MEMORY.md pointers and keeps valid lines', () => {
+        const memoryDir = makeTempDir();
+        const entrypoint = join(memoryDir, 'MEMORY.md');
+        const validFile = join(memoryDir, 'feedback.md');
+
+        try {
+            writeFileSync(validFile, 'ok\n', 'utf-8');
+            writeFileSync(
+                entrypoint,
+                [
+                    '- [Valid](feedback.md) — ok',
+                    '- [Missing](missing.md) — missing',
+                    '- [Escapes](../outside.md) — invalid',
+                ].join('\n') + '\n',
+                'utf-8',
+            );
+
+            const pruned = __testing.pruneBrokenMemoryIndexEntries(memoryDir);
+            assert.deepEqual(pruned, ['../outside.md', 'missing.md']);
+            assert.equal(readFileSync(entrypoint, 'utf-8'), '- [Valid](feedback.md) — ok\n');
+        } finally {
+            rmSync(memoryDir, { recursive: true, force: true });
+        }
+    });
+});
+
+describe('listSessionsTouchedSince', () => {
+    test('counts touched session files and excludes the current session file', () => {
+        const sessionDir = makeTempDir();
+        const older = join(sessionDir, 'older.jsonl');
+        const newer = join(sessionDir, 'newer.jsonl');
+        const current = join(sessionDir, 'current.jsonl');
+
+        try {
+            writeFileSync(older, '{}\n', 'utf-8');
+            writeFileSync(newer, '{}\n', 'utf-8');
+            writeFileSync(current, '{}\n', 'utf-8');
+
+            const olderTime = Date.now() - 10 * 60 * 1000;
+            const newerTime = Date.now() - 60 * 1000;
+            utimesSync(older, olderTime / 1000, olderTime / 1000);
+            utimesSync(newer, newerTime / 1000, newerTime / 1000);
+            utimesSync(current, newerTime / 1000, newerTime / 1000);
+
+            const sinceMs = statSync(older).mtimeMs + 1000;
+            const touched = __testing.listSessionsTouchedSince(sessionDir, sinceMs, current);
+            assert.equal(touched.length, 1);
+            assert.equal(touched[0], newer);
+        } finally {
+            rmSync(sessionDir, { recursive: true, force: true });
+        }
+    });
+});

package/src/resources/extensions/slash-commands/extension-manifest.json

@@ -1,12 +1,12 @@
 {
-  "id": "slash-commands",
-  "name": "Slash Commands",
-  "version": "1.0.0",
-  "description": "Boilerplate generators for slash commands, extensions, and audit tools",
-  "tier": "bundled",
-  "requires": { "platform": ">=2.29.0" },
-  "provides": {
-    "commands": ["create-slash-command", "create-extension", "audit", "clear", "plan", "execute", "cancel-plan"],
-    "flags": ["plan"]
-  }
+	"id": "slash-commands",
+	"name": "Slash Commands",
+	"version": "1.0.0",
+	"description": "Bundled slash commands for audit, clearing state, and plan workflows",
+	"tier": "bundled",
+	"requires": { "platform": ">=2.29.0" },
+	"provides": {
+		"commands": ["audit", "clear", "plan", "execute", "cancel-plan"],
+		"flags": ["plan"]
+	}
 }

package/src/resources/extensions/slash-commands/index.ts

@@ -1,14 +1,10 @@
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
-import createSlashCommand from "./create-slash-command.js";
-import createExtension from "./create-extension.js";
 import auditCommand from "./audit.js";
 import clearCommand from "./clear.js";
 import planCommand from "./plan.js";
 
 export default function slashCommands(pi: ExtensionAPI) {
-  createSlashCommand(pi);
-  createExtension(pi);
-  auditCommand(pi);
-  clearCommand(pi);
-  planCommand(pi);
+	auditCommand(pi);
+	clearCommand(pi);
+	planCommand(pi);
 }