tlc-claude-code 2.5.0 → 2.6.1

package/server/lib/e2e/verify-runner.js

@@ -0,0 +1,191 @@
+'use strict';
+
+const { parseAcceptanceCriteria } = require('./acceptance-parser.js');
+const { detectE2eFramework } = require('./framework-detector.js');
+
+function normalizeLogErrors(logErrors) {
+  if (Array.isArray(logErrors)) {
+    return logErrors
+      .map((entry) => String(entry || '').trim())
+      .filter(Boolean);
+  }
+
+  if (typeof logErrors === 'string') {
+    const trimmed = logErrors.trim();
+    return trimmed ? [trimmed] : [];
+  }
+
+  return [];
+}
+
+function buildExecFailureLogs(execResult) {
+  const explicitLogs = normalizeLogErrors(execResult && execResult.logErrors);
+  if (explicitLogs.length > 0) {
+    return explicitLogs;
+  }
+
+  const output = [execResult && execResult.stderr, execResult && execResult.stdout]
+    .filter((value) => typeof value === 'string')
+    .join('\n')
+    .trim();
+
+  if (output) {
+    return [output];
+  }
+
+  const exitCode = execResult && Number.isInteger(execResult.code) ? execResult.code : 1;
+  return [`E2E command exited with code ${exitCode}`];
+}
+
+function normalizeCriterionResult(entry, fallback) {
+  const status = entry && typeof entry.status === 'string'
+    ? entry.status.trim().toLowerCase()
+    : fallback.status;
+
+  return {
+    criterion: fallback.criterion,
+    status: status === 'verified' || status === 'manual' || status === 'failed'
+      ? status
+      : fallback.status,
+    screenshot: entry && typeof entry.screenshot === 'string' && entry.screenshot.trim()
+      ? entry.screenshot
+      : fallback.screenshot,
+    logErrors: entry && Object.prototype.hasOwnProperty.call(entry, 'logErrors')
+      ? normalizeLogErrors(entry.logErrors)
+      : fallback.logErrors,
+  };
+}
+
+function buildSummary(results) {
+  return results.reduce((summary, item) => {
+    if (item.status === 'verified') summary.verified += 1;
+    if (item.status === 'manual') summary.manual += 1;
+    if (item.status === 'failed') summary.failed += 1;
+    return summary;
+  }, { verified: 0, manual: 0, failed: 0 });
+}
+
+function buildCommand(framework) {
+  if (framework === 'playwright') {
+    return {
+      command: 'npx',
+      args: ['playwright', 'test', '--reporter=list'],
+    };
+  }
+
+  if (framework === 'supertest') {
+    return {
+      command: 'npx',
+      args: ['vitest', 'run'],
+    };
+  }
+
+  return null;
+}
+
+async function runVerification(options) {
+  const {
+    planPath,
+    projectDir,
+    exec,
+    fs,
+  } = options || {};
+
+  if (typeof planPath !== 'string' || !planPath.trim()) {
+    throw new TypeError('runVerification requires planPath');
+  }
+
+  if (typeof projectDir !== 'string' || !projectDir.trim()) {
+    throw new TypeError('runVerification requires projectDir');
+  }
+
+  if (typeof exec !== 'function') {
+    throw new TypeError('runVerification requires exec');
+  }
+
+  if (!fs || typeof fs.readFileSync !== 'function' || typeof fs.existsSync !== 'function') {
+    throw new TypeError('runVerification requires fs with readFileSync and existsSync');
+  }
+
+  const planContent = fs.readFileSync(planPath, 'utf8');
+  const criteria = parseAcceptanceCriteria({ planContent });
+  const manualResults = [];
+  const actionableCriteria = [];
+
+  for (const item of criteria) {
+    if (item.type === 'manual') {
+      manualResults.push({
+        criterion: item.criterion,
+        status: 'manual',
+        screenshot: null,
+        logErrors: [],
+      });
+      continue;
+    }
+
+    actionableCriteria.push(item);
+  }
+
+  if (actionableCriteria.length === 0) {
+    const results = manualResults;
+    return {
+      ...buildSummary(results),
+      results,
+    };
+  }
+
+  const { framework } = detectE2eFramework({ projectDir, fs });
+  const command = buildCommand(framework);
+
+  if (!command) {
+    const results = actionableCriteria.map(({ criterion }) => ({
+      criterion,
+      status: 'failed',
+      screenshot: null,
+      logErrors: ['No supported E2E framework detected'],
+    })).concat(manualResults);
+
+    return {
+      ...buildSummary(results),
+      results,
+    };
+  }
+
+  const execResult = await exec({
+    ...command,
+    cwd: projectDir,
+  });
+
+  const passed = execResult && execResult.code === 0;
+  const fallback = actionableCriteria.map(({ criterion }) => ({
+    criterion,
+    status: passed ? 'verified' : 'failed',
+    screenshot: execResult && typeof execResult.screenshot === 'string' ? execResult.screenshot : null,
+    logErrors: passed ? normalizeLogErrors(execResult && execResult.logErrors) : buildExecFailureLogs(execResult),
+  }));
+
+  const explicitResults = new Map();
+  for (const entry of Array.isArray(execResult && execResult.results) ? execResult.results : []) {
+    if (!entry || typeof entry.criterion !== 'string') {
+      continue;
+    }
+
+    explicitResults.set(entry.criterion.trim(), entry);
+  }
+
+  const actionableResults = fallback.map((item) => normalizeCriterionResult(
+    explicitResults.get(item.criterion),
+    item
+  ));
+
+  const results = actionableResults.concat(manualResults);
+
+  return {
+    ...buildSummary(results),
+    results,
+  };
+}
+
+module.exports = {
+  runVerification,
+};

package/server/lib/e2e/verify-runner.test.js

@@ -0,0 +1,167 @@
+'use strict';
+
+import { describe, expect, it, vi } from 'vitest';
+
+const { runVerification } = require('./verify-runner.js');
+
+function createFs(planContent, extraFiles = {}) {
+  return {
+    readFileSync(path) {
+      if (path === '/tmp/phase-plan.md') {
+        return planContent;
+      }
+
+      if (Object.prototype.hasOwnProperty.call(extraFiles, path)) {
+        return extraFiles[path];
+      }
+
+      throw new Error(`Unexpected read: ${path}`);
+    },
+
+    existsSync(path) {
+      return Object.prototype.hasOwnProperty.call(extraFiles, path);
+    },
+  };
+}
+
+describe('runVerification', () => {
+  it('runs the detected E2E command and marks automatable criteria verified', async () => {
+    const fs = createFs(`
+- [ ] User can click the export button
+Data is retained for 30 days.
+`, {
+      '/repo/package.json': JSON.stringify({
+        devDependencies: {
+          supertest: '^7.2.2',
+        },
+      }),
+    });
+
+    const exec = vi.fn().mockResolvedValue({
+      code: 0,
+      results: [
+        {
+          criterion: 'User can click the export button',
+          screenshot: 'artifacts/export.png',
+          logErrors: [],
+        },
+      ],
+    });
+
+    const result = await runVerification({
+      planPath: '/tmp/phase-plan.md',
+      projectDir: '/repo',
+      exec,
+      fs,
+    });
+
+    expect(exec).toHaveBeenCalledWith({
+      command: 'npx',
+      args: ['vitest', 'run'],
+      cwd: '/repo',
+    });
+    expect(result).toEqual({
+      verified: 1,
+      manual: 1,
+      failed: 0,
+      results: [
+        {
+          criterion: 'User can click the export button',
+          status: 'verified',
+          screenshot: 'artifacts/export.png',
+          logErrors: [],
+        },
+        {
+          criterion: 'Data is retained for 30 days.',
+          status: 'manual',
+          screenshot: null,
+          logErrors: [],
+        },
+      ],
+    });
+  });
+
+  it('uses playwright when the project has a playwright config', async () => {
+    const fs = createFs('- [ ] User can click the sign in button', {
+      '/repo/playwright.config.ts': 'export default {};',
+    });
+
+    const exec = vi.fn().mockResolvedValue({ code: 0 });
+
+    await runVerification({
+      planPath: '/tmp/phase-plan.md',
+      projectDir: '/repo',
+      exec,
+      fs,
+    });
+
+    expect(exec).toHaveBeenCalledWith({
+      command: 'npx',
+      args: ['playwright', 'test', '--reporter=list'],
+      cwd: '/repo',
+    });
+  });
+
+  it('fails automatable criteria when no supported E2E framework is detected', async () => {
+    const fs = createFs('- [ ] User can click the sign in button');
+    const exec = vi.fn();
+
+    const result = await runVerification({
+      planPath: '/tmp/phase-plan.md',
+      projectDir: '/repo',
+      exec,
+      fs,
+    });
+
+    expect(exec).not.toHaveBeenCalled();
+    expect(result).toEqual({
+      verified: 0,
+      manual: 0,
+      failed: 1,
+      results: [
+        {
+          criterion: 'User can click the sign in button',
+          status: 'failed',
+          screenshot: null,
+          logErrors: ['No supported E2E framework detected'],
+        },
+      ],
+    });
+  });
+
+  it('propagates failed executions into each automatable criterion', async () => {
+    const fs = createFs(`
+Given the user is on the login page
+When they click the sign in button
+Then the dashboard page should load
+`, {
+      '/repo/playwright.config.ts': 'export default {};',
+    });
+
+    const exec = vi.fn().mockResolvedValue({
+      code: 1,
+      stderr: 'Timeout while waiting for dashboard',
+    });
+
+    const result = await runVerification({
+      planPath: '/tmp/phase-plan.md',
+      projectDir: '/repo',
+      exec,
+      fs,
+    });
+
+    expect(result).toEqual({
+      verified: 0,
+      manual: 0,
+      failed: 1,
+      results: [
+        {
+          criterion: 'the dashboard page should load',
+          status: 'failed',
+          screenshot: null,
+          logErrors: ['Timeout while waiting for dashboard'],
+        },
+      ],
+    });
+  });
+});

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