tlc-claude-code 2.0.1 → 2.1.0

package/server/lib/launchd-agent.js

@@ -0,0 +1,225 @@
+/**
+ * LaunchAgent plist generator for macOS.
+ *
+ * Generates, installs, and manages a macOS LaunchAgent that keeps
+ * the TLC server running permanently — auto-starts on login,
+ * auto-restarts on crash.
+ *
+ * @module launchd-agent
+ */
+
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+
+/** LaunchAgent label */
+const PLIST_LABEL = 'com.tlc.server';
+
+/** Default plist install location */
+const PLIST_PATH = path.join(os.homedir(), 'Library', 'LaunchAgents', `${PLIST_LABEL}.plist`);
+
+/**
+ * Generate a macOS LaunchAgent plist XML string.
+ *
+ * @param {object} opts
+ * @param {string} opts.projectRoot - Absolute path to the TLC project
+ * @param {number} [opts.port=3147] - Server port
+ * @returns {string} Valid XML plist
+ */
+function generatePlist(opts) {
+  const { projectRoot, port = 3147 } = opts;
+  const nodePath = process.execPath;
+  const serverScript = path.join(projectRoot, 'server', 'index.js');
+  const logDir = path.join(os.homedir(), '.tlc', 'logs');
+  const logFile = path.join(logDir, 'server.log');
+  const envPath = process.env.PATH || '/usr/local/bin:/usr/bin:/bin';
+
+  return `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+  <key>Label</key>
+  <string>${PLIST_LABEL}</string>
+
+  <key>ProgramArguments</key>
+  <array>
+    <string>${nodePath}</string>
+    <string>${serverScript}</string>
+  </array>
+
+  <key>WorkingDirectory</key>
+  <string>${projectRoot}</string>
+
+  <key>EnvironmentVariables</key>
+  <dict>
+    <key>PATH</key>
+    <string>${envPath}</string>
+    <key>HOME</key>
+    <string>${os.homedir()}</string>
+    <key>NODE_ENV</key>
+    <string>development</string>
+    <key>TLC_PORT</key>
+    <string>${port}</string>
+  </dict>
+
+  <key>KeepAlive</key>
+  <true/>
+
+  <key>ThrottleInterval</key>
+  <integer>10</integer>
+
+  <key>StandardOutPath</key>
+  <string>${logFile}</string>
+
+  <key>StandardErrorPath</key>
+  <string>${logFile}</string>
+</dict>
+</plist>
+`;
+}
+
+/**
+ * Write the plist file to disk.
+ *
+ * @param {object} opts
+ * @param {string} opts.projectRoot - Absolute path to the TLC project
+ * @param {string} [opts.targetDir] - Override install directory (for testing)
+ * @param {number} [opts.port=3147] - Server port
+ */
+function installAgent(opts) {
+  const targetDir = opts.targetDir || path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(targetDir, `${PLIST_LABEL}.plist`);
+
+  // Ensure log directory exists
+  const logDir = path.join(os.homedir(), '.tlc', 'logs');
+  if (!fs.existsSync(logDir)) {
+    fs.mkdirSync(logDir, { recursive: true });
+  }
+
+  // Ensure target directory exists
+  if (!fs.existsSync(targetDir)) {
+    fs.mkdirSync(targetDir, { recursive: true });
+  }
+
+  const xml = generatePlist(opts);
+  fs.writeFileSync(plistPath, xml, 'utf-8');
+}
+
+/**
+ * Remove the plist file from disk.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.targetDir] - Override install directory (for testing)
+ */
+function uninstallAgent(opts = {}) {
+  const targetDir = opts.targetDir || path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(targetDir, `${PLIST_LABEL}.plist`);
+
+  if (fs.existsSync(plistPath)) {
+    fs.unlinkSync(plistPath);
+  }
+}
+
+/**
+ * Check if the plist file is installed.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.targetDir] - Override install directory (for testing)
+ * @returns {boolean}
+ */
+function isInstalled(opts = {}) {
+  const targetDir = opts.targetDir || path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(targetDir, `${PLIST_LABEL}.plist`);
+  return fs.existsSync(plistPath);
+}
+
+/**
+ * Load the agent into launchd.
+ *
+ * @param {object} [opts]
+ * @param {Function} [opts.exec] - Async exec function (for testing)
+ * @param {string} [opts.targetDir] - Override install directory
+ * @returns {Promise<{ok: boolean, error?: string}>}
+ */
+async function loadAgent(opts = {}) {
+  const exec = opts.exec || defaultExec;
+  const targetDir = opts.targetDir || path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(targetDir, `${PLIST_LABEL}.plist`);
+
+  try {
+    await exec(`launchctl load -w ${plistPath}`);
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+/**
+ * Unload the agent from launchd and remove the plist.
+ *
+ * @param {object} [opts]
+ * @param {Function} [opts.exec] - Async exec function (for testing)
+ * @param {string} [opts.targetDir] - Override install directory
+ * @returns {Promise<{ok: boolean, error?: string}>}
+ */
+async function unloadAgent(opts = {}) {
+  const exec = opts.exec || defaultExec;
+  const targetDir = opts.targetDir || path.join(os.homedir(), 'Library', 'LaunchAgents');
+  const plistPath = path.join(targetDir, `${PLIST_LABEL}.plist`);
+
+  try {
+    await exec(`launchctl unload ${plistPath}`);
+  } catch {
+    // Agent may not be loaded — that's fine
+  }
+
+  uninstallAgent({ targetDir });
+  return { ok: true };
+}
+
+/**
+ * Check if the agent is loaded in launchd.
+ *
+ * @param {object} [opts]
+ * @param {Function} [opts.exec] - Async exec function (for testing)
+ * @returns {Promise<{loaded: boolean, pid?: number}>}
+ */
+async function statusAgent(opts = {}) {
+  const exec = opts.exec || defaultExec;
+
+  try {
+    const { stdout } = await exec(`launchctl list ${PLIST_LABEL}`);
+    const parts = stdout.trim().split('\t');
+    const pid = parts[0] && parts[0] !== '-' ? parseInt(parts[0], 10) : null;
+    return { loaded: true, pid };
+  } catch {
+    return { loaded: false };
+  }
+}
+
+/**
+ * Default exec using child_process.
+ * @param {string} cmd
+ * @returns {Promise<{stdout: string, stderr: string}>}
+ */
+function defaultExec(cmd) {
+  const { exec } = require('child_process');
+  return new Promise((resolve, reject) => {
+    exec(cmd, (err, stdout, stderr) => {
+      if (err) return reject(err);
+      resolve({ stdout, stderr });
+    });
+  });
+}
+
+module.exports = {
+  generatePlist,
+  installAgent,
+  uninstallAgent,
+  isInstalled,
+  loadAgent,
+  unloadAgent,
+  statusAgent,
+  PLIST_LABEL,
+  PLIST_PATH,
+};

package/server/lib/launchd-agent.test.js

@@ -0,0 +1,185 @@
+/**
+ * LaunchAgent plist generator tests - Phase 83 Task 1
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import path from 'path';
+import os from 'os';
+import fs from 'fs';
+
+import {
+  generatePlist,
+  installAgent,
+  uninstallAgent,
+  isInstalled,
+  loadAgent,
+  unloadAgent,
+  statusAgent,
+  PLIST_LABEL,
+  PLIST_PATH,
+} from './launchd-agent.js';
+
+describe('launchd-agent', () => {
+  describe('generatePlist', () => {
+    it('returns valid XML with correct label', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject' });
+      expect(xml).toContain('<?xml version="1.0"');
+      expect(xml).toContain('<!DOCTYPE plist');
+      expect(xml).toContain('<string>com.tlc.server</string>');
+    });
+
+    it('includes KeepAlive and ThrottleInterval', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject' });
+      expect(xml).toContain('<key>KeepAlive</key>');
+      expect(xml).toContain('<true/>');
+      expect(xml).toContain('<key>ThrottleInterval</key>');
+      expect(xml).toContain('<integer>10</integer>');
+    });
+
+    it('sets WorkingDirectory to project root', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject' });
+      expect(xml).toContain('<key>WorkingDirectory</key>');
+      expect(xml).toContain('<string>/Users/dev/myproject</string>');
+    });
+
+    it('sets EnvironmentVariables including PATH and NODE_ENV', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject' });
+      expect(xml).toContain('<key>EnvironmentVariables</key>');
+      expect(xml).toContain('<key>NODE_ENV</key>');
+      expect(xml).toContain('<string>development</string>');
+      expect(xml).toContain('<key>PATH</key>');
+    });
+
+    it('uses absolute node path in ProgramArguments', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject' });
+      expect(xml).toContain('<key>ProgramArguments</key>');
+      // Should contain path to node and path to server/index.js
+      expect(xml).toContain('server/index.js');
+    });
+
+    it('sets log paths under ~/.tlc/logs/', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject' });
+      expect(xml).toContain('<key>StandardOutPath</key>');
+      expect(xml).toContain('<key>StandardErrorPath</key>');
+      expect(xml).toContain('.tlc/logs/server.log');
+    });
+
+    it('allows custom port via opts', () => {
+      const xml = generatePlist({ projectRoot: '/Users/dev/myproject', port: 4000 });
+      expect(xml).toContain('<key>TLC_PORT</key>');
+      expect(xml).toContain('<string>4000</string>');
+    });
+  });
+
+  describe('installAgent', () => {
+    let tmpDir;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-launchd-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('writes plist file to target directory', () => {
+      const plistPath = path.join(tmpDir, 'com.tlc.server.plist');
+      installAgent({ projectRoot: '/Users/dev/myproject', targetDir: tmpDir });
+      expect(fs.existsSync(plistPath)).toBe(true);
+      const content = fs.readFileSync(plistPath, 'utf-8');
+      expect(content).toContain('com.tlc.server');
+    });
+  });
+
+  describe('uninstallAgent', () => {
+    let tmpDir;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-launchd-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('removes plist file', () => {
+      const plistPath = path.join(tmpDir, 'com.tlc.server.plist');
+      fs.writeFileSync(plistPath, '<plist/>');
+      uninstallAgent({ targetDir: tmpDir });
+      expect(fs.existsSync(plistPath)).toBe(false);
+    });
+  });
+
+  describe('isInstalled', () => {
+    let tmpDir;
+
+    beforeEach(() => {
+      tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-launchd-'));
+    });
+
+    afterEach(() => {
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+
+    it('returns true when plist exists', () => {
+      fs.writeFileSync(path.join(tmpDir, 'com.tlc.server.plist'), '<plist/>');
+      expect(isInstalled({ targetDir: tmpDir })).toBe(true);
+    });
+
+    it('returns false when plist does not exist', () => {
+      expect(isInstalled({ targetDir: tmpDir })).toBe(false);
+    });
+  });
+
+  describe('loadAgent', () => {
+    it('calls launchctl load with correct path', async () => {
+      const mockExec = vi.fn().mockResolvedValue({ stdout: '', stderr: '' });
+      const result = await loadAgent({ exec: mockExec, targetDir: '/tmp/agents' });
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.stringContaining('launchctl load'),
+      );
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.stringContaining('com.tlc.server.plist'),
+      );
+    });
+  });
+
+  describe('unloadAgent', () => {
+    it('calls launchctl unload then removes plist', async () => {
+      const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-launchd-'));
+      const plistPath = path.join(tmpDir, 'com.tlc.server.plist');
+      fs.writeFileSync(plistPath, '<plist/>');
+
+      const mockExec = vi.fn().mockResolvedValue({ stdout: '', stderr: '' });
+      await unloadAgent({ exec: mockExec, targetDir: tmpDir });
+
+      expect(mockExec).toHaveBeenCalledWith(
+        expect.stringContaining('launchctl unload'),
+      );
+      expect(fs.existsSync(plistPath)).toBe(false);
+
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('statusAgent', () => {
+    it('returns loaded when launchctl finds the agent', async () => {
+      const mockExec = vi.fn().mockResolvedValue({ stdout: '12345\t0\tcom.tlc.server', stderr: '' });
+      const result = await statusAgent({ exec: mockExec });
+      expect(result.loaded).toBe(true);
+      expect(result.pid).toBeDefined();
+    });
+
+    it('returns not loaded when launchctl does not find agent', async () => {
+      const mockExec = vi.fn().mockRejectedValue(new Error('Could not find service'));
+      const result = await statusAgent({ exec: mockExec });
+      expect(result.loaded).toBe(false);
+    });
+  });
+
+  describe('constants', () => {
+    it('exports correct plist label', () => {
+      expect(PLIST_LABEL).toBe('com.tlc.server');
+    });
+  });
+});

package/server/lib/memory-api.js

@@ -28,7 +28,7 @@
  * @param {object} deps.memoryStore - Memory store with list/get methods
  * @returns {object} Handler methods for each memory endpoint
  */
-export function createMemoryApi({ semanticRecall, vectorIndexer, richCapture, embeddingClient, memoryStore }) {
+function createMemoryApi({ semanticRecall, vectorIndexer, richCapture, embeddingClient, memoryStore }) {
 
   /**
    * Search memory semantically.
@@ -178,3 +178,5 @@ export function createMemoryApi({ semanticRecall, vectorIndexer, richCapture, em
     handleRemember,
   };
 }
+
+module.exports = { createMemoryApi };

package/server/lib/memory-api.test.js

@@ -1,6 +1,6 @@
 /**
  * @file memory-api.test.js
- * @description Tests for the Memory API endpoint handlers (Phase 74, Task 1).
+ * @description Tests for the Memory API endpoint handlers.
  *
  * Tests the factory function `createMemoryApi(deps)` which accepts injected
  * dependencies (semanticRecall, vectorIndexer, richCapture, embeddingClient,
@@ -11,7 +11,8 @@
  * routing is tested here.
  */
 import { describe, it, beforeEach, expect, vi } from 'vitest';
-import { createMemoryApi } from './memory-api.js';
+
+const { createMemoryApi } = await import('./memory-api.js');
 
 /**
  * Creates a mock Express request object.
@@ -294,7 +295,6 @@ describe('memory-api', () => {
     it('project filter works across endpoints', async () => {
       const projectId = 'proj-abc';
 
-      // Test project filter on conversations
       const convReq = createMockReq({ query: { project: projectId, page: '1', limit: '10' } });
       const convRes = createMockRes();
       await api.handleListConversations(convReq, convRes);
@@ -302,7 +302,6 @@ describe('memory-api', () => {
         expect.objectContaining({ project: projectId })
       );
 
-      // Test project filter on decisions
       const decReq = createMockReq({ query: { project: projectId } });
       const decRes = createMockRes();
       await api.handleListDecisions(decReq, decRes);
@@ -310,7 +309,6 @@ describe('memory-api', () => {
         expect.objectContaining({ project: projectId })
       );
 
-      // Test project filter on gotchas
       const gotReq = createMockReq({ query: { project: projectId } });
       const gotRes = createMockRes();
       await api.handleListGotchas(gotReq, gotRes);

package/server/lib/memory-bridge-e2e.test.js

@@ -0,0 +1,160 @@
+/**
+ * Memory Bridge E2E Tests - Phase 82 Task 5
+ *
+ * Tests the full pipeline: capture → observeAndRemember → pattern detect → file store.
+ * Proves the memory system achieves its original goal.
+ *
+ * RED: depends on capture-bridge.js (Task 1) and capture-guard.js (Task 4).
+ */
+
+import { describe, it, beforeEach, afterEach, expect, vi } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+
+import { captureExchange, drainSpool, SPOOL_FILENAME } from './capture-bridge.js';
+import { observeAndRemember } from './memory-observer.js';
+
+describe('memory-bridge e2e', () => {
+  let testDir;
+
+  beforeEach(() => {
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tlc-bridge-e2e-'));
+    // Create memory directory structure
+    fs.mkdirSync(path.join(testDir, '.tlc', 'memory', 'team', 'decisions'), { recursive: true });
+    fs.mkdirSync(path.join(testDir, '.tlc', 'memory', 'team', 'gotchas'), { recursive: true });
+    fs.mkdirSync(path.join(testDir, '.tlc', 'memory', '.local'), { recursive: true });
+    fs.writeFileSync(path.join(testDir, '.tlc.json'), JSON.stringify({ project: 'e2e-test' }));
+  });
+
+  afterEach(() => {
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  it('decision in exchange creates decision file', async () => {
+    // Pattern detector analyzes the user field for decision patterns
+    const exchange = {
+      user: "let's use PostgreSQL instead of MySQL because we need JSONB support.",
+      assistant: 'Good choice. PostgreSQL has excellent JSONB support.',
+    };
+
+    await observeAndRemember(testDir, exchange);
+
+    // Wait for setImmediate-based async processing
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    // Check that a decision file was created
+    const decisionsDir = path.join(testDir, '.tlc', 'memory', 'team', 'decisions');
+    const files = fs.readdirSync(decisionsDir);
+    expect(files.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('gotcha in exchange creates gotcha file', async () => {
+    // Pattern detector looks for "watch out for X" in user field
+    const exchange = {
+      user: 'watch out for the PGlite WASM driver under concurrent writes.',
+      assistant: 'Good catch. Serialize database operations to avoid crashes.',
+    };
+
+    await observeAndRemember(testDir, exchange);
+
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    const gotchasDir = path.join(testDir, '.tlc', 'memory', 'team', 'gotchas');
+    const files = fs.readdirSync(gotchasDir);
+    expect(files.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('full pipeline: captureExchange → observe → file stored', async () => {
+    // Simulate what the Stop hook does: POST to a mock server that calls observeAndRemember
+    let capturedExchange = null;
+
+    // Mock fetch that simulates the server calling observeAndRemember
+    const mockFetch = vi.fn().mockImplementation(async (url, opts) => {
+      const body = JSON.parse(opts.body);
+      for (const ex of body.exchanges) {
+        capturedExchange = ex;
+        await observeAndRemember(testDir, ex);
+      }
+      return { ok: true, json: async () => ({ captured: body.exchanges.length }) };
+    });
+
+    await captureExchange({
+      cwd: testDir,
+      // Pattern detector analyzes user field — put decision language there
+      assistantMessage: 'Good choice, JWT is better for horizontal scaling.',
+      userMessage: "let's use JWT tokens instead of sessions for authentication.",
+      sessionId: 'e2e-sess-1',
+    }, { fetch: mockFetch });
+
+    await new Promise(resolve => setTimeout(resolve, 300));
+
+    // Verify the exchange was captured
+    expect(capturedExchange).not.toBeNull();
+    expect(capturedExchange.user).toContain('JWT tokens');
+
+    // Verify a decision file was created
+    const decisionsDir = path.join(testDir, '.tlc', 'memory', 'team', 'decisions');
+    const files = fs.readdirSync(decisionsDir);
+    expect(files.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('spool entry captured after drain', async () => {
+    const spoolDir = path.join(testDir, '.tlc', 'memory');
+    const spoolPath = path.join(spoolDir, SPOOL_FILENAME);
+
+    // Write a spooled entry with a decision (pattern in user field)
+    const spooledEntry = JSON.stringify({
+      projectId: 'e2e-test',
+      exchanges: [{
+        user: "we decided to use SQLite for the vector store.",
+        assistant: 'SQLite embeds directly and needs no separate process.',
+        timestamp: Date.now(),
+      }],
+    });
+    fs.writeFileSync(spoolPath, spooledEntry + '\n');
+
+    // Mock fetch that calls observeAndRemember (like the real server would)
+    const mockFetch = vi.fn().mockImplementation(async (url, opts) => {
+      const body = JSON.parse(opts.body);
+      for (const ex of body.exchanges) {
+        await observeAndRemember(testDir, ex);
+      }
+      return { ok: true, json: async () => ({ captured: body.exchanges.length }) };
+    });
+
+    await drainSpool(spoolDir, { fetch: mockFetch });
+
+    await new Promise(resolve => setTimeout(resolve, 500));
+
+    // Spool should be drained
+    if (fs.existsSync(spoolPath)) {
+      expect(fs.readFileSync(spoolPath, 'utf-8').trim()).toBe('');
+    }
+
+    // Decision file should have been created from the spooled exchange
+    const decisionsDir = path.join(testDir, '.tlc', 'memory', 'team', 'decisions');
+    const files = fs.readdirSync(decisionsDir);
+    expect(files.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('capture guard deduplicates identical exchanges', async () => {
+    // Dedup happens at the capture guard level, not the observer
+    const { createCaptureGuard } = await import('./capture-guard.js');
+    const guard = createCaptureGuard();
+
+    const exchange = {
+      user: "we decided to use Redis as our caching layer.",
+      assistant: 'Redis is great for caching.',
+      timestamp: Date.now(),
+    };
+
+    // First call returns the exchange
+    const first = guard.deduplicate([exchange], 'e2e-test');
+    expect(first).toHaveLength(1);
+
+    // Same exchange immediately — deduplicated
+    const second = guard.deduplicate([exchange], 'e2e-test');
+    expect(second).toHaveLength(0);
+  });
+});

package/server/lib/memory-committer.js

@@ -23,7 +23,24 @@ async function detectUncommittedMemory(projectRoot) {
     return [];
   }
 
-  // Get all files in team directory
+  // Try git status first — only return modified/untracked files
+  try {
+    const teamRelative = path.relative(projectRoot, teamDir);
+    const { stdout } = await execAsync(
+      `git status --porcelain -- "${teamRelative}"`,
+      { cwd: projectRoot }
+    );
+    if (stdout.trim().length === 0) return [];
+
+    return stdout.trim().split('\n')
+      .map(line => line.slice(3).trim()) // strip status prefix (e.g. "?? ", " M ")
+      .filter(f => f.endsWith('.json') || f.endsWith('.md'))
+      .filter(f => !f.endsWith('conventions.md'));
+  } catch {
+    // Not a git repo or git not available — fall back to walkDir
+  }
+
+  // Fallback: return all files (non-git directory)
   const files = [];
 
   async function walkDir(dir) {
@@ -33,10 +50,7 @@ async function detectUncommittedMemory(projectRoot) {
       if (entry.isDirectory()) {
         await walkDir(fullPath);
       } else if (entry.name.endsWith('.json') || entry.name.endsWith('.md')) {
-        // Skip template files like conventions.md
         if (entry.name === 'conventions.md') continue;
-
-        // Get path relative to projectRoot
         const relativePath = path.relative(projectRoot, fullPath);
         files.push(relativePath);
       }

package/server/lib/memory-committer.test.js

@@ -58,6 +58,27 @@ describe('memory-committer', () => {
 
       expect(uncommitted.every(f => !f.includes('.local'))).toBe(true);
     });
+
+    // Phase 81 Task 4: detectUncommittedMemory should use git status
+    it('returns empty for already-committed files in a git repo', async () => {
+      // Create a git repo, add a decision, and commit it
+      const { execSync } = await import('child_process');
+      execSync('git init', { cwd: testDir, stdio: 'pipe' });
+      execSync('git config user.email "test@test.com"', { cwd: testDir, stdio: 'pipe' });
+      execSync('git config user.name "Test"', { cwd: testDir, stdio: 'pipe' });
+
+      await writeTeamDecision(testDir, {
+        title: 'Committed Decision',
+        reasoning: 'Already committed',
+      });
+
+      execSync('git add -A', { cwd: testDir, stdio: 'pipe' });
+      execSync('git commit -m "initial"', { cwd: testDir, stdio: 'pipe' });
+
+      // Now detect uncommitted — should be empty since everything is committed
+      const uncommitted = await detectUncommittedMemory(testDir);
+      expect(uncommitted).toHaveLength(0);
+    });
   });
 
   describe('generateCommitMessage', () => {