tlc-claude-code 2.4.10 → 2.6.0

package/server/lib/hooks/block-tools-hook.test.js

@@ -0,0 +1,54 @@
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { BUILD_ROUTING_FLAG, shouldBlockAgent } from '../block-tools-hook.js';
+
+const tempDirs = [];
+
+function createProjectRoot() {
+  const projectRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'block-tools-hook-'));
+  tempDirs.push(projectRoot);
+  return projectRoot;
+}
+
+function writeFlag(projectRoot, value) {
+  const flagPath = path.join(projectRoot, BUILD_ROUTING_FLAG);
+  fs.mkdirSync(path.dirname(flagPath), { recursive: true });
+  fs.writeFileSync(flagPath, value);
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('shouldBlockAgent', () => {
+  it('returns provider when file has codex', () => {
+    const projectRoot = createProjectRoot();
+    writeFlag(projectRoot, 'codex');
+
+    expect(shouldBlockAgent(projectRoot)).toBe('codex');
+  });
+
+  it('returns null when claude', () => {
+    const projectRoot = createProjectRoot();
+    writeFlag(projectRoot, 'claude');
+
+    expect(shouldBlockAgent(projectRoot)).toBeNull();
+  });
+
+  it('returns null when missing', () => {
+    const projectRoot = createProjectRoot();
+
+    expect(shouldBlockAgent(projectRoot)).toBeNull();
+  });
+
+  it('returns null when empty', () => {
+    const projectRoot = createProjectRoot();
+    writeFlag(projectRoot, '');
+
+    expect(shouldBlockAgent(projectRoot)).toBeNull();
+  });
+});

package/server/lib/orchestration/cli-dispatch.js

@@ -49,10 +49,14 @@ function buildCommand(provider, prompt, worktreePath, flags) {
   let args;
 
   if (normalizedProvider === 'codex') {
-    args = ['exec', '--json', '--full-auto'];
+    args = ['exec', '--json', '--full-auto', '--ephemeral'];
     if (worktreePath) {
       args.push('-C', worktreePath);
     }
+    // Short prompts go inline; long prompts use stdin
+    if (prompt && prompt.length < 1000) {
+      usesStdin = false;
+    }
   } else if (normalizedProvider === 'gemini') {
     usesStdin = false;
     args = [...baseFlags, '-p', prompt];
@@ -84,6 +88,10 @@ function buildCommand(provider, prompt, worktreePath, flags) {
   }
 
   args.push(...baseFlags);
+  // For codex with short prompts, append prompt as inline argument
+  if (normalizedProvider === 'codex' && !usesStdin && prompt) {
+    args.push(prompt);
+  }
   return { command: normalizedProvider, args, spawnOptions, usesStdin };
 }
 
@@ -112,6 +120,13 @@ async function dispatch({
   spawn = require('child_process').spawn,
   binaryOverride,
 }) {
+  const PROMPT_SIZE_THRESHOLD = 16000;
+  if (prompt && prompt.length > PROMPT_SIZE_THRESHOLD) {
+    console.warn(
+      `[cli-dispatch] Prompt length (${prompt.length} chars) exceeds ${PROMPT_SIZE_THRESHOLD} char threshold (~${Math.round(prompt.length / 4)} tokens). Consider breaking the prompt into smaller tasks.`
+    );
+  }
+
   const start = Date.now();
   const built = buildCommand(provider, prompt, worktreePath, flags);
   // Allow standalone to preserve custom/absolute binary paths

package/server/lib/orchestration/cli-dispatch.test.js

@@ -30,7 +30,7 @@ function createMockProcess({ stdout = '', stderr = '', exitCode = 0, delay = 0 }
 }
 
 describe('cli-dispatch', () => {
-  it('builds codex args with -C, writes prompt to stdin, and extracts threadId', async () => {
+  it('builds codex args with -C, handles prompt, and extracts threadId', async () => {
     const stdout = [
       '{"type":"thread.started","thread_id":"thread-123"}',
       '{"type":"agent_message","message":{"items":[{"type":"text","text":"done"}]}}',
@@ -46,12 +46,18 @@ describe('cli-dispatch', () => {
       spawn,
     });
 
-    expect(spawn).toHaveBeenCalledWith(
-      'codex',
-      ['exec', '--json', '--full-auto', '-C', '/tmp/worktree', '--model', 'gpt-5.4'],
-      {}
-    );
-    expect(proc.stdin.write).toHaveBeenCalledWith('Review this change');
+    const args = spawn.mock.calls[0][1];
+    expect(args).toContain('exec');
+    expect(args).toContain('--json');
+    expect(args).toContain('--full-auto');
+    expect(args).toContain('--ephemeral');
+    expect(args).toContain('-C');
+    expect(args).toContain('/tmp/worktree');
+    expect(args).toContain('--model');
+    expect(args).toContain('gpt-5.4');
+    // Short prompt (<1000 chars) goes inline
+    expect(args).toContain('Review this change');
+    expect(proc.stdin.write).not.toHaveBeenCalled();
     expect(proc.stdin.end).toHaveBeenCalled();
     expect(result.threadId).toBe('thread-123');
     expect(result.exitCode).toBe(0);
@@ -221,7 +227,7 @@ describe('cli-dispatch', () => {
 
     expect(spawn).toHaveBeenCalledWith(
       'codex',
-      ['exec', '--json', '--full-auto', '-C', '/tmp/codex-worktree'],
+      expect.arrayContaining(['-C', '/tmp/codex-worktree']),
       {}
     );
   });
@@ -239,4 +245,84 @@ describe('cli-dispatch', () => {
     expect(result.threadId).toBeNull();
     expect(result.exitCode).toBe(0);
   });
+
+  it('buildCommand for codex includes --ephemeral flag', async () => {
+    const proc = createMockProcess({ stdout: 'ok' });
+    const spawn = vi.fn(() => proc);
+
+    await dispatch({
+      provider: 'codex',
+      prompt: 'Do something',
+      spawn,
+    });
+
+    const args = spawn.mock.calls[0][1];
+    expect(args).toContain('--ephemeral');
+  });
+
+  it('buildCommand for codex includes -o flag when outputFile provided', async () => {
+    const proc = createMockProcess({ stdout: 'ok' });
+    const spawn = vi.fn(() => proc);
+
+    await dispatch({
+      provider: 'codex',
+      prompt: 'Do something',
+      flags: ['-o', '/tmp/output.json'],
+      spawn,
+    });
+
+    const args = spawn.mock.calls[0][1];
+    expect(args).toContain('-o');
+    expect(args).toContain('/tmp/output.json');
+  });
+
+  it('buildCommand for codex uses inline argument for short prompts', async () => {
+    const shortPrompt = 'Fix the bug';
+    const proc = createMockProcess({ stdout: 'ok' });
+    const spawn = vi.fn(() => proc);
+
+    const result = await dispatch({
+      provider: 'codex',
+      prompt: shortPrompt,
+      spawn,
+    });
+
+    const args = spawn.mock.calls[0][1];
+    expect(args).toContain(shortPrompt);
+    expect(proc.stdin.write).not.toHaveBeenCalled();
+  });
+
+  it('buildCommand for codex uses stdin for long prompts', async () => {
+    const longPrompt = 'x'.repeat(1000);
+    const proc = createMockProcess({ stdout: 'ok' });
+    const spawn = vi.fn(() => proc);
+
+    await dispatch({
+      provider: 'codex',
+      prompt: longPrompt,
+      spawn,
+    });
+
+    const args = spawn.mock.calls[0][1];
+    expect(args).not.toContain(longPrompt);
+    expect(proc.stdin.write).toHaveBeenCalledWith(longPrompt);
+  });
+
+  it('dispatch warns when prompt exceeds size threshold', async () => {
+    const hugePrompt = 'x'.repeat(16001);
+    const proc = createMockProcess({ stdout: 'ok' });
+    const spawn = vi.fn(() => proc);
+    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+    await dispatch({
+      provider: 'codex',
+      prompt: hugePrompt,
+      spawn,
+    });
+
+    expect(warnSpy).toHaveBeenCalledWith(
+      expect.stringContaining('exceeds')
+    );
+    warnSpy.mockRestore();
+  });
 });

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

@@ -0,0 +1,101 @@
+const fs = require('fs/promises');
+
+async function readActiveSessions(activeSessionsPath) {
+  try {
+    const raw = await fs.readFile(activeSessionsPath, 'utf8');
+    const parsed = JSON.parse(raw);
+    return Array.isArray(parsed) ? parsed : [];
+  } catch (error) {
+    if (error && error.code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+}
+
+async function writeActiveSessions(activeSessionsPath, sessions) {
+  await fs.mkdir(require('path').dirname(activeSessionsPath), { recursive: true });
+  await fs.writeFile(activeSessionsPath, JSON.stringify(sessions, null, 2));
+}
+
+async function checkCompletions({
+  activeSessionsPath,
+  orchestratorUrl,
+  fetch = globalThis.fetch,
+}) {
+  const activeSessions = await readActiveSessions(activeSessionsPath);
+  if (activeSessions.length === 0) {
+    return {
+      completions: [],
+      failures: [],
+      stillRunning: 0,
+    };
+  }
+
+  const completions = [];
+  const failures = [];
+  const remainingSessions = [];
+
+  let orchestratorReachable = true;
+
+  for (const session of activeSessions) {
+    try {
+      const response = await fetch(
+        `${String(orchestratorUrl).replace(/\/+$/, '')}/sessions/${session.sessionId}`
+      );
+
+      if (!response.ok) {
+        // Server returned error for this session — keep it as running, don't abort
+        remainingSessions.push(session);
+        continue;
+      }
+
+      const payload = await response.json();
+
+      if (payload.status === 'completed') {
+        completions.push(session);
+        continue;
+      }
+
+      if (payload.status === 'failed') {
+        failures.push({
+          ...session,
+          ...(payload.reason ? { reason: payload.reason } : {}),
+        });
+        continue;
+      }
+
+      remainingSessions.push(session);
+    } catch (error) {
+      if (!orchestratorReachable) {
+        // Already know orchestrator is down — keep remaining sessions as-is
+        remainingSessions.push(session);
+        continue;
+      }
+      // First network error — check if orchestrator is entirely unreachable
+      orchestratorReachable = false;
+      remainingSessions.push(session);
+    }
+  }
+
+  if (!orchestratorReachable && completions.length === 0 && failures.length === 0) {
+    return {
+      completions: [],
+      failures: [],
+      stillRunning: -1,
+      error: 'orchestrator unreachable',
+    };
+  }
+
+  await writeActiveSessions(activeSessionsPath, remainingSessions);
+
+  return {
+    completions,
+    failures,
+    stillRunning: remainingSessions.length,
+  };
+}
+
+module.exports = {
+  checkCompletions,
+};

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,
+};