create-harness-vibe-coding 0.8.17 → 0.8.19

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

@@ -0,0 +1,150 @@
+import test, { before, after } from 'node:test';
+import assert from 'node:assert/strict';
+import http from 'node:http';
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { startServer, stopServer } from '../server.mjs';
+import { SessionRegistry } from '../session-registry.mjs';
+
+function fetchJson(baseUrl, token, route) {
+  return new Promise((resolve, reject) => {
+    const url = new URL(route, baseUrl);
+    if (token !== undefined) url.searchParams.set('token', token);
+    http.get(url.toString(), (res) => {
+      let body = '';
+      res.on('data', c => body += c);
+      res.on('end', () => {
+        try { resolve({ status: res.statusCode, headers: res.headers, body: JSON.parse(body) }); }
+        catch { resolve({ status: res.statusCode, headers: res.headers, body }); }
+      });
+    }).on('error', reject);
+  });
+}
+
+function authGet(baseUrl, token, route) {
+  const url = new URL(route, baseUrl);
+  return new Promise((resolve, reject) => {
+    http.get({ hostname: url.hostname, port: url.port, path: url.pathname + url.search,
+      headers: { Authorization: `Bearer ${token}` } }, (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 postJson(baseUrl, token, route, payload = {}) {
+  const url = new URL(route, baseUrl);
+  const body = JSON.stringify(payload);
+  return new Promise((resolve, reject) => {
+    const req = http.request({
+      hostname: url.hostname,
+      port: url.port,
+      path: url.pathname + url.search,
+      method: 'POST',
+      headers: {
+        Authorization: `Bearer ${token}`,
+        'Content-Type': 'application/json',
+        'Content-Length': Buffer.byteLength(body),
+      },
+    }, (res) => {
+      let responseBody = '';
+      res.on('data', c => responseBody += c);
+      res.on('end', () => {
+        try { resolve({ status: res.statusCode, body: JSON.parse(responseBody) }); }
+        catch { resolve({ status: res.statusCode, body: responseBody }); }
+      });
+    });
+    req.on('error', reject);
+    req.end(body);
+  });
+}
+
+let server, baseUrl, token, tempRoot;
+
+before(async () => {
+  tempRoot = fs.mkdtempSync(path.join(os.tmpdir(), 'wf-ui-test-'));
+  const tasksDir = path.join(tempRoot, 'Harness', 'tasks');
+  fs.mkdirSync(tasksDir, { recursive: true });
+  const ta = path.join(tasksDir, 'task-alpha');
+  fs.mkdirSync(ta);
+  fs.writeFileSync(path.join(ta, 'STATE.json'), JSON.stringify({
+    schemaVersion: 1, taskId: 'task-alpha', status: 'active', phase: 'intake',
+    updatedAt: '2026-07-29T10:00:00.000Z',
+    acceptance: [{ id: 'AC-001', text: 'Alpha', status: 'pending' }],
+    links: { dependsOn: [], blocks: [] }
+  }));
+  fs.writeFileSync(path.join(ta, 'PLAN.md'), '# Plan');
+  fs.writeFileSync(path.join(ta, 'PROGRESS.md'), '# Progress');
+
+  const tb = path.join(tasksDir, 'task-beta');
+  fs.mkdirSync(tb);
+  fs.writeFileSync(path.join(tb, 'STATE.json'), JSON.stringify({
+    schemaVersion: 1, taskId: 'task-beta', status: 'active', phase: 'implementation',
+    updatedAt: '2026-07-29T09:00:00.000Z',
+    acceptance: [{ id: 'AC-002', text: 'Beta', status: 'passed' }],
+    links: { dependsOn: ['task-alpha'], blocks: [] }
+  }));
+
+  const hd = path.join(tempRoot, 'Harness');
+  fs.writeFileSync(path.join(hd, 'settings.json'), JSON.stringify({ ui: { language: 'zh' } }));
+  fs.writeFileSync(path.join(hd, '.harness-version'), JSON.stringify({ version: '0.8.19' }));
+
+  const r = await startServer({ projectRoot: tempRoot, host: '127.0.0.1', port: 0 });
+  server = r.server; token = r.token; baseUrl = `http://127.0.0.1:${r.port}`;
+});
+
+after(async () => {
+  if (server) await stopServer(server);
+  if (tempRoot) fs.rmSync(tempRoot, { recursive: true, force: true });
+});
+
+test('binds to 127.0.0.1', () => { const a = server.address(); assert.equal(a.address, '127.0.0.1'); });
+test('port > 0 with port=0', () => { assert.ok(server.address().port > 0); });
+test('health returns 200', async () => { const { status, body } = await fetchJson(baseUrl, token, '/api/health'); assert.equal(status, 200); assert.equal(body.status, 'ok'); });
+test('health auth via Bearer', async () => { const { status, body } = await authGet(baseUrl, token, '/api/health'); assert.equal(status, 200); assert.equal(body.status, 'ok'); });
+test('no token -> 401', async () => { const { status, body } = await fetchJson(baseUrl, undefined, '/api/tasks'); assert.equal(status, 401); assert.equal(body.error.code, 'UNAUTHORIZED'); });
+test('bad token -> 403', async () => { const { status } = await fetchJson(baseUrl, 'bad-token-1234567890abcdef', '/api/tasks'); assert.equal(status, 403); });
+test('project returns root + version', async () => { const { status, body } = await fetchJson(baseUrl, token, '/api/project'); assert.equal(status, 200); assert.equal(body.root, tempRoot); assert.equal(body.version, '0.8.19'); });
+test('tasks returns array sorted desc', async () => { const { status, body } = await fetchJson(baseUrl, token, '/api/tasks'); assert.equal(status, 200); assert.ok(body.length >= 2); assert.equal(body[0].taskId, 'task-alpha'); });
+test('tasks/:id returns single', async () => { const { status, body } = await fetchJson(baseUrl, token, '/api/tasks/task-beta'); assert.equal(status, 200); assert.equal(body.taskId, 'task-beta'); });
+test('tasks/:id missing -> 404', async () => { const { status } = await fetchJson(baseUrl, token, '/api/tasks/task-nonexist'); assert.equal(status, 404); });
+test('tasks with invalid chars -> 400', async () => { const { status } = await fetchJson(baseUrl, token, '/api/tasks/task%00inject'); assert.equal(status, 400); });
+test('settings merged', async () => { const { status, body } = await fetchJson(baseUrl, token, '/api/settings'); assert.equal(status, 200); assert.equal(body.server.host, '127.0.0.1'); assert.equal(body.ui.language, 'zh'); });
+test('sessions empty when no registry', async () => { const { status, body } = await fetchJson(baseUrl, token, '/api/sessions'); assert.equal(status, 200); assert.ok(Array.isArray(body)); assert.equal(body.length, 0); });
+test('error envelope format', async () => { const { status, body } = await fetchJson(baseUrl, undefined, '/api/tasks'); assert.equal(status, 401); assert.ok(body.error.code); assert.ok(body.error.message); });
+test('content-type json', async () => { const { status, headers } = await fetchJson(baseUrl, token, '/api/health'); assert.equal(status, 200); assert.match(headers['content-type'], /application\/json/); });
+test('unknown route 404', async () => { const { status } = await fetchJson(baseUrl, token, '/api/nope'); assert.equal(status, 404); });
+
+test('session stop is idempotent and removes session from live list', async () => {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), 'wf-ui-stop-test-'));
+  fs.mkdirSync(path.join(root, 'Harness', 'tasks'), { recursive: true });
+  const registry = new SessionRegistry();
+  const started = await startServer({ projectRoot: root, host: '127.0.0.1', port: 0, sessionRegistry: registry });
+  const localBaseUrl = `http://127.0.0.1:${started.port}`;
+  try {
+    const session = registry.create({ runtime: 'claude' });
+    registry.update(session.sessionId, { status: 'running' });
+
+    const first = await postJson(localBaseUrl, started.token, `/api/sessions/${session.sessionId}/stop`);
+    assert.equal(first.status, 200);
+    assert.equal(first.body.ok, true);
+    assert.equal(first.body.saved.status, 'saved');
+
+    const live = await fetchJson(localBaseUrl, started.token, '/api/sessions');
+    assert.equal(live.status, 200);
+    assert.deepEqual(live.body, []);
+
+    const second = await postJson(localBaseUrl, started.token, `/api/sessions/${session.sessionId}/stop`);
+    assert.equal(second.status, 200);
+    assert.equal(second.body.ok, true);
+    assert.equal(second.body.alreadyStopped, true);
+  } finally {
+    await stopServer(started.server);
+    fs.rmSync(root, { recursive: true, force: true });
+  }
+});

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

@@ -0,0 +1,238 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { SessionRegistry, ALLOWED_RUNTIMES } from '../session-registry.mjs';
+import { RUNTIME_DEFINITIONS } from '../runtime-detector.mjs';
+
+test('ALLOWED_RUNTIMES contains supported and detectable CLI agents', () => {
+  assert.deepEqual([...ALLOWED_RUNTIMES].sort(), RUNTIME_DEFINITIONS.map(runtime => runtime.id).sort());
+});
+
+test('create with valid runtime claude succeeds', () => {
+  const reg = new SessionRegistry();
+  const session = reg.create({ taskId: 'task-xyz', runtime: 'claude', cols: 120, rows: 32, projectRoot: '/tmp/proj' });
+  assert.ok(session.sessionId);
+  assert.equal(session.taskId, 'task-xyz');
+  assert.equal(session.runtime, 'claude');
+  assert.equal(session.subagentMode, 'wf-subagents');
+  assert.equal(session.workflowMode, null);
+  assert.equal(session.status, 'starting');
+  assert.equal(session.cols, 120);
+  assert.equal(session.rows, 32);
+  assert.equal(session.pid, null);
+  assert.equal(session.exitCode, null);
+  assert.equal(session.wsClientCount, 0);
+  assert.equal(typeof session.startedAt, 'string');
+  assert.equal(typeof session.updatedAt, 'string');
+});
+
+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' });
+  assert.ok(session.sessionId);
+  assert.equal(session.taskId, null);
+  assert.equal(session.runtime, 'opencode');
+  assert.equal(session.model, 'sonnet');
+  assert.equal(session.provider, 'anthropic');
+});
+
+test('create can mark a wf CEO terminal session', () => {
+  const reg = new SessionRegistry();
+  const session = reg.create({
+    runtime: 'codex',
+    role: 'CEO',
+    workflowMode: 'wf',
+    ceoPrompt: 'run the workflow',
+    subagentMode: 'built-in-subagents',
+  });
+  assert.equal(session.role, 'CEO');
+  assert.equal(session.workflowMode, 'wf');
+  assert.equal(session.ceoPrompt, 'run the workflow');
+  assert.equal(session.subagentMode, 'built-in-subagents');
+});
+
+test('create with invalid runtime fake-peer throws', () => {
+  const reg = new SessionRegistry();
+  assert.throws(() => reg.create({ taskId: 'task-xyz', runtime: 'fake-peer' }), {
+    name: 'Error',
+    message: /Invalid runtime.*fake-peer/,
+  });
+});
+
+test('create with codex succeeds', () => {
+  const reg = new SessionRegistry();
+  const session = reg.create({ taskId: 'task-abc', runtime: 'codex', cols: 80, rows: 24, projectRoot: '/tmp' });
+  assert.equal(session.runtime, 'codex');
+  assert.ok(session.sessionId);
+});
+
+test('create with opencode succeeds', () => {
+  const reg = new SessionRegistry();
+  const session = reg.create({ taskId: 'task-abc', runtime: 'opencode', cols: 80, rows: 24, projectRoot: '/tmp' });
+  assert.equal(session.runtime, 'opencode');
+  assert.ok(session.sessionId);
+});
+
+test('create with cc succeeds', () => {
+  const reg = new SessionRegistry();
+  const session = reg.create({ taskId: 'task-abc', runtime: 'cc', cols: 80, rows: 24, projectRoot: '/tmp' });
+  assert.equal(session.runtime, 'cc');
+  assert.ok(session.sessionId);
+});
+
+test('get returns correct session', () => {
+  const reg = new SessionRegistry();
+  const created = reg.create({ taskId: 'task-xyz', runtime: 'claude', cols: 120, rows: 32, projectRoot: '/tmp' });
+  const retrieved = reg.get(created.sessionId);
+  assert.deepEqual(retrieved, created);
+});
+
+test('get returns undefined for unknown sessionId', () => {
+  const reg = new SessionRegistry();
+  assert.equal(reg.get('nonexistent'), undefined);
+});
+
+test('getAll returns array', () => {
+  const reg = new SessionRegistry();
+  reg.create({ taskId: 'task-a', runtime: 'claude', cols: 120, rows: 32, projectRoot: '/tmp' });
+  reg.create({ taskId: 'task-b', runtime: 'codex', cols: 80, rows: 24, projectRoot: '/tmp' });
+  const all = reg.getAll();
+  assert.equal(all.length, 2);
+});
+
+test('getAllForTask filters correctly', () => {
+  const reg = new SessionRegistry();
+  const s1 = reg.create({ taskId: 'task-xyz', runtime: 'claude', cols: 120, rows: 32, projectRoot: '/tmp/a' });
+  const s2 = reg.create({ taskId: 'task-xyz', runtime: 'codex', cols: 80, rows: 24, projectRoot: '/tmp/a' });
+  reg.create({ taskId: 'task-other', runtime: 'claude', cols: 100, rows: 40, projectRoot: '/tmp/b' });
+
+  const filtered = reg.getAllForTask('task-xyz');
+  assert.equal(filtered.length, 2);
+  assert.ok(filtered.some(s => s.sessionId === s1.sessionId));
+  assert.ok(filtered.some(s => s.sessionId === s2.sessionId));
+});
+
+test('update merges status and cols/rows', () => {
+  const reg = new SessionRegistry();
+  const created = reg.create({ taskId: 'task-xyz', runtime: 'claude', cols: 120, rows: 32, projectRoot: '/tmp' });
+
+  reg.update(created.sessionId, { status: 'running', cols: 100, rows: 40 });
+  const updated = reg.get(created.sessionId);
+
+  assert.equal(updated.status, 'running');
+  assert.equal(updated.cols, 100);
+  assert.equal(updated.rows, 40);
+  assert.equal(updated.taskId, 'task-xyz'); // unchanged
+  assert.equal(updated.runtime, 'claude'); // unchanged
+});
+
+test('update merges pid and exitCode', () => {
+  const reg = new SessionRegistry();
+  const created = reg.create({ taskId: 'task-xyz', runtime: 'claude', cols: 120, rows: 32, projectRoot: '/tmp' });
+
+  reg.update(created.sessionId, { pid: 12345 });
+  assert.equal(reg.get(created.sessionId).pid, 12345);
+
+  reg.update(created.sessionId, { status: 'exited', exitCode: 0 });
+  assert.equal(reg.get(created.sessionId).status, 'exited');
+  assert.equal(reg.get(created.sessionId).exitCode, 0);
+});
+
+test('update merges wsClientCount', () => {
+  const reg = new SessionRegistry();
+  const created = reg.create({ taskId: 'task-xyz', runtime: 'claude', cols: 120, rows: 32, projectRoot: '/tmp' });
+  reg.update(created.sessionId, { wsClientCount: 3 });
+  assert.equal(reg.get(created.sessionId).wsClientCount, 3);
+});
+
+test('update sets updatedAt timestamp', () => {
+  const reg = new SessionRegistry();
+  const created = reg.create({ taskId: 'task-xyz', runtime: 'claude', cols: 120, rows: 32, projectRoot: '/tmp' });
+  const before = created.updatedAt;
+
+  // Small delay to ensure different timestamp
+  const updated = reg.get(created.sessionId);
+  reg.update(created.sessionId, { status: 'running' });
+  const after = reg.get(created.sessionId).updatedAt;
+  assert.ok(after >= before);
+});
+
+test('count returns correct number', () => {
+  const reg = new SessionRegistry();
+  assert.equal(reg.count(), 0);
+  reg.create({ taskId: 'task-a', runtime: 'claude', cols: 120, rows: 32, projectRoot: '/tmp' });
+  assert.equal(reg.count(), 1);
+  reg.create({ taskId: 'task-b', runtime: 'opencode', cols: 100, rows: 40, projectRoot: '/tmp' });
+  assert.equal(reg.count(), 2);
+});
+
+test('remove then get returns undefined', () => {
+  const reg = new SessionRegistry();
+  const created = reg.create({ taskId: 'task-xyz', runtime: 'claude', cols: 120, rows: 32, projectRoot: '/tmp' });
+  assert.equal(reg.count(), 1);
+
+  reg.remove(created.sessionId);
+  assert.equal(reg.get(created.sessionId), undefined);
+  assert.equal(reg.count(), 0);
+});
+
+test('stop removes web session from live registry and returns saved 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(reg.get(created.sessionId), undefined);
+  assert.equal(reg.count(), 0);
+});
+
+test('withLock serializes updates for the same session', async () => {
+  const reg = new SessionRegistry();
+  const created = reg.create({ runtime: 'claude' });
+  const events = [];
+
+  await Promise.all([
+    reg.withLock(created.sessionId, async () => {
+      events.push('a:start');
+      await new Promise(resolve => setTimeout(resolve, 20));
+      events.push('a:end');
+    }),
+    reg.withLock(created.sessionId, async () => {
+      events.push('b:start');
+      events.push('b:end');
+    }),
+  ]);
+
+  assert.deepEqual(events, ['a:start', 'a:end', 'b:start', 'b:end']);
+});
+
+test('remove non-existent session does nothing', () => {
+  const reg = new SessionRegistry();
+  reg.remove('nonexistent');
+  assert.equal(reg.count(), 0);
+});
+
+test('two concurrent sessions do not interfere', () => {
+  const reg = new SessionRegistry();
+  const s1 = reg.create({ taskId: 'task-a', runtime: 'claude', cols: 120, rows: 32, projectRoot: '/proj-a' });
+  const s2 = reg.create({ taskId: 'task-b', runtime: 'codex', cols: 80, rows: 24, projectRoot: '/proj-b' });
+
+  assert.notEqual(s1.sessionId, s2.sessionId);
+  assert.equal(s1.taskId, 'task-a');
+  assert.equal(s2.taskId, 'task-b');
+
+  reg.update(s1.sessionId, { status: 'running' });
+  assert.equal(reg.get(s1.sessionId).status, 'running');
+  assert.equal(reg.get(s2.sessionId).status, 'starting'); // unchanged
+
+  reg.remove(s1.sessionId);
+  assert.equal(reg.get(s1.sessionId), undefined);
+  assert.equal(reg.get(s2.sessionId).taskId, 'task-b'); // s2 intact
+  assert.equal(reg.count(), 1);
+});
+
+test('create returns session with peerId derived from runtime', () => {
+  const reg = new SessionRegistry();
+  const session = reg.create({ taskId: 'task-xyz', runtime: 'claude', cols: 120, rows: 32, projectRoot: '/tmp' });
+  assert.ok(session.peerId);
+  assert.ok(session.peerId.startsWith('claude-'));
+});

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

@@ -0,0 +1,135 @@
+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 { loadSettings, resolveSettings } from '../settings.mjs';
+import { RUNTIME_DEFINITIONS } from '../runtime-detector.mjs';
+
+const DEFAULTS = {
+  server: { host: '127.0.0.1', port: 0 },
+  terminal: { enabled: false, attachMode: false, defaultRuntime: 'codex' },
+  peers: { allowlist: RUNTIME_DEFINITIONS.map(runtime => runtime.id) },
+  ui: { theme: 'auto', language: 'en', reducedMotion: false },
+};
+
+describe('settings', () => {
+  let baseDir;
+
+  before(() => {
+    baseDir = fs.mkdtempSync(path.join(os.tmpdir(), 'st-test-'));
+  });
+
+  after(() => {
+    fs.rmSync(baseDir, { recursive: true, force: true });
+  });
+
+  test('loadSettings returns defaults when no settings.json exists', () => {
+    const settings = loadSettings(baseDir);
+    assert.deepEqual(settings, DEFAULTS);
+  });
+
+  test('project settings override defaults', () => {
+    const projectDir = path.join(baseDir, 'override-test');
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.mkdirSync(path.join(projectDir, 'Harness'), { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDir, 'Harness', 'settings.json'),
+      JSON.stringify({
+        server: { port: 3456 },
+        ui: { language: 'zh-CN' },
+      })
+    );
+
+    const settings = loadSettings(projectDir);
+
+    assert.equal(settings.server.host, '127.0.0.1'); // from defaults
+    assert.equal(settings.server.port, 3456); // from project
+    assert.equal(settings.ui.language, 'zh-CN'); // from project
+    assert.equal(settings.ui.theme, 'auto'); // from defaults
+    assert.equal(settings.terminal.enabled, false); // from defaults
+    assert.deepEqual(settings.peers.allowlist, RUNTIME_DEFINITIONS.map(runtime => runtime.id)); // from defaults
+  });
+
+  test('unknown keys are silently ignored in project settings', () => {
+    const projectDir = path.join(baseDir, 'unknown-keys');
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.mkdirSync(path.join(projectDir, 'Harness'), { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDir, 'Harness', 'settings.json'),
+      JSON.stringify({
+        unknownKey: 'should-be-ignored',
+        nestedUnknown: { inner: 'also-ignored' },
+        server: { host: '0.0.0.0' },
+      })
+    );
+
+    const settings = loadSettings(projectDir);
+
+    assert.equal(settings.server.host, '0.0.0.0');
+    assert.equal(settings.server.port, 0);
+    // unknown keys should not appear
+    assert.equal(Object.hasOwn(settings, 'unknownKey'), false);
+    assert.equal(Object.hasOwn(settings, 'nestedUnknown'), false);
+  });
+
+  test('missing required keys get default values', () => {
+    const projectDir = path.join(baseDir, 'missing-keys');
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.mkdirSync(path.join(projectDir, 'Harness'), { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDir, 'Harness', 'settings.json'),
+      JSON.stringify({
+        server: { host: '0.0.0.0' },
+      })
+    );
+
+    const settings = loadSettings(projectDir);
+
+    assert.equal(settings.server.host, '0.0.0.0');
+    assert.equal(settings.server.port, 0); // default, not provided
+    assert.equal(settings.terminal.enabled, false); // default, not provided
+  });
+
+  test('nested settings merge correctly (not full replace)', () => {
+    const projectDir = path.join(baseDir, 'nested-merge');
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.mkdirSync(path.join(projectDir, 'Harness'), { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDir, 'Harness', 'settings.json'),
+      JSON.stringify({
+        server: { port: 8080 },
+        peers: { allowlist: ['claude'] },
+      })
+    );
+
+    const settings = loadSettings(projectDir);
+
+    // server.host came from defaults, server.port from project
+    assert.equal(settings.server.host, '127.0.0.1');
+    assert.equal(settings.server.port, 8080);
+    // peers.allowlist replaced (not merged)
+    assert.deepEqual(settings.peers.allowlist, ['claude']);
+    // ui fully from defaults
+    assert.equal(settings.ui.theme, 'auto');
+    assert.equal(settings.ui.language, 'en');
+  });
+
+  test('resolveSettings returns the merged result from loadSettings', () => {
+    const projectDir = path.join(baseDir, 'resolve-test');
+    fs.mkdirSync(projectDir, { recursive: true });
+    fs.mkdirSync(path.join(projectDir, 'Harness'), { recursive: true });
+    fs.writeFileSync(
+      path.join(projectDir, 'Harness', 'settings.json'),
+      JSON.stringify({
+        terminal: { enabled: true },
+      })
+    );
+
+    // resolveSettings takes a precedence object (project root overrides)
+    const settings = resolveSettings({ projectRoot: projectDir });
+
+    assert.equal(settings.terminal.enabled, true);
+    assert.equal(settings.server.host, '127.0.0.1');
+  });
+});