tlc-claude-code 2.5.0 → 2.6.1

package/server/lib/orchestration/completion-checker.test.js

@@ -0,0 +1,177 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+
+const { checkCompletions } = require('./completion-checker.js');
+
+function makeSession(overrides = {}) {
+  return {
+    sessionId: 'session-1',
+    taskName: 'Task 1',
+    startedAt: '2026-03-30T08:00:00.000Z',
+    ...overrides,
+  };
+}
+
+function writeSessionsFile(activeSessionsPath, sessions) {
+  fs.mkdirSync(path.dirname(activeSessionsPath), { recursive: true });
+  fs.writeFileSync(activeSessionsPath, JSON.stringify(sessions, null, 2));
+}
+
+describe('completion-checker', () => {
+  const tempDirs = [];
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+    while (tempDirs.length > 0) {
+      fs.rmSync(tempDirs.pop(), { recursive: true, force: true });
+    }
+  });
+
+  function makeActiveSessionsPath() {
+    const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'completion-checker-test-'));
+    tempDirs.push(tempDir);
+    return path.join(tempDir, '.tlc', '.active-sessions.json');
+  }
+
+  it('returns empty when there are no active sessions', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    writeSessionsFile(activeSessionsPath, []);
+
+    const fetch = vi.fn();
+    const result = await checkCompletions({
+      activeSessionsPath,
+      orchestratorUrl: 'http://orchestrator.test',
+      fetch,
+    });
+
+    expect(result).toEqual({
+      completions: [],
+      failures: [],
+      stillRunning: 0,
+    });
+    expect(fetch).not.toHaveBeenCalled();
+    expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([]);
+  });
+
+  it('reports a completed session and removes it from the file', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    writeSessionsFile(activeSessionsPath, [makeSession()]);
+
+    const fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ status: 'completed' }),
+    });
+
+    const result = await checkCompletions({
+      activeSessionsPath,
+      orchestratorUrl: 'http://orchestrator.test',
+      fetch,
+    });
+
+    expect(fetch).toHaveBeenCalledWith('http://orchestrator.test/sessions/session-1');
+    expect(result).toEqual({
+      completions: [makeSession()],
+      failures: [],
+      stillRunning: 0,
+    });
+    expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([]);
+  });
+
+  it('reports a failed session with reason', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    writeSessionsFile(activeSessionsPath, [makeSession()]);
+
+    const fetch = vi.fn().mockResolvedValue({
+      ok: true,
+      json: async () => ({ status: 'failed', reason: 'Tests failed' }),
+    });
+
+    const result = await checkCompletions({
+      activeSessionsPath,
+      orchestratorUrl: 'http://orchestrator.test',
+      fetch,
+    });
+
+    expect(result).toEqual({
+      completions: [],
+      failures: [{ ...makeSession(), reason: 'Tests failed' }],
+      stillRunning: 0,
+    });
+    expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([]);
+  });
+
+  it('handles multiple sessions with mixed running and completed states', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const running = makeSession({ sessionId: 'session-1', taskName: 'Task 1' });
+    const completed = makeSession({ sessionId: 'session-2', taskName: 'Task 2' });
+    const failed = makeSession({ sessionId: 'session-3', taskName: 'Task 3' });
+    writeSessionsFile(activeSessionsPath, [running, completed, failed]);
+
+    const fetch = vi.fn().mockImplementation(async (url) => {
+      if (url.endsWith('/session-1')) {
+        return { ok: true, json: async () => ({ status: 'running' }) };
+      }
+      if (url.endsWith('/session-2')) {
+        return { ok: true, json: async () => ({ status: 'completed' }) };
+      }
+      if (url.endsWith('/session-3')) {
+        return { ok: true, json: async () => ({ status: 'failed', reason: 'Rejected' }) };
+      }
+      throw new Error(`Unexpected URL: ${url}`);
+    });
+
+    const result = await checkCompletions({
+      activeSessionsPath,
+      orchestratorUrl: 'http://orchestrator.test',
+      fetch,
+    });
+
+    expect(result).toEqual({
+      completions: [completed],
+      failures: [{ ...failed, reason: 'Rejected' }],
+      stillRunning: 1,
+    });
+    expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([running]);
+  });
+
+  it('returns an error result when the orchestrator is unreachable', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+    const session = makeSession();
+    writeSessionsFile(activeSessionsPath, [session]);
+
+    const fetch = vi.fn().mockRejectedValue(new Error('connect ECONNREFUSED'));
+
+    const result = await checkCompletions({
+      activeSessionsPath,
+      orchestratorUrl: 'http://orchestrator.test',
+      fetch,
+    });
+
+    expect(result).toEqual({
+      completions: [],
+      failures: [],
+      stillRunning: -1,
+      error: 'orchestrator unreachable',
+    });
+    expect(JSON.parse(fs.readFileSync(activeSessionsPath, 'utf8'))).toEqual([session]);
+  });
+
+  it('treats a missing file as no active sessions', async () => {
+    const activeSessionsPath = makeActiveSessionsPath();
+
+    const result = await checkCompletions({
+      activeSessionsPath,
+      orchestratorUrl: 'http://orchestrator.test',
+      fetch: vi.fn(),
+    });
+
+    expect(result).toEqual({
+      completions: [],
+      failures: [],
+      stillRunning: 0,
+    });
+    expect(fs.existsSync(activeSessionsPath)).toBe(false);
+  });
+});

package/server/lib/orchestration/result-verifier.js

@@ -0,0 +1,143 @@
+/**
+ * Result Verifier
+ * Verifies that a dispatched agent actually produced meaningful work.
+ * Codex can exit 0 but produce nothing — this module catches that.
+ */
+
+const { execSync: defaultExecSync } = require('child_process');
+
+const TEST_FILE_PATTERN = /\.(test|spec)\./;
+
+/**
+ * Take a snapshot of the current git state for later comparison.
+ * @param {{ worktreePath: string, exec?: Function }} options
+ * @returns {{ gitHash: string, trackedFiles: string[], untrackedFiles: string[] }}
+ */
+function takeSnapshot({ worktreePath, exec = defaultExecSync }) {
+  const run = (cmd) => String(exec(cmd, { cwd: worktreePath })).trim();
+
+  const gitHash = run('git rev-parse HEAD');
+  const trackedRaw = run('git ls-files');
+  const untrackedRaw = run('git ls-files --others --exclude-standard');
+
+  return {
+    gitHash,
+    trackedFiles: trackedRaw ? trackedRaw.split('\n').filter(Boolean) : [],
+    untrackedFiles: untrackedRaw ? untrackedRaw.split('\n').filter(Boolean) : [],
+  };
+}
+
+/**
+ * Verify that an agent dispatch actually produced meaningful results.
+ * @param {{
+ *   worktreePath: string,
+ *   expectedFiles: string[],
+ *   preSnapshot: { gitHash: string, trackedFiles: string[], untrackedFiles: string[] },
+ *   exec?: Function,
+ *   runTests?: boolean,
+ *   testCommand?: string
+ * }} options
+ * @returns {{
+ *   success: boolean,
+ *   filesChanged: string[],
+ *   testsAdded: string[],
+ *   testsPassing: boolean | null,
+ *   summary: string,
+ *   failureReason: string | null
+ * }}
+ */
+function verifyResult({
+  worktreePath,
+  expectedFiles = [],
+  preSnapshot,
+  exec = defaultExecSync,
+  runTests = false,
+  testCommand = 'npm test',
+}) {
+  const run = (cmd) => String(exec(cmd, { cwd: worktreePath })).trim();
+
+  // 1. Detect file changes via git diff
+  let filesChanged = [];
+  try {
+    const diffOutput = run(`git diff --name-only ${preSnapshot.gitHash} HEAD`);
+    filesChanged = diffOutput ? diffOutput.split('\n').filter(Boolean) : [];
+
+    // Also pick up untracked files that appeared after the snapshot
+    const untrackedRaw = run('git ls-files --others --exclude-standard');
+    const untrackedNow = untrackedRaw ? untrackedRaw.split('\n').filter(Boolean) : [];
+    const newUntracked = untrackedNow.filter(
+      (f) => !preSnapshot.untrackedFiles.includes(f)
+    );
+    filesChanged = [...new Set([...filesChanged, ...newUntracked])];
+  } catch (err) {
+    // If git diff itself fails (e.g., timeout), report timeout
+    return {
+      success: false,
+      filesChanged: [],
+      testsAdded: [],
+      testsPassing: null,
+      summary: `Verification failed: ${err.message}`,
+      failureReason: err.code === 'ETIMEDOUT' ? 'timeout' : 'timeout',
+    };
+  }
+
+  // 2. No changes at all — Codex exited 0 but did nothing
+  if (filesChanged.length === 0) {
+    return {
+      success: false,
+      filesChanged: [],
+      testsAdded: [],
+      testsPassing: null,
+      summary: 'No files were changed. The agent exited successfully but produced no output.',
+      failureReason: 'no_changes',
+    };
+  }
+
+  // 3. Identify test files
+  const testsAdded = filesChanged.filter((f) => TEST_FILE_PATTERN.test(f));
+
+  // 4. If no tests were added/modified, it's a partial result
+  if (testsAdded.length === 0) {
+    return {
+      success: false,
+      filesChanged,
+      testsAdded: [],
+      testsPassing: null,
+      summary: `${filesChanged.length} file(s) changed but no test files were added or modified.`,
+      failureReason: 'no_tests',
+    };
+  }
+
+  // 5. Optionally run tests
+  let testsPassing = null;
+  if (runTests) {
+    try {
+      run(testCommand);
+      testsPassing = true;
+    } catch (_) {
+      return {
+        success: false,
+        filesChanged,
+        testsAdded,
+        testsPassing: false,
+        summary: `${filesChanged.length} file(s) changed with ${testsAdded.length} test file(s), but tests are failing.`,
+        failureReason: 'tests_failing',
+      };
+    }
+  }
+
+  // 6. Success
+  return {
+    success: true,
+    filesChanged,
+    testsAdded,
+    testsPassing,
+    summary: `${filesChanged.length} file(s) changed, ${testsAdded.length} test file(s) added/modified.${testsPassing === true ? ' All tests passing.' : ''}`,
+    failureReason: null,
+  };
+}
+
+module.exports = {
+  takeSnapshot,
+  verifyResult,
+};

package/server/lib/orchestration/result-verifier.test.js

@@ -0,0 +1,291 @@
+import { describe, it, expect, vi } from 'vitest';
+
+const { takeSnapshot, verifyResult } = require('./result-verifier.js');
+
+describe('result-verifier', () => {
+  describe('takeSnapshot', () => {
+    it('returns git state with hash, tracked, and untracked files', () => {
+      const exec = vi.fn()
+        .mockReturnValueOnce('abc1234')                   // git rev-parse HEAD
+        .mockReturnValueOnce('src/a.js\nsrc/b.js\n')      // git ls-files
+        .mockReturnValueOnce('new-file.js\n');             // git ls-files --others --exclude-standard
+
+      const snapshot = takeSnapshot({ worktreePath: '/tmp/wt', exec });
+
+      expect(exec).toHaveBeenCalledWith('git rev-parse HEAD', { cwd: '/tmp/wt' });
+      expect(exec).toHaveBeenCalledWith('git ls-files', { cwd: '/tmp/wt' });
+      expect(exec).toHaveBeenCalledWith(
+        'git ls-files --others --exclude-standard',
+        { cwd: '/tmp/wt' }
+      );
+      expect(snapshot).toEqual({
+        gitHash: 'abc1234',
+        trackedFiles: ['src/a.js', 'src/b.js'],
+        untrackedFiles: ['new-file.js'],
+      });
+    });
+
+    it('handles empty repos gracefully', () => {
+      const exec = vi.fn()
+        .mockReturnValueOnce('def5678')
+        .mockReturnValueOnce('')
+        .mockReturnValueOnce('');
+
+      const snapshot = takeSnapshot({ worktreePath: '/tmp/empty', exec });
+
+      expect(snapshot).toEqual({
+        gitHash: 'def5678',
+        trackedFiles: [],
+        untrackedFiles: [],
+      });
+    });
+  });
+
+  describe('verifyResult', () => {
+    function makePreSnapshot(overrides = {}) {
+      return {
+        gitHash: 'aaa1111',
+        trackedFiles: ['src/main.js'],
+        untrackedFiles: [],
+        ...overrides,
+      };
+    }
+
+    function makeExec({ diffOutput = '', testExitCode = 0 } = {}) {
+      const fn = vi.fn().mockImplementation((cmd) => {
+        if (cmd.startsWith('git diff')) {
+          return diffOutput;
+        }
+        if (cmd.startsWith('git rev-parse')) {
+          return 'bbb2222';
+        }
+        if (cmd.startsWith('git ls-files --others')) {
+          return '';
+        }
+        if (cmd.startsWith('git ls-files')) {
+          return 'src/main.js\n';
+        }
+        // Test runner
+        if (testExitCode !== 0) {
+          const err = new Error('tests failed');
+          err.status = testExitCode;
+          throw err;
+        }
+        return 'Tests passed';
+      });
+      return fn;
+    }
+
+    it('detects file changes via git diff', () => {
+      const exec = makeExec({
+        diffOutput: 'src/main.js\nsrc/utils.js\nsrc/utils.test.js\n',
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(result.filesChanged).toEqual(['src/main.js', 'src/utils.js', 'src/utils.test.js']);
+      expect(result.success).toBe(true);
+    });
+
+    it('detects no changes and returns failure', () => {
+      const exec = makeExec({ diffOutput: '' });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.failureReason).toBe('no_changes');
+      expect(result.filesChanged).toEqual([]);
+    });
+
+    it('detects test files added', () => {
+      const exec = makeExec({
+        diffOutput: 'src/widget.js\nsrc/widget.test.js\nsrc/widget.spec.ts\n',
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(result.testsAdded).toEqual(['src/widget.test.js', 'src/widget.spec.ts']);
+      expect(result.success).toBe(true);
+    });
+
+    it('detects no test files and returns partial failure', () => {
+      const exec = makeExec({
+        diffOutput: 'src/feature.js\nsrc/helpers.js\n',
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.failureReason).toBe('no_tests');
+      expect(result.testsAdded).toEqual([]);
+      expect(result.filesChanged).toEqual(['src/feature.js', 'src/helpers.js']);
+    });
+
+    it('detects test failures', () => {
+      const exec = vi.fn().mockImplementation((cmd) => {
+        if (cmd.startsWith('git diff')) {
+          return 'src/foo.js\nsrc/foo.test.js\n';
+        }
+        if (cmd.startsWith('git rev-parse')) {
+          return 'bbb2222';
+        }
+        if (cmd.startsWith('git ls-files --others')) {
+          return '';
+        }
+        if (cmd.startsWith('git ls-files')) {
+          return 'src/main.js\nsrc/foo.js\nsrc/foo.test.js\n';
+        }
+        // test runner command fails
+        const err = new Error('test suite failed');
+        err.status = 1;
+        throw err;
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+        runTests: true,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.failureReason).toBe('tests_failing');
+      expect(result.testsPassing).toBe(false);
+    });
+
+    it('returns success when files changed and tests pass', () => {
+      const exec = vi.fn().mockImplementation((cmd) => {
+        if (cmd.startsWith('git diff')) {
+          return 'src/api.js\nsrc/api.test.js\n';
+        }
+        if (cmd.startsWith('git rev-parse')) {
+          return 'ccc3333';
+        }
+        if (cmd.startsWith('git ls-files --others')) {
+          return '';
+        }
+        if (cmd.startsWith('git ls-files')) {
+          return 'src/main.js\nsrc/api.js\nsrc/api.test.js\n';
+        }
+        return 'All tests passed';
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+        runTests: true,
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.testsPassing).toBe(true);
+      expect(result.failureReason).toBeNull();
+      expect(result.filesChanged).toEqual(['src/api.js', 'src/api.test.js']);
+      expect(result.testsAdded).toEqual(['src/api.test.js']);
+    });
+
+    it('handles exec timeout by returning timeout failure', () => {
+      const exec = vi.fn().mockImplementation((cmd) => {
+        if (cmd.startsWith('git diff')) {
+          const err = new Error('Command timed out');
+          err.code = 'ETIMEDOUT';
+          throw err;
+        }
+        if (cmd.startsWith('git rev-parse')) {
+          return 'abc123';
+        }
+        if (cmd.startsWith('git ls-files --others')) {
+          return '';
+        }
+        if (cmd.startsWith('git ls-files')) {
+          return '';
+        }
+        return '';
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.failureReason).toBe('timeout');
+    });
+
+    it('returns partial when implementation exists but no tests', () => {
+      const exec = makeExec({
+        diffOutput: 'src/new-module.js\nlib/helpers.js\n',
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.failureReason).toBe('no_tests');
+      expect(result.filesChanged.length).toBe(2);
+      expect(result.testsAdded).toEqual([]);
+    });
+
+    it('produces a human-readable summary', () => {
+      const exec = makeExec({
+        diffOutput: 'src/component.js\nsrc/component.test.js\n',
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+      });
+
+      expect(typeof result.summary).toBe('string');
+      expect(result.summary.length).toBeGreaterThan(0);
+      expect(result.summary).toContain('2');  // file count
+    });
+
+    it('skips test execution when runTests is false or omitted', () => {
+      const exec = makeExec({
+        diffOutput: 'src/api.js\nsrc/api.test.js\n',
+      });
+
+      const result = verifyResult({
+        worktreePath: '/tmp/wt',
+        expectedFiles: [],
+        preSnapshot: makePreSnapshot(),
+        exec,
+        // runTests is not set — defaults to false
+      });
+
+      expect(result.testsPassing).toBeNull();
+      expect(result.success).toBe(true);
+    });
+  });
+});

package/server/lib/orchestration/session-dispatcher.js

@@ -0,0 +1,99 @@
+const fs = require('fs/promises');
+const path = require('path');
+
+async function readActiveSessions(activeSessionsPath) {
+  try {
+    const raw = await fs.readFile(activeSessionsPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch {
+    return [];
+  }
+}
+
+async function writeActiveSessions(activeSessionsPath, sessions) {
+  await fs.mkdir(path.dirname(activeSessionsPath), { recursive: true });
+  await fs.writeFile(activeSessionsPath, JSON.stringify(sessions, null, 2));
+}
+
+async function dispatchToOrchestrator({
+  orchestratorUrl,
+  project,
+  tasks = [],
+  phaseBranch,
+  activeSessionsPath,
+  fetch = globalThis.fetch,
+}) {
+  void phaseBranch;
+
+  if (tasks.length === 0) {
+    return {
+      dispatched: 0,
+      sessions: [],
+      errors: [],
+    };
+  }
+
+  const baseUrl = String(orchestratorUrl).replace(/\/+$/, '');
+  const sessions = [];
+  const activeSessions = [];
+  const errors = [];
+
+  for (const task of tasks) {
+    try {
+      const response = await fetch(`${baseUrl}/sessions`, {
+        method: 'POST',
+        headers: { 'content-type': 'application/json' },
+        body: JSON.stringify({
+          project,
+          pool: 'local-tmux',
+          command: task.provider,
+          prompt: task.prompt,
+        }),
+      });
+
+      if (!response || !response.ok) {
+        errors.push(`${task.name}: ${response ? response.status : 'request failed'}`);
+        continue;
+      }
+
+      const payload = await response.json();
+      if (!payload || !payload.id) {
+        errors.push(`${task.name}: invalid session response`);
+        continue;
+      }
+
+      sessions.push({ id: payload.id, taskName: task.name });
+      activeSessions.push({
+        sessionId: payload.id,
+        taskName: task.name,
+        startedAt: new Date().toISOString(),
+      });
+    } catch (error) {
+      if (sessions.length === 0 && errors.length === 0) {
+        return {
+          dispatched: 0,
+          errors: ['orchestrator unreachable'],
+          fallback: true,
+        };
+      }
+
+      errors.push(`${task.name}: ${error.message}`);
+    }
+  }
+
+  if (activeSessions.length > 0) {
+    const existing = await readActiveSessions(activeSessionsPath);
+    await writeActiveSessions(activeSessionsPath, [...existing, ...activeSessions]);
+  }
+
+  return {
+    dispatched: sessions.length,
+    sessions,
+    errors,
+  };
+}
+
+module.exports = {
+  dispatchToOrchestrator,
+};