mirror of
https://github.com/affaan-m/ECC.git
synced 2026-09-18 15:50:25 +02:00
Affaan MustafaandGitHub
1ed03ecf2e
Exact-head independent local Codex review PASS with no P0/P1. CI run 34680860653 attempt 2 passed at 0707cd431c. Includes HTTP/schema failure handling, coalesced sampling cache and regression tests. Disclosed P2 follow-ups remain in the merge-queue receipt. Rollback: revert this squash commit. No deployment or publication claim.
335 lines
16 KiB
JavaScript
335 lines
16 KiB
JavaScript
'use strict';
|
|
/**
|
|
* Tests for scripts/lib/control-pane/control-plane-view.js: the
|
|
* ecc.control-plane.view.v1 contract (tasks, lanes, events, projection,
|
|
* inventory) built from a control-pane snapshot with proximity.
|
|
*/
|
|
|
|
const assert = require('assert');
|
|
|
|
const { buildProximitySnapshot } = require('../../scripts/lib/control-pane/proximity');
|
|
const { buildControlPlaneView, createControlPlaneViewSource, buildInventoryManifest, VIEW_SCHEMA_VERSION, EVENT_KINDS, _internal } = require('../../scripts/lib/control-pane/control-plane-view');
|
|
const { createProjectionWindow } = require('../../scripts/lib/agent-proximity/projection');
|
|
|
|
let passed = 0;
|
|
let failed = 0;
|
|
async function test(name, fn) {
|
|
try {
|
|
await fn();
|
|
console.log(` PASS ${name}`);
|
|
passed += 1;
|
|
} catch (e) {
|
|
console.log(` FAIL ${name}`);
|
|
console.log(` ${e.message}`);
|
|
failed += 1;
|
|
}
|
|
}
|
|
|
|
const NOW = '2026-09-11T20:01:00.000Z';
|
|
|
|
function session(id, extra = {}) {
|
|
return {
|
|
id,
|
|
task: `Task ${id}`,
|
|
project: '',
|
|
taskGroup: '',
|
|
agentType: 'worker',
|
|
harness: 'codex',
|
|
state: 'running',
|
|
pid: null,
|
|
worktree: { path: `/tmp/wt/${id}`, branch: `feat/${id}`, base: 'main' },
|
|
lastHeartbeatAt: '2026-09-11T20:00:00Z',
|
|
updatedAt: '2026-09-11T20:00:00Z',
|
|
unreadMessages: 0,
|
|
metrics: { tokensUsed: 0, costUsd: 0 },
|
|
...extra
|
|
};
|
|
}
|
|
|
|
const WORKING_SETS = {
|
|
a: [{ path: 'src/api/users.js', lines: [[1, 50]] }, { path: 'src/db/schema.js' }],
|
|
b: [{ path: 'src/api/users.js', lines: [[10, 30]] }],
|
|
c: [{ path: 'docs/guide.md' }],
|
|
d: [{ path: 'src/api/posts.js' }],
|
|
idle: []
|
|
};
|
|
|
|
function snapshotFor(sessions, extra = {}) {
|
|
const proximity = buildProximitySnapshot(sessions, {
|
|
workingSetFor: s => WORKING_SETS[s.id] || [],
|
|
graph: { adjacency: { 'src/api/posts.js': ['src/db/schema.js'] } }
|
|
});
|
|
return { schemaVersion: 'ecc.control-pane.snapshot.v1', repoRoot: '/tmp/repo', dbPath: '/tmp/ecc2.db', sessions, proximity, ...extra };
|
|
}
|
|
|
|
(async () => {
|
|
console.log('\n=== Testing control-plane view ===\n');
|
|
|
|
await test('view: schema, counts, lanes and tasks from a four-session snapshot', () => {
|
|
const sessions = [
|
|
session('a', { taskGroup: 'ecc' }),
|
|
session('b', { harness: 'claude', project: 'ecc-website' }),
|
|
session('c', { harness: 'hermes', state: 'completed', lastHeartbeatAt: '' }),
|
|
session('d', { pid: 4242 })
|
|
];
|
|
const view = buildControlPlaneView(snapshotFor(sessions), { now: NOW });
|
|
assert.strictEqual(view.schemaVersion, VIEW_SCHEMA_VERSION);
|
|
assert.strictEqual(view.generatedAt, NOW);
|
|
assert.deepStrictEqual(view.source, { snapshotSchema: 'ecc.control-pane.snapshot.v1', repoRoot: '/tmp/repo', dbPath: '/tmp/ecc2.db' });
|
|
assert.deepStrictEqual(view.thresholds, { ta: 0.35, ra: 0.7, source: 'static' });
|
|
assert.strictEqual(view.counts.tasks, 4);
|
|
assert.strictEqual(view.counts.agents, 4);
|
|
assert.strictEqual(view.counts.pairs, 6);
|
|
assert.strictEqual(view.counts.lanes, 4);
|
|
const laneIds = view.lanes.map(l => l.id).sort();
|
|
assert.deepStrictEqual(laneIds, ['group:ecc', 'harness:codex', 'harness:hermes', 'project:ecc-website']);
|
|
const group = view.lanes.find(l => l.id === 'group:ecc');
|
|
assert.deepStrictEqual(group, { id: 'group:ecc', label: 'ecc', kind: 'task-group', taskIds: ['a'] });
|
|
|
|
const a = view.tasks.find(t => t.id === 'a');
|
|
assert.strictEqual(a.lane, 'group:ecc');
|
|
assert.strictEqual(a.label, 'Task a');
|
|
assert.strictEqual(a.harness, 'codex');
|
|
assert.strictEqual(a.state, 'running');
|
|
assert.deepStrictEqual(a.worktree, { path: '/tmp/wt/a', branch: 'feat/a', base: 'main' });
|
|
assert.strictEqual(a.heartbeatAt, '2026-09-11T20:00:00.000Z');
|
|
assert.deepStrictEqual(a.workingSet, { fileCount: 2, files: ['src/api/users.js', 'src/db/schema.js'] });
|
|
assert.strictEqual(a.projection.point.length, 2);
|
|
assert.strictEqual(a.projection.pairs, 3);
|
|
assert.strictEqual(a.projection.maxRisk, 1);
|
|
assert.strictEqual(a.inventory.authority, 'declared-only');
|
|
assert.strictEqual(a.inventory.heartbeat.state, 'fresh');
|
|
|
|
const c = view.tasks.find(t => t.id === 'c');
|
|
assert.strictEqual(c.heartbeatAt, null);
|
|
assert.strictEqual(c.inventory.heartbeat.state, 'unknown');
|
|
assert.strictEqual(c.projection.maxRisk, 0);
|
|
|
|
const d = view.tasks.find(t => t.id === 'd');
|
|
assert.strictEqual(d.pid, 4242);
|
|
assert.ok(d.projection.maxRisk >= 0.7, 'd couples to a through the import graph');
|
|
});
|
|
|
|
await test('view: static-threshold advisory events carry level, threshold, channels and action', () => {
|
|
const sessions = [session('a'), session('b'), session('c'), session('d')];
|
|
const view = buildControlPlaneView(snapshotFor(sessions), { now: NOW });
|
|
const advisories = view.events.filter(e => e.kind === EVENT_KINDS.advisory);
|
|
assert.strictEqual(advisories.length, 2, 'a/b overlap and a/d dependency both cross a threshold');
|
|
assert.strictEqual(view.counts.advisories, 2);
|
|
const ab = advisories.find(e => e.subject.a === 'a' && e.subject.b === 'b');
|
|
assert.ok(ab, 'a/b event present');
|
|
assert.strictEqual(ab.id, 'proximity.advisory:a|b:resolution');
|
|
assert.strictEqual(ab.level, 'resolution');
|
|
assert.strictEqual(ab.severity, 'critical');
|
|
assert.strictEqual(ab.at, NOW);
|
|
assert.strictEqual(ab.risk, 1);
|
|
assert.deepStrictEqual(ab.channels, { x_tree: 1, x_overlap: 1, x_dep: 0 });
|
|
assert.deepStrictEqual(ab.threshold, { ta: 0.35, ra: 0.7, crossed: 'ra', source: 'static' });
|
|
assert.strictEqual(ab.action.type, 'steer');
|
|
assert.ok(['a', 'b'].includes(ab.action.steer) && ['a', 'b'].includes(ab.action.hold) && ab.action.steer !== ab.action.hold);
|
|
assert.strictEqual(ab.action.hold, 'a', 'a has more committed work, so a holds');
|
|
assert.ok(ab.message.includes('static threshold 0.7'));
|
|
assert.strictEqual(view.counts.resolutions, 2);
|
|
assert.ok(view.limits.some(l => l.includes('static thresholds')));
|
|
});
|
|
|
|
await test('view: custom thresholds change the level and the event says which line was crossed', () => {
|
|
const sessions = [session('a'), session('b')];
|
|
const view = buildControlPlaneView(snapshotFor(sessions), { now: NOW, thresholds: { ta: 0.2, ra: 1.5 } });
|
|
assert.deepStrictEqual(view.thresholds, { ta: 0.2, ra: 1.5, source: 'static' });
|
|
assert.strictEqual(view.events.length, 1);
|
|
const ev = view.events[0];
|
|
assert.strictEqual(ev.level, 'traffic');
|
|
assert.strictEqual(ev.severity, 'warning');
|
|
assert.strictEqual(ev.threshold.crossed, 'ta');
|
|
assert.deepStrictEqual(ev.action, { type: 'transmit', steer: null, hold: null });
|
|
assert.strictEqual(ev.id, 'proximity.advisory:a|b:traffic');
|
|
});
|
|
|
|
await test('view: projection is PCA over the shipped channels with a rolling window', () => {
|
|
const sessions = [session('a'), session('b'), session('c'), session('d')];
|
|
const window = createProjectionWindow({ windowSize: 64 });
|
|
const snapshot = snapshotFor(sessions);
|
|
const first = buildControlPlaneView(snapshot, { now: NOW, window });
|
|
assert.strictEqual(first.projection.method, 'pca');
|
|
assert.deepStrictEqual(first.projection.channels, ['x_tree', 'x_overlap', 'x_dep']);
|
|
assert.strictEqual(first.projection.normalization, 'raw', 'six samples is below the warm-up');
|
|
const second = buildControlPlaneView(snapshot, { now: NOW, window });
|
|
assert.strictEqual(second.projection.normalization, 'zscore-clipped');
|
|
assert.strictEqual(second.projection.window.samples, 12);
|
|
assert.deepStrictEqual(second.projection.window.percentiles, [2.5, 97.5]);
|
|
assert.strictEqual(second.projection.pca.loadings.length, 2);
|
|
assert.ok(second.projection.pca.explainedVariance[0] > 0);
|
|
assert.strictEqual(second.pairs.length, 6);
|
|
for (const pair of second.pairs) {
|
|
assert.ok(Array.isArray(pair.point) && pair.point.length === 2);
|
|
assert.ok(Object.keys(pair.normalized).every(k => pair.normalized[k] >= 0 && pair.normalized[k] <= 1));
|
|
}
|
|
assert.strictEqual(second.projection.agents.length, 4);
|
|
assert.ok(!('pairs' in second.projection), 'pairs live at the top level, not under projection');
|
|
});
|
|
|
|
await test('view: inventory is declared-only, maps sanitized ids and reports lease conflicts as events', () => {
|
|
const sessions = [session('a'), session('weird id!/x'), session('c', { state: 'stopped' })];
|
|
const manifest = {
|
|
leases: [
|
|
{ resource: 'browser:chrome', owner: 'a', expiresAt: '2026-09-11T21:00:00Z' },
|
|
{ resource: 'browser:chrome', owner: 'c', expiresAt: '2026-09-11T21:00:00Z' }
|
|
]
|
|
};
|
|
const view = buildControlPlaneView(snapshotFor(sessions), { now: NOW, manifest });
|
|
assert.strictEqual(view.inventory.status, 'ok');
|
|
assert.strictEqual(view.inventory.mode, 'read-only');
|
|
assert.strictEqual(view.inventory.observedAt, NOW);
|
|
assert.deepStrictEqual(view.inventory.activity.declaredSessionsByStatus, { open: 2, closed: 1, unknown: 0 });
|
|
assert.strictEqual(view.inventory.coverage.leases, 'declared-only');
|
|
assert.ok(Array.isArray(view.inventory.limits) && view.inventory.limits.length > 0);
|
|
assert.deepStrictEqual(view.inventory.leaseConflicts, [{ resource: 'browser:chrome', owners: ['a', 'c'] }]);
|
|
const weird = view.tasks.find(t => t.id === 'weird id!/x');
|
|
assert.strictEqual(weird.inventory.id, 'weird-id--x');
|
|
assert.strictEqual(weird.inventory.heartbeat.state, 'fresh');
|
|
const conflict = view.events.find(e => e.kind === EVENT_KINDS.leaseConflict);
|
|
assert.ok(conflict, 'lease conflict surfaced as an event');
|
|
assert.strictEqual(conflict.id, 'inventory.lease-conflict:browser:chrome');
|
|
assert.strictEqual(conflict.level, 'conflict');
|
|
assert.deepStrictEqual(conflict.subject, { resource: 'browser:chrome', owners: ['a', 'c'] });
|
|
assert.strictEqual(conflict.action.type, 'review');
|
|
assert.ok(conflict.message.includes('not a lock'));
|
|
});
|
|
|
|
await test('view: inventory failure degrades to unavailable without breaking the view', () => {
|
|
const sessions = [session('a'), session('b')];
|
|
const inventoryModule = { buildInventory: () => { throw new Error('Invalid coordination input.'); } };
|
|
const view = buildControlPlaneView(snapshotFor(sessions), { now: NOW, inventoryModule });
|
|
assert.deepStrictEqual(view.inventory, { status: 'unavailable', truncated: false, reason: 'Invalid coordination input.' });
|
|
assert.strictEqual(view.tasks.length, 2);
|
|
assert.strictEqual(view.tasks[0].inventory.heartbeat, null);
|
|
assert.strictEqual(view.events.length, 1, 'advisory events still flow');
|
|
});
|
|
|
|
await test('view: sessions without edits are tasks with no projection point and no pairs', () => {
|
|
const sessions = [session('idle'), session('a')];
|
|
const view = buildControlPlaneView(snapshotFor(sessions), { now: NOW });
|
|
assert.strictEqual(view.counts.tasks, 2);
|
|
assert.strictEqual(view.counts.agents, 1);
|
|
assert.strictEqual(view.counts.pairs, 0);
|
|
assert.strictEqual(view.events.length, 0);
|
|
const idle = view.tasks.find(t => t.id === 'idle');
|
|
assert.deepStrictEqual(idle.projection, { point: null, pairs: 0, maxRisk: 0 });
|
|
assert.deepStrictEqual(idle.workingSet, { fileCount: 0, files: [] });
|
|
assert.strictEqual(view.projection.normalization, 'raw');
|
|
});
|
|
|
|
await test('view: empty and missing snapshots produce an empty, well-formed view', () => {
|
|
const empty = buildControlPlaneView({ sessions: [], proximity: null }, { now: NOW });
|
|
assert.strictEqual(empty.schemaVersion, VIEW_SCHEMA_VERSION);
|
|
assert.deepStrictEqual(empty.tasks, []);
|
|
assert.deepStrictEqual(empty.lanes, []);
|
|
assert.deepStrictEqual(empty.events, []);
|
|
assert.deepStrictEqual(empty.pairs, []);
|
|
assert.strictEqual(empty.inventory.status, 'ok');
|
|
const none = buildControlPlaneView(undefined, { now: NOW });
|
|
assert.deepStrictEqual(none.counts, { lanes: 0, tasks: 0, agents: 0, pairs: 0, events: 0, advisories: 0, resolutions: 0 });
|
|
assert.deepStrictEqual(none.source, { snapshotSchema: null, repoRoot: null, dbPath: null });
|
|
});
|
|
|
|
await test('buildInventoryManifest: caps tasks at 64, filters unsafe paths and merges an external manifest', () => {
|
|
const sessions = Array.from({ length: 70 }, (_, i) => session(`s${i}`));
|
|
const agents = new Map([['s0', { files: ['ok/file.js', '/abs/file.js', '../up.js', 'C:/win.js', 'a//b.js'] }]]);
|
|
const built = buildInventoryManifest(sessions, agents, { manifest: { goals: [{ id: 'g1', kind: 'native', status: 'active' }], tasks: [{ id: 'external', paths: [] }] } });
|
|
assert.strictEqual(built.truncated, true);
|
|
assert.strictEqual(built.manifest.tasks.length, 65);
|
|
assert.deepStrictEqual(built.manifest.tasks[0].paths, ['ok/file.js']);
|
|
assert.strictEqual(built.manifest.goals.length, 1);
|
|
assert.strictEqual(built.manifest.sessions.length, 64);
|
|
assert.strictEqual(built.manifest.sessions[0].status, 'open');
|
|
assert.strictEqual(built.idMap.get('s0'), 's0');
|
|
});
|
|
|
|
await test('internal: inventory ids are sanitized and deduplicated; states map to open/closed/unknown', () => {
|
|
const taken = new Set();
|
|
assert.strictEqual(_internal.inventoryIdFor('plain-id', 0, taken), 'plain-id');
|
|
assert.strictEqual(_internal.inventoryIdFor('plain-id', 1, taken), 'plain-id-2');
|
|
assert.strictEqual(_internal.inventoryIdFor('!!!', 2, taken), 'task-3');
|
|
assert.strictEqual(_internal.inventoryIdFor('__proto__', 3, taken), 'proto__', 'leading underscores stripped, no longer reserved');
|
|
assert.strictEqual(_internal.inventoryIdFor('constructor', 5, taken), 'task-6', 'reserved word falls back to a positional id');
|
|
assert.strictEqual(_internal.inventoryIdFor('a b/c', 4, taken), 'a-b-c');
|
|
assert.strictEqual(_internal.sessionDeclarationStatus('running'), 'open');
|
|
assert.strictEqual(_internal.sessionDeclarationStatus('failed'), 'closed');
|
|
assert.strictEqual(_internal.sessionDeclarationStatus('weird'), 'unknown');
|
|
assert.deepStrictEqual(_internal.laneFor({ harness: 'codex' }), { id: 'harness:codex', label: 'codex', kind: 'harness' });
|
|
});
|
|
|
|
await test('createControlPlaneViewSource: keeps one window across builds', async () => {
|
|
const sessions = [session('a'), session('b'), session('c'), session('d')];
|
|
const snapshot = snapshotFor(sessions);
|
|
let builds = 0;
|
|
let clock = 1000;
|
|
const source = createControlPlaneViewSource({
|
|
clock: () => clock,
|
|
buildSnapshot: async () => {
|
|
builds += 1;
|
|
return snapshot;
|
|
},
|
|
projection: { windowSize: 32 },
|
|
viewOptions: { now: NOW }
|
|
});
|
|
const first = await source.build();
|
|
clock += 5000;
|
|
const second = await source.build();
|
|
assert.strictEqual(builds, 2);
|
|
assert.strictEqual(first.projection.window.samples, 6);
|
|
assert.strictEqual(second.projection.window.samples, 12);
|
|
assert.strictEqual(source.window.size, 32);
|
|
assert.strictEqual(second.generatedAt, NOW);
|
|
});
|
|
|
|
await test('view source samples once per interval despite repeated and concurrent reads', async () => {
|
|
let clock = 1000;
|
|
let builds = 0;
|
|
const source = createControlPlaneViewSource({
|
|
clock: () => clock,
|
|
buildSnapshot: async () => { builds += 1; return snapshotFor([session('a'), session('b')]); },
|
|
viewOptions: { now: NOW }
|
|
});
|
|
const views = await Promise.all(Array.from({ length: 10 }, () => source.build()));
|
|
assert.strictEqual(builds, 1);
|
|
assert.strictEqual(source.window.length, 1);
|
|
assert.ok(views.every(view => view.generatedAt === views[0].generatedAt));
|
|
await source.build();
|
|
await source.build({ thresholds: { ta: 0.2, ra: 1.5 } });
|
|
assert.strictEqual(source.window.length, 1, 'alternate read options must not resample');
|
|
clock += 5000;
|
|
await source.build();
|
|
assert.strictEqual(builds, 2);
|
|
assert.strictEqual(source.window.length, 2);
|
|
});
|
|
|
|
await test('view source rejects failed refreshes and retries without false healthy data', async () => {
|
|
let fail = true;
|
|
let clock = 0;
|
|
const source = createControlPlaneViewSource({
|
|
clock: () => clock,
|
|
buildSnapshot: async () => {
|
|
if (fail) throw new Error('snapshot unavailable');
|
|
return snapshotFor([session('a'), session('b')]);
|
|
}
|
|
});
|
|
await assert.rejects(source.build(), /snapshot unavailable/);
|
|
assert.strictEqual(source.window.length, 0);
|
|
fail = false;
|
|
await source.build();
|
|
assert.strictEqual(source.window.length, 1);
|
|
clock += 5000;
|
|
fail = true;
|
|
await assert.rejects(source.build(), /snapshot unavailable/);
|
|
assert.strictEqual(source.window.length, 1);
|
|
fail = false;
|
|
await source.build();
|
|
assert.strictEqual(source.window.length, 2);
|
|
});
|
|
|
|
console.log(`\nResults: Passed: ${passed}, Failed: ${failed}`);
|
|
if (failed > 0) process.exit(1);
|
|
})();
|