create-harness-vibe-coding 0.8.19 → 0.9.3

package/src/wf-ui-server/__tests__/session-cleanup.test.mjs

@@ -0,0 +1,159 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'node:fs';
+import path from 'node:path';
+import { makeHarnessTempRoot } from '../../../tests/support/temp-root.js';
+import {
+  buildCleanupSummary,
+  pruneCleanupTargets,
+} from '../session-cleanup.mjs';
+
+function tmpdir(prefix) {
+  return makeHarnessTempRoot(prefix);
+}
+
+function writeJson(filePath, value) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify(value, null, 2)}\n`, 'utf8');
+}
+
+function writeSession(root, relDir, state, updatedAt) {
+  const dir = path.join(root, relDir);
+  fs.mkdirSync(dir, { recursive: true });
+  writeJson(path.join(dir, 'STATE.json'), {
+    sessionId: path.basename(relDir),
+    runtime: 'codex',
+    status: state,
+    updatedAt,
+    terminalSeq: 1,
+  });
+  fs.writeFileSync(path.join(dir, 'terminal.jsonl'), '{"seq":1,"data":"hello"}\n', 'utf8');
+  fs.writeFileSync(path.join(dir, 'events.jsonl'), '{"type":"session.saved"}\n', 'utf8');
+  return dir;
+}
+
+test('AC-CLEANUP-001 stopped session cleanup is previewable and preserves live/task-bound sessions by default', () => {
+  const root = tmpdir('harness-cleanup-sessions-');
+  const previewTempRoot = tmpdir('harness-cleanup-empty-temp-');
+  const pruneTempRoot = tmpdir('harness-cleanup-empty-temp-');
+  try {
+    const old = '2026-01-01T00:00:00.000Z';
+    const recent = '2026-07-30T00:00:00.000Z';
+    const oldUnbound = writeSession(root, 'Harness/a2a/sessions/session-old', 'saved', old);
+    const recentUnbound = writeSession(root, 'Harness/a2a/sessions/session-recent', 'saved', recent);
+    const liveUnbound = writeSession(root, 'Harness/a2a/sessions/session-live', 'running', old);
+    const taskBound = writeSession(root, 'Harness/tasks/task-alpha/sessions/session-task', 'saved', old);
+
+    const summary = buildCleanupSummary(root, {
+      stoppedSessionRetentionDays: 7,
+      keepStoppedSessions: 20,
+      includeTaskSessions: false,
+      detachedLogRetentionHours: 24,
+    }, {
+      liveSessionIds: new Set(['session-live']),
+      now: new Date('2026-07-31T00:00:00.000Z'),
+      tempRoot: previewTempRoot,
+    });
+
+    assert.equal(summary.sessions.eligibleCount, 1);
+    assert.deepEqual(summary.targets.sessions.map(target => target.sessionId), ['session-old']);
+
+    const result = pruneCleanupTargets(root, {
+      stoppedSessionRetentionDays: 7,
+      keepStoppedSessions: 20,
+      includeTaskSessions: false,
+      detachedLogRetentionHours: 24,
+    }, {
+      apply: true,
+      liveSessionIds: new Set(['session-live']),
+      now: new Date('2026-07-31T00:00:00.000Z'),
+      tempRoot: pruneTempRoot,
+    });
+
+    assert.equal(result.applied, true);
+    assert.equal(fs.existsSync(oldUnbound), false);
+    assert.equal(fs.existsSync(recentUnbound), true);
+    assert.equal(fs.existsSync(liveUnbound), true);
+    assert.equal(fs.existsSync(taskBound), true);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.rmSync(previewTempRoot, { recursive: true, force: true });
+    fs.rmSync(pruneTempRoot, { recursive: true, force: true });
+  }
+});
+
+test('AC-CLEANUP-002 detached wf-ui temp cleanup skips current and fresh launch logs', () => {
+  const root = tmpdir('harness-cleanup-project-');
+  const tempRoot = tmpdir('harness-cleanup-temp-root-');
+  try {
+    const oldDir = path.join(tempRoot, 'harness-wf-ui-old');
+    const freshDir = path.join(tempRoot, 'harness-wf-ui-fresh');
+    const currentDir = path.join(tempRoot, 'harness-wf-ui-current');
+    const liveDir = path.join(tempRoot, 'harness-wf-ui-live');
+    for (const dir of [oldDir, freshDir, currentDir, liveDir]) {
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(path.join(dir, 'wf-ui.log'), 'log\n', 'utf8');
+    }
+    fs.writeFileSync(path.join(liveDir, 'ready.json'), JSON.stringify({ pid: process.pid }));
+
+    const oldDate = new Date('2026-07-28T00:00:00.000Z');
+    for (const dir of [oldDir, liveDir]) {
+      fs.utimesSync(dir, oldDate, oldDate);
+      fs.utimesSync(path.join(dir, 'wf-ui.log'), oldDate, oldDate);
+    }
+
+    const result = pruneCleanupTargets(root, {
+      stoppedSessionRetentionDays: 7,
+      keepStoppedSessions: 20,
+      includeTaskSessions: false,
+      detachedLogRetentionHours: 24,
+    }, {
+      apply: true,
+      now: new Date('2026-07-31T00:00:00.000Z'),
+      tempRoot,
+      currentReadyFile: path.join(currentDir, 'ready.json'),
+    });
+
+    assert.equal(result.tempLogs.eligibleCount, 1);
+    assert.equal(fs.existsSync(oldDir), false);
+    assert.equal(fs.existsSync(freshDir), true);
+    assert.equal(fs.existsSync(currentDir), true);
+    assert.equal(fs.existsSync(liveDir), true);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+    fs.rmSync(tempRoot, { recursive: true, force: true });
+  }
+});
+
+test('AC-CLEANUP-002 detached wf-ui cleanup defaults to project-local launch logs', () => {
+  const root = tmpdir('harness-cleanup-project-local-');
+  try {
+    const launchRoot = path.join(root, 'Harness', '.temp', 'wf-ui-launch');
+    const oldDir = path.join(launchRoot, 'harness-wf-ui-old');
+    const currentDir = path.join(launchRoot, 'harness-wf-ui-current');
+    for (const dir of [oldDir, currentDir]) {
+      fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(path.join(dir, 'wf-ui.log'), 'log\n', 'utf8');
+    }
+    const oldDate = new Date('2026-07-28T00:00:00.000Z');
+    fs.utimesSync(oldDir, oldDate, oldDate);
+    fs.utimesSync(path.join(oldDir, 'wf-ui.log'), oldDate, oldDate);
+
+    const result = pruneCleanupTargets(root, {
+      stoppedSessionRetentionDays: 7,
+      keepStoppedSessions: 20,
+      includeTaskSessions: false,
+      detachedLogRetentionHours: 24,
+    }, {
+      apply: true,
+      now: new Date('2026-07-31T00:00:00.000Z'),
+      currentReadyFile: path.join(currentDir, 'ready.json'),
+    });
+
+    assert.equal(result.tempLogs.eligibleCount, 1);
+    assert.equal(fs.existsSync(oldDir), false);
+    assert.equal(fs.existsSync(currentDir), true);
+  } finally {
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

package/src/wf-ui-server/__tests__/session-registry.test.mjs

@@ -13,7 +13,7 @@ test('create with valid runtime claude succeeds', () => {
   assert.ok(session.sessionId);
   assert.equal(session.taskId, 'task-xyz');
   assert.equal(session.runtime, 'claude');
-  assert.equal(session.subagentMode, 'wf-subagents');
+  assert.equal(session.subagentMode, 'built-in-subagents');
   assert.equal(session.workflowMode, null);
   assert.equal(session.status, 'starting');
   assert.equal(session.cols, 120);
@@ -25,6 +25,16 @@ test('create with valid runtime claude succeeds', () => {
   assert.equal(typeof session.updatedAt, 'string');
 });
 
+test('create normalizes legacy wf-subagents mode to wf-node-subagents', () => {
+  const reg = new SessionRegistry();
+  const legacy = reg.create({ runtime: 'claude', subagentMode: 'wf-subagents' });
+  assert.equal(legacy.subagentMode, 'wf-node-subagents');
+  const modern = reg.create({ runtime: 'claude', subagentMode: 'wf-node-subagents' });
+  assert.equal(modern.subagentMode, 'wf-node-subagents');
+  const defaulted = reg.create({ runtime: 'claude' });
+  assert.equal(defaulted.subagentMode, 'built-in-subagents');
+});
+
 test('create can start an unbound terminal agent session', () => {
   const reg = new SessionRegistry();
   const session = reg.create({ runtime: 'opencode', cols: 100, rows: 30, model: 'sonnet', provider: 'anthropic' });
@@ -35,6 +45,45 @@ test('create can start an unbound terminal agent session', () => {
   assert.equal(session.provider, 'anthropic');
 });
 
+test('AC-001 AC-005 create preserves explicit agent launch fields and graph context', () => {
+  const reg = new SessionRegistry();
+  const graphContext = {
+    nodeId: 'agent-main-1',
+    connectedPeerIds: ['agent-subagent-1'],
+    relationship: 'main-controls-subagent',
+  };
+  const launchPolicy = {
+    sandboxMode: 'danger-full-access',
+    approvalPolicy: 'never',
+  };
+
+  const session = reg.create({
+    agentKind: 'main',
+    runtime: 'codex',
+    workflowMode: 'wf',
+    taskId: 'task-alpha',
+    cwd: 'D:\\workspaces\\alpha',
+    launchPolicy,
+    graphContext,
+  });
+
+  assert.equal(session.agentKind, 'main');
+  assert.equal(session.runtime, 'codex');
+  assert.equal(session.workflowMode, 'wf');
+  assert.equal(session.taskId, 'task-alpha');
+  assert.equal(session.cwd, 'D:\\workspaces\\alpha');
+  assert.deepEqual(session.launchPolicy, launchPolicy);
+  assert.deepEqual(session.graphContext, graphContext);
+});
+
+test('AC-001 AC-005 create rejects Router as an agent kind', () => {
+  const reg = new SessionRegistry();
+  assert.throws(() => reg.create({ runtime: 'codex', agentKind: 'router' }), {
+    name: 'Error',
+    message: /agent kind.*router/i,
+  });
+});
+
 test('create can mark a wf CEO terminal session', () => {
   const reg = new SessionRegistry();
   const session = reg.create({
@@ -175,12 +224,12 @@ test('remove then get returns undefined', () => {
   assert.equal(reg.count(), 0);
 });
 
-test('stop removes web session from live registry and returns saved state', () => {
+test('stop removes web session from live registry and returns stopped state', () => {
   const reg = new SessionRegistry();
   const created = reg.create({ runtime: 'claude' });
   const stopped = reg.stop(created.sessionId);
   assert.equal(stopped.sessionId, created.sessionId);
-  assert.equal(stopped.status, 'saved');
+  assert.equal(stopped.status, 'stopped');
   assert.equal(reg.get(created.sessionId), undefined);
   assert.equal(reg.count(), 0);
 });

package/src/wf-ui-server/__tests__/settings.test.mjs

@@ -2,7 +2,7 @@ import test, { describe, before, after } from 'node:test';
 import assert from 'node:assert/strict';
 import fs from 'node:fs';
 import path from 'node:path';
-import os from 'node:os';
+import { makeHarnessTempRoot } from '../../../tests/support/temp-root.js';
 import { loadSettings, resolveSettings } from '../settings.mjs';
 import { RUNTIME_DEFINITIONS } from '../runtime-detector.mjs';
 
@@ -11,13 +11,23 @@ const DEFAULTS = {
   terminal: { enabled: false, attachMode: false, defaultRuntime: 'codex' },
   peers: { allowlist: RUNTIME_DEFINITIONS.map(runtime => runtime.id) },
   ui: { theme: 'auto', language: 'en', reducedMotion: false },
+  cleanup: {
+    enabled: true,
+    autoPruneOnStartup: true,
+    autoPruneIntervalHours: 6,
+    autoPruneStoppedSessions: false,
+    stoppedSessionRetentionDays: 14,
+    keepStoppedSessions: 20,
+    includeTaskSessions: false,
+    detachedLogRetentionHours: 24,
+  },
 };
 
 describe('settings', () => {
   let baseDir;
 
   before(() => {
-    baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'st-test-'));
+    baseDir = makeHarnessTempRoot('st-test-');
   });
 
   after(() => {

package/src/wf-ui-server/__tests__/spawn-gate.test.mjs

@@ -0,0 +1,78 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { createSpawnGate } from '../spawn-gate.mjs';
+
+// Spawn-gate contract: a sliding window over concurrent spawns; FIFO waiters;
+// slots always released (success, error, or timeout).
+
+function deferred() {
+  let resolve;
+  let reject;
+  const promise = new Promise((res, rej) => { resolve = res; reject = rej; });
+  return { promise, resolve, reject };
+}
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+test('T1 window cap: maxConcurrent run at once, the rest wait FIFO', async () => {
+  const gate = createSpawnGate({ maxConcurrent: 2, timeoutMs: 5000 });
+  const blockers = [deferred(), deferred(), deferred(), deferred()];
+  const order = [];
+
+  const run = async (i) => gate(() => {
+    order.push(`run-${i}`);
+    return blockers[i].promise;
+  });
+
+  const p1 = run(0); // slot 1
+  const p2 = run(1); // slot 2
+  await sleep(20);
+  const p3 = run(2); // queued
+  const p4 = run(3); // queued
+  await sleep(20);
+
+  assert.deepEqual(order, ['run-0', 'run-1']); // third+fourth not started
+
+  blockers[0].resolve('a');
+  assert.equal(await p1, 'a');
+  await sleep(10);
+  assert.deepEqual(order, ['run-0', 'run-1', 'run-2']); // FIFO: 2 enters next
+
+  blockers[1].resolve('b');
+  assert.equal(await p2, 'b');
+  await sleep(10);
+  assert.deepEqual(order, ['run-0', 'run-1', 'run-2', 'run-3']);
+
+  blockers[2].resolve('c');
+  blockers[3].resolve('d');
+  assert.equal(await p3, 'c');
+  assert.equal(await p4, 'd');
+});
+
+test('T2 rejection releases the slot; the next waiter proceeds', async () => {
+  const gate = createSpawnGate({ maxConcurrent: 1, timeoutMs: 5000 });
+  const blocker = deferred();
+  const p1 = gate(() => blocker.promise);
+  await sleep(10);
+  const p2 = gate(() => 'second-ok');
+
+  blocker.reject(new Error('boom'));
+  await assert.rejects(p1, /boom/);
+  assert.equal(await p2, 'second-ok'); // p2 entered after p1's slot freed
+});
+
+test('T3 a hung spawn times out: caller errors and the slot frees', async () => {
+  const gate = createSpawnGate({ maxConcurrent: 1, timeoutMs: 40 });
+  const hung = deferred();
+  const p1 = gate(() => hung.promise);
+  await assert.rejects(p1, /timed out after 40ms/);
+  const p2 = gate(() => 'after-timeout');
+  assert.equal(await p2, 'after-timeout');
+  hung.resolve('late'); // background settlement must not break anything
+});
+
+test('T4 the result of the gated fn passes through untouched', async () => {
+  const gate = createSpawnGate({ maxConcurrent: 2, timeoutMs: 5000 });
+  assert.deepEqual(await gate(() => ({ ok: 1 })), { ok: 1 });
+  assert.equal(await gate(() => 42), 42);
+});

package/src/wf-ui-server/__tests__/task-group-parser.test.mjs

@@ -0,0 +1,120 @@
+import test, { after } from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import fs from 'node:fs';
+import path from 'node:path';
+import { makeHarnessTempRoot } from '../../../tests/support/temp-root.js';
+import { parseTaskCapsule, parseTaskList } from '../task-parser.mjs';
+import { startServer, stopServer } from '../server.mjs';
+
+const tempRoots = [];
+
+function makeProject() {
+  const root = makeHarnessTempRoot('task-group-parser-');
+  tempRoots.push(root);
+  const tasksRoot = path.join(root, 'Harness', 'tasks');
+  fs.mkdirSync(tasksRoot, { recursive: true });
+  return { root, tasksRoot };
+}
+
+function writeFixtureState(tasksRoot, taskId, state) {
+  const dir = path.join(tasksRoot, taskId);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(path.join(dir, 'STATE.json'), JSON.stringify(state, null, 2) + '\n');
+}
+
+after(() => {
+  for (const root of tempRoots) fs.rmSync(root, { recursive: true, force: true });
+});
+
+function fetchJson(baseUrl, route) {
+  return new Promise((resolve, reject) => {
+    http.get(new URL(route, baseUrl), (res) => {
+      let body = '';
+      res.on('data', c => body += c);
+      res.on('end', () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(body) }); }
+        catch { resolve({ status: res.statusCode, body }); }
+      });
+    }).on('error', reject);
+  });
+}
+
+function baseState(overrides = {}) {
+  return {
+    schemaVersion: 1,
+    taskId: 'task-x',
+    status: 'active',
+    phase: 'implement',
+    updatedAt: '2026-08-13T08:00:00.000Z',
+    links: { dependsOn: [], blocks: [], related: [] },
+    ...overrides,
+  };
+}
+
+test('P1: parseTaskCapsule exposes group from STATE.json when present', () => {
+  const { tasksRoot } = makeProject();
+  writeFixtureState(tasksRoot, 'task-grouped', baseState({ taskId: 'task-grouped', group: 'release-0819-formal' }));
+
+  const capsule = parseTaskCapsule(path.join(tasksRoot, 'task-grouped'));
+  assert.equal(capsule.group, 'release-0819-formal');
+
+  const list = parseTaskList(tasksRoot);
+  assert.equal(list.find(task => task.taskId === 'task-grouped').group, 'release-0819-formal');
+});
+
+test('P2: parseTaskCapsule group is null when absent from STATE.json', () => {
+  const { tasksRoot } = makeProject();
+  writeFixtureState(tasksRoot, 'task-ungrouped', baseState({ taskId: 'task-ungrouped' }));
+
+  const capsule = parseTaskCapsule(path.join(tasksRoot, 'task-ungrouped'));
+  assert.equal(capsule.group, null);
+
+  const list = parseTaskList(tasksRoot);
+  assert.equal(list.find(task => task.taskId === 'task-ungrouped').group, null);
+});
+
+test('P3: list endpoint payload carries group per task', async () => {
+  const { root, tasksRoot } = makeProject();
+  writeFixtureState(tasksRoot, 'task-grouped', baseState({ taskId: 'task-grouped', group: 'release-0819-formal' }));
+  writeFixtureState(tasksRoot, 'task-ungrouped', baseState({ taskId: 'task-ungrouped' }));
+
+  const started = await startServer({ projectRoot: root, host: '127.0.0.1', port: 0 });
+  const baseUrl = `http://127.0.0.1:${started.port}`;
+  try {
+    const list = await fetchJson(baseUrl, '/api/tasks');
+    assert.equal(list.status, 200);
+    assert.equal(list.body.find(task => task.taskId === 'task-grouped').group, 'release-0819-formal');
+    assert.equal(list.body.find(task => task.taskId === 'task-ungrouped').group, null);
+
+    const single = await fetchJson(baseUrl, '/api/tasks/task-grouped');
+    assert.equal(single.status, 200);
+    assert.equal(single.body.group, 'release-0819-formal');
+  } finally {
+    await stopServer(started.server);
+  }
+});
+
+test('P4: startup generation writes Harness/tasks/GROUPS.md from fixtures', async () => {
+  const { root, tasksRoot } = makeProject();
+  writeFixtureState(tasksRoot, 'task-grouped', baseState({
+    taskId: 'task-grouped',
+    group: 'release-0819-formal',
+    updatedAt: new Date().toISOString(),
+  }));
+  writeFixtureState(tasksRoot, 'task-ungrouped', baseState({
+    taskId: 'task-ungrouped',
+    updatedAt: new Date().toISOString(),
+  }));
+
+  const started = await startServer({ projectRoot: root, host: '127.0.0.1', port: 0 });
+  try {
+    const md = fs.readFileSync(path.join(tasksRoot, 'GROUPS.md'), 'utf8');
+    assert.match(md, /^# Task Groups \(generated\)/);
+    assert.match(md, /## release-0819-formal \(1 task\)/);
+    assert.match(md, /## default \(1 task\)/);
+    assert.match(md, /## Needs Archive \(stale\)/);
+  } finally {
+    await stopServer(started.server);
+  }
+});