Lyon
571 lines
29 KiB
TypeScript
571 lines
29 KiB
TypeScript
import { codexQueuesQueryForTest } from "./src/code-queue";
|
|
|
|
type JsonRecord = Record<string, unknown>;
|
|
|
|
function assertCondition(condition: unknown, message: string, detail: JsonRecord = {}): void {
|
|
if (!condition) throw new Error(`${message}: ${JSON.stringify(detail)}`);
|
|
}
|
|
|
|
function asRecord(value: unknown): JsonRecord {
|
|
assertCondition(typeof value === "object" && value !== null && !Array.isArray(value), "expected JSON object", { value });
|
|
return value as JsonRecord;
|
|
}
|
|
|
|
function asArray(value: unknown): unknown[] {
|
|
assertCondition(Array.isArray(value), "expected JSON array", { value });
|
|
return value as unknown[];
|
|
}
|
|
|
|
function manyIds(prefix: string, count: number): string[] {
|
|
return Array.from({ length: count }, (_, index) => `${prefix}-${String(index + 1).padStart(2, "0")}`);
|
|
}
|
|
|
|
function fixtureResponse(): JsonRecord {
|
|
return {
|
|
ok: true,
|
|
status: 200,
|
|
body: {
|
|
ok: true,
|
|
queue: {
|
|
total: 4,
|
|
queueCount: 3,
|
|
activeQueueIds: ["alpha"],
|
|
activeTaskIds: ["task-running"],
|
|
queuedTaskIds: ["task-queued"],
|
|
counts: { running: 1, queued: 2, succeeded: 1 },
|
|
unreadTerminal: 1,
|
|
executionDiagnostics: {
|
|
state: "split-brain",
|
|
splitBrain: true,
|
|
heartbeatFreshTaskIds: ["task-running"],
|
|
databaseActiveTaskCount: 1,
|
|
databaseActiveTaskIds: ["task-running"],
|
|
schedulerActiveRunSlotCount: 0,
|
|
schedulerActiveTaskIds: [],
|
|
},
|
|
},
|
|
queues: [
|
|
{
|
|
id: "alpha",
|
|
name: "Alpha",
|
|
total: 1,
|
|
counts: { running: 1, queued: 0 },
|
|
unreadTerminal: 0,
|
|
activeTaskId: "task-running",
|
|
runnableTaskId: null,
|
|
updatedAt: "2026-05-20T00:00:00.000Z",
|
|
},
|
|
{
|
|
id: "beta",
|
|
name: "Beta",
|
|
total: 2,
|
|
counts: { running: 0, queued: 2 },
|
|
unreadTerminal: 0,
|
|
activeTaskId: null,
|
|
runnableTaskId: "task-queued",
|
|
updatedAt: "2026-05-20T00:01:00.000Z",
|
|
},
|
|
{
|
|
id: "gamma",
|
|
name: "Gamma",
|
|
total: 1,
|
|
counts: { succeeded: 1 },
|
|
unreadTerminal: 1,
|
|
activeTaskId: null,
|
|
runnableTaskId: null,
|
|
updatedAt: "2026-05-20T00:02:00.000Z",
|
|
},
|
|
],
|
|
},
|
|
};
|
|
}
|
|
|
|
function splitBrainLiveResponse(): JsonRecord {
|
|
const liveTaskIds = manyIds("task-running", 8);
|
|
return {
|
|
ok: true,
|
|
status: 200,
|
|
body: {
|
|
ok: true,
|
|
queue: {
|
|
total: 8,
|
|
queueCount: 2,
|
|
activeQueueIds: [],
|
|
activeTaskIds: [],
|
|
queuedTaskIds: [],
|
|
counts: { running: 8 },
|
|
unreadTerminal: 0,
|
|
executionDiagnostics: {
|
|
state: "split-brain",
|
|
splitBrain: true,
|
|
splitBrainLive: true,
|
|
effectiveLiveness: "live",
|
|
recommendedAction: "continue-supervision",
|
|
databaseActiveTaskCount: 8,
|
|
databaseActiveTaskIds: liveTaskIds,
|
|
schedulerActiveRunSlotCount: 0,
|
|
schedulerActiveTaskIds: [],
|
|
activeHeartbeatCount: 8,
|
|
activeHeartbeatTaskIds: liveTaskIds,
|
|
heartbeatFreshTaskIds: liveTaskIds,
|
|
heartbeatExpiredTaskIds: [],
|
|
heartbeatMissingTaskIds: [],
|
|
staleRecoveryCandidateTaskIds: [],
|
|
heartbeatRiskTaskIds: [],
|
|
},
|
|
},
|
|
queues: [
|
|
{
|
|
id: "alpha",
|
|
name: "Alpha",
|
|
total: 4,
|
|
counts: { running: 4 },
|
|
unreadTerminal: 0,
|
|
activeTaskId: null,
|
|
runnableTaskId: null,
|
|
updatedAt: "2026-05-20T00:00:00.000Z",
|
|
},
|
|
{
|
|
id: "beta",
|
|
name: "Beta",
|
|
total: 4,
|
|
counts: { running: 4 },
|
|
unreadTerminal: 0,
|
|
activeTaskId: null,
|
|
runnableTaskId: null,
|
|
updatedAt: "2026-05-20T00:01:00.000Z",
|
|
},
|
|
],
|
|
},
|
|
};
|
|
}
|
|
|
|
function heartbeatRiskResponse(): JsonRecord {
|
|
const staleTaskIds = manyIds("task-stale", 4);
|
|
return {
|
|
ok: true,
|
|
status: 200,
|
|
body: {
|
|
ok: true,
|
|
queue: {
|
|
total: 6,
|
|
queueCount: 3,
|
|
activeQueueIds: [],
|
|
activeTaskIds: [],
|
|
queuedTaskIds: ["task-queued-risk"],
|
|
counts: { running: 4, queued: 1, retry_wait: 1 },
|
|
unreadTerminal: 0,
|
|
executionDiagnostics: {
|
|
state: "stale-active",
|
|
effectiveLiveness: "at-risk",
|
|
recommendedAction: "investigate-heartbeat-risk",
|
|
now: "2026-05-20T00:30:00.000Z",
|
|
databaseActiveTaskCount: 4,
|
|
databaseActiveTaskIds: staleTaskIds,
|
|
schedulerActiveRunSlotCount: 0,
|
|
schedulerActiveTaskIds: [],
|
|
activeHeartbeatCount: 4,
|
|
activeHeartbeatTaskIds: staleTaskIds,
|
|
heartbeatFreshTaskIds: [],
|
|
heartbeatExpiredTaskIds: staleTaskIds,
|
|
heartbeatMissingTaskIds: [],
|
|
staleRecoveryCandidateTaskIds: staleTaskIds,
|
|
heartbeatRiskTaskIds: staleTaskIds,
|
|
lastSchedulerHeartbeatAt: "2026-05-20T00:15:00.000Z",
|
|
lastObservedAgentEventAt: "2026-05-20T00:14:30.000Z",
|
|
reasons: ["heartbeat expired for database-active tasks"],
|
|
},
|
|
},
|
|
queues: [
|
|
{
|
|
id: "risk-a",
|
|
name: "Risk A",
|
|
total: 3,
|
|
counts: { running: 3 },
|
|
unreadTerminal: 0,
|
|
activeTaskId: null,
|
|
runnableTaskId: null,
|
|
updatedAt: "2026-05-20T00:20:00.000Z",
|
|
},
|
|
{
|
|
id: "risk-b",
|
|
name: "Risk B",
|
|
total: 1,
|
|
counts: { running: 1 },
|
|
unreadTerminal: 0,
|
|
activeTaskId: null,
|
|
runnableTaskId: null,
|
|
updatedAt: "2026-05-20T00:19:00.000Z",
|
|
},
|
|
{
|
|
id: "risk-queued",
|
|
name: "Risk Queued",
|
|
total: 2,
|
|
counts: { queued: 1, retry_wait: 1 },
|
|
unreadTerminal: 0,
|
|
activeTaskId: null,
|
|
runnableTaskId: "task-queued-risk",
|
|
updatedAt: "2026-05-20T00:18:00.000Z",
|
|
},
|
|
],
|
|
},
|
|
};
|
|
}
|
|
|
|
function noActiveResponse(): JsonRecord {
|
|
return {
|
|
ok: true,
|
|
status: 200,
|
|
body: {
|
|
ok: true,
|
|
queue: {
|
|
total: 2,
|
|
queueCount: 2,
|
|
activeQueueIds: [],
|
|
activeTaskIds: [],
|
|
queuedTaskIds: [],
|
|
counts: { succeeded: 2 },
|
|
unreadTerminal: 1,
|
|
executionDiagnostics: {
|
|
state: "healthy",
|
|
effectiveLiveness: "healthy",
|
|
recommendedAction: "none",
|
|
databaseActiveTaskCount: 0,
|
|
databaseActiveTaskIds: [],
|
|
schedulerActiveRunSlotCount: 0,
|
|
schedulerActiveTaskIds: [],
|
|
activeHeartbeatCount: 0,
|
|
activeHeartbeatTaskIds: [],
|
|
heartbeatFreshTaskIds: [],
|
|
heartbeatExpiredTaskIds: [],
|
|
heartbeatMissingTaskIds: [],
|
|
staleRecoveryCandidateTaskIds: [],
|
|
heartbeatRiskTaskIds: [],
|
|
},
|
|
},
|
|
queues: [
|
|
{
|
|
id: "done-a",
|
|
name: "Done A",
|
|
total: 1,
|
|
counts: { succeeded: 1 },
|
|
unreadTerminal: 1,
|
|
activeTaskId: null,
|
|
runnableTaskId: null,
|
|
updatedAt: "2026-05-20T00:05:00.000Z",
|
|
},
|
|
{
|
|
id: "done-b",
|
|
name: "Done B",
|
|
total: 1,
|
|
counts: { succeeded: 1 },
|
|
unreadTerminal: 0,
|
|
activeTaskId: null,
|
|
runnableTaskId: null,
|
|
updatedAt: "2026-05-20T00:04:00.000Z",
|
|
},
|
|
],
|
|
},
|
|
};
|
|
}
|
|
|
|
function activeBelowTargetResponse(): JsonRecord {
|
|
return {
|
|
ok: true,
|
|
status: 200,
|
|
body: {
|
|
ok: true,
|
|
queue: {
|
|
total: 8,
|
|
queueCount: 3,
|
|
activeQueueIds: ["feature-a", "feature-b"],
|
|
activeTaskIds: ["task-active-a", "task-active-b"],
|
|
queuedTaskIds: ["task-queued-a", "task-queued-b", "task-queued-c"],
|
|
counts: { running: 2, queued: 3, retry_wait: 1, succeeded: 2 },
|
|
unreadTerminal: 0,
|
|
executionDiagnostics: {
|
|
state: "healthy",
|
|
effectiveLiveness: "healthy",
|
|
recommendedAction: "none",
|
|
databaseActiveTaskCount: 2,
|
|
databaseActiveTaskIds: ["task-active-a", "task-active-b"],
|
|
schedulerActiveRunSlotCount: 2,
|
|
schedulerActiveTaskIds: ["task-active-a", "task-active-b"],
|
|
activeHeartbeatCount: 2,
|
|
activeHeartbeatTaskIds: ["task-active-a", "task-active-b"],
|
|
heartbeatFreshTaskIds: ["task-active-a", "task-active-b"],
|
|
heartbeatExpiredTaskIds: [],
|
|
heartbeatMissingTaskIds: [],
|
|
staleRecoveryCandidateTaskIds: [],
|
|
heartbeatRiskTaskIds: [],
|
|
lastSchedulerHeartbeatAt: "2026-05-20T01:00:00.000Z",
|
|
lastObservedAgentEventAt: "2026-05-20T01:00:05.000Z",
|
|
},
|
|
},
|
|
queues: [
|
|
{
|
|
id: "feature-a",
|
|
name: "Feature A",
|
|
total: 3,
|
|
counts: { running: 1, queued: 1, succeeded: 1 },
|
|
unreadTerminal: 0,
|
|
activeTaskId: "task-active-a",
|
|
runnableTaskId: null,
|
|
updatedAt: "2026-05-20T01:01:00.000Z",
|
|
},
|
|
{
|
|
id: "feature-b",
|
|
name: "Feature B",
|
|
total: 3,
|
|
counts: { running: 1, retry_wait: 1, succeeded: 1 },
|
|
unreadTerminal: 0,
|
|
activeTaskId: "task-active-b",
|
|
runnableTaskId: "task-queued-b",
|
|
updatedAt: "2026-05-20T01:00:30.000Z",
|
|
},
|
|
{
|
|
id: "feature-c",
|
|
name: "Feature C",
|
|
total: 2,
|
|
counts: { queued: 2 },
|
|
unreadTerminal: 0,
|
|
activeTaskId: null,
|
|
runnableTaskId: "task-queued-c",
|
|
updatedAt: "2026-05-20T01:00:10.000Z",
|
|
},
|
|
],
|
|
tasks: [
|
|
{
|
|
id: "task-active-a",
|
|
queueId: "feature-a",
|
|
status: "running",
|
|
displayPrompt: "Implement feature A polish and contract tests",
|
|
},
|
|
{
|
|
id: "task-active-b",
|
|
queueId: "feature-b",
|
|
status: "running",
|
|
displayPrompt: "Fix feature B queue handling",
|
|
},
|
|
{
|
|
id: "task-queued-a",
|
|
queueId: "feature-a",
|
|
status: "queued",
|
|
displayPrompt: "Queued feature A follow-up",
|
|
},
|
|
],
|
|
},
|
|
};
|
|
}
|
|
|
|
function assertQueuesShape(label: string, result: unknown, expectedView: string): void {
|
|
const data = asRecord(result);
|
|
const queues = asRecord(data.queues);
|
|
assertCondition(queues.view === expectedView, `${label} view mismatch`, queues);
|
|
const items = asArray(queues.items);
|
|
assertCondition(items.length === 3, `${label} must expose queue rows at data.queues.items[]`, queues);
|
|
const first = asRecord(items[0]);
|
|
assertCondition(first.id === "alpha", `${label} first item id mismatch`, first);
|
|
const firstCounts = asRecord(first.counts);
|
|
assertCondition(firstCounts.running === 1, `${label} item counts should be preserved`, first);
|
|
const counts = asRecord(queues.counts);
|
|
assertCondition(counts.running === 1 && counts.queued === 2, `${label} global counts should be preserved`, counts);
|
|
const diagnostics = asRecord(queues.executionDiagnostics);
|
|
assertCondition(diagnostics.state === "split-brain", `${label} executionDiagnostics should be preserved`, diagnostics);
|
|
assertCondition(diagnostics.splitBrainLive === true, `${label} split-brain live should remain explicitly true`, diagnostics);
|
|
assertCondition(diagnostics.effectiveLiveness === "live", `${label} diagnostics should retain derived liveness`, diagnostics);
|
|
assertCondition(diagnostics.recommendedAction === "continue-supervision", `${label} split-brain live should continue supervision`, diagnostics);
|
|
const liveness = asRecord(diagnostics.liveness);
|
|
assertCondition(liveness.effectiveLiveness === "live", `${label} liveness summary should foreground effective live state`, liveness);
|
|
assertCondition(liveness.recommendedAction === "continue-supervision", `${label} liveness summary should foreground recommended action`, liveness);
|
|
assertCondition(liveness.activeHeartbeatCount === 1, `${label} liveness summary should derive active heartbeat count from fresh heartbeat ids`, liveness);
|
|
assertCondition(liveness.schedulerActiveRunSlotCount === 0, `${label} liveness summary should keep master active slot zero visible`, liveness);
|
|
assertCondition(asArray(liveness.heartbeatFreshTaskIds).length === 1, `${label} liveness summary should include bounded fresh heartbeat task ids`, liveness);
|
|
assertCondition(String(liveness.interpretation ?? "").includes("heartbeat is fresh"), `${label} liveness interpretation should explain slot-zero split-brain`, liveness);
|
|
const activity = asRecord(queues.activity);
|
|
assertCondition(activity.effectiveActiveTaskCount === 1, `${label} activity should foreground effective active task count`, activity);
|
|
assertCondition(activity.databaseRunningTaskCount === 1, `${label} activity should distinguish database running tasks`, activity);
|
|
assertCondition(activity.heartbeatFreshActiveTaskCount === 1, `${label} activity should distinguish heartbeat-fresh active runners`, activity);
|
|
assertCondition(activity.schedulerLocalActiveQueueCount === 1, `${label} activity should distinguish scheduler-local active queues`, activity);
|
|
const commanderConcurrency = asRecord(activity.commanderConcurrency);
|
|
assertCondition(commanderConcurrency.activeRunnerCount === 1, `${label} activity should expose commander-facing active runner count`, commanderConcurrency);
|
|
assertCondition(commanderConcurrency.activeRunnerCountField === "activity.effectiveActiveTaskCount", `${label} activity should name the active runner count field`, commanderConcurrency);
|
|
assertCondition(activity.activeQueueIdsScope === "scheduler-local-active-run-slots", `${label} activity should label activeQueueIds scope`, activity);
|
|
assertCondition(Array.isArray(queues.activeTaskIds), `${label} activeTaskIds should be present`, queues);
|
|
assertCondition(Array.isArray(queues.queuedTaskIds), `${label} queuedTaskIds should be present`, queues);
|
|
const commander = asRecord(queues.commander);
|
|
assertCondition(commander.activeRunnerCount === 1, `${label} commander block should be near the front and expose active runner count`, commander);
|
|
assertCondition(commander.target === 15 && commander.slotDeficit === 14, `${label} commander block should expose 15 target slot deficit`, commander);
|
|
assertCondition(commander.queuedCount === 2, `${label} commander block should expose queued count`, commander);
|
|
assertCondition(asArray(asRecord(commander.runningTasks).items).length >= 1, `${label} commander runningTasks should expose active task ids`, commander);
|
|
assertCondition(asArray(asRecord(asRecord(commander.heartbeat).fresh).items).includes("task-running"), `${label} commander heartbeat should foreground fresh ids`, commander);
|
|
}
|
|
|
|
function assertSplitBrainLiveActivity(label: string, result: unknown): void {
|
|
const queues = asRecord(asRecord(result).queues);
|
|
const totals = asRecord(queues.totals);
|
|
assertCondition(totals.activeQueueCount === 0, `${label} scheduler-local active queue count should be zero`, totals);
|
|
assertCondition(totals.schedulerLocalActiveQueueCount === 0, `${label} should preserve zero scheduler-local active queues`, totals);
|
|
assertCondition(totals.runnableQueueCount === 0, `${label} runnable queue count should be zero`, totals);
|
|
assertCondition(totals.databaseRunningTaskCount === 8, `${label} should foreground DB running task count`, totals);
|
|
assertCondition(totals.databaseActiveTaskCount === 8, `${label} should foreground DB active task count`, totals);
|
|
assertCondition(totals.heartbeatFreshActiveTaskCount === 8, `${label} should foreground heartbeat-effective active runners`, totals);
|
|
assertCondition(totals.commanderActiveRunnerCount === 8, `${label} should mirror commander active count in totals`, totals);
|
|
assertCondition(totals.effectiveActiveTaskCount === 8, `${label} should foreground effective active task count`, totals);
|
|
assertCondition(asArray(queues.activeQueueIds).length === 0, `${label} activeQueueIds should remain the scheduler-local list`, queues);
|
|
assertCondition(queues.activeQueueIdsScope === "scheduler-local-active-run-slots", `${label} activeQueueIds should be scoped`, queues);
|
|
assertCondition(String(queues.activeQueueIdsNote ?? "").includes("scheduler-local only"), `${label} activeQueueIds note should explain local-only semantics`, queues);
|
|
const activity = asRecord(queues.activity);
|
|
assertCondition(activity.effectiveActiveTaskCount === 8, `${label} activity should expose effective active count`, activity);
|
|
assertCondition(activity.effectiveActiveSource === "heartbeat-fresh", `${label} activity should choose heartbeat-fresh source`, activity);
|
|
assertCondition(activity.databaseRunningTaskCount === 8, `${label} activity should expose DB running count`, activity);
|
|
assertCondition(activity.heartbeatFreshActiveTaskCount === 8, `${label} activity should expose heartbeat-effective active count`, activity);
|
|
assertCondition(activity.schedulerLocalActiveQueueCount === 0, `${label} activity should expose scheduler-local queue count`, activity);
|
|
assertCondition(activity.schedulerLocalActiveRunSlotCount === 0, `${label} activity should expose scheduler-local slot count`, activity);
|
|
assertCondition(activity.runnableQueueCount === 0, `${label} activity should expose runnable queue count`, activity);
|
|
assertCondition(activity.splitBrainLive === true, `${label} activity should preserve split-brain live`, activity);
|
|
assertCondition(activity.splitBrainDisposition === "live-count-as-active", `${label} activity should count live split-brain as active`, activity);
|
|
const commanderConcurrency = asRecord(queues.commanderConcurrency);
|
|
assertCondition(commanderConcurrency.activeRunnerCount === 8, `${label} should expose commander-facing active runner count`, commanderConcurrency);
|
|
assertCondition(commanderConcurrency.activeRunnerCountField === "activity.effectiveActiveTaskCount", `${label} should name the active runner count field`, commanderConcurrency);
|
|
assertCondition(commanderConcurrency.splitBrainDisposition === "live-count-as-active", `${label} should classify live split-brain capacity`, commanderConcurrency);
|
|
assertCondition(commanderConcurrency.interventionRequired === false, `${label} should not require intervention for fresh split-brain`, commanderConcurrency);
|
|
assertCondition(String(commanderConcurrency.decisionRule ?? "").includes("15 - activeRunnerCount"), `${label} should give 15-concurrency arithmetic`, commanderConcurrency);
|
|
assertCondition(String(activity.activeQueueIdsNote ?? "").includes("zero local queue ids does not mean zero active runners"), `${label} activity note should prevent zero-active misread`, activity);
|
|
assertCondition(String(activity.interpretation ?? "").includes("continue supervision"), `${label} activity interpretation should keep supervision action`, activity);
|
|
const commander = asRecord(queues.commander);
|
|
assertCondition(commander.activeRunnerCount === 8, `${label} commander should foreground heartbeat-effective active count`, commander);
|
|
assertCondition(commander.slotDeficit === 7 && commander.target === 15, `${label} commander should compute below-target slot deficit`, commander);
|
|
assertCondition(asRecord(commander.runningTasks).count === 8, `${label} commander runningTasks should preserve live active count`, commander);
|
|
assertCondition(asRecord(asRecord(commander.heartbeat).fresh).count === 8, `${label} commander heartbeat should preserve fresh heartbeat count`, commander);
|
|
assertCondition(asRecord(asRecord(commander.heartbeat).risk).count === 0, `${label} commander heartbeat risk should be zero for live split-brain`, commander);
|
|
}
|
|
|
|
function assertHeartbeatRiskCommander(label: string, result: unknown): void {
|
|
const queues = asRecord(asRecord(result).queues);
|
|
const commander = asRecord(queues.commander);
|
|
const heartbeat = asRecord(commander.heartbeat);
|
|
const risk = asRecord(heartbeat.risk);
|
|
const stale = asRecord(heartbeat.staleRecoveryCandidates);
|
|
assertCondition(commander.activeRunnerCount === 4, `${label} should count database-active stale tasks as active before recovery`, commander);
|
|
assertCondition(commander.slotDeficit === 11 && commander.target === 15, `${label} should compute slot deficit from target 15`, commander);
|
|
assertCondition(commander.queuedCount === 2, `${label} should expose queued + retry_wait count`, commander);
|
|
assertCondition(commander.attentionRequired === true && commander.interventionRequired === false, `${label} should require attention but not high-risk intervention from one snapshot`, commander);
|
|
assertCondition(heartbeat.effectiveLiveness === "at-risk", `${label} heartbeat liveness should be at-risk`, heartbeat);
|
|
assertCondition(risk.count === 4 && asArray(risk.items).length > 0, `${label} should expose bounded heartbeat risk ids`, risk);
|
|
assertCondition(stale.count === 4 && String(stale.command ?? "").includes("dryRun=1"), `${label} should expose stale recovery candidates and dry-run command`, stale);
|
|
}
|
|
|
|
function assertNoActiveCommander(label: string, result: unknown): void {
|
|
const commander = asRecord(asRecord(asRecord(result).queues).commander);
|
|
assertCondition(commander.activeRunnerCount === 0, `${label} should expose zero active runners`, commander);
|
|
assertCondition(commander.slotDeficit === 15 && commander.slotDeficitState === "below-target", `${label} should expose full 15-slot deficit`, commander);
|
|
assertCondition(commander.queuedCount === 0, `${label} queued count should be zero`, commander);
|
|
assertCondition(asRecord(commander.runningTasks).count === 0, `${label} running task list should be empty`, commander);
|
|
}
|
|
|
|
function assertBelowTargetCommander(label: string, result: unknown): void {
|
|
const commander = asRecord(asRecord(asRecord(result).queues).commander);
|
|
const runningTasks = asRecord(commander.runningTasks);
|
|
const runningItems = asArray(runningTasks.items).map(asRecord);
|
|
const activeQueues = asRecord(commander.activeQueues);
|
|
const runnableQueues = asRecord(commander.runnableQueues);
|
|
assertCondition(commander.activeRunnerCount === 2, `${label} should foreground active runner count`, commander);
|
|
assertCondition(commander.slotDeficit === 13 && commander.target === 15, `${label} should expose deficit below target`, commander);
|
|
assertCondition(commander.queuedCount === 4, `${label} should include queued and retry_wait`, commander);
|
|
assertCondition(runningItems.some((item) => item.id === "task-active-a" && item.name === "Implement feature A polish and contract tests"), `${label} should include active task names when upstream task rows are available`, runningTasks);
|
|
assertCondition(runningItems.some((item) => asArray(item.queueIds).includes("feature-a") && asArray(item.queueNames).includes("Feature A")), `${label} should include active task queues`, runningTasks);
|
|
assertCondition(activeQueues.count === 2 && runnableQueues.count === 3, `${label} should keep active and queued queue rows separate`, commander);
|
|
assertCondition(String(asRecord(commander.commands).running ?? "").includes("--status running,judging"), `${label} should expose running drill-down command`, commander);
|
|
}
|
|
|
|
export function runCodeQueueQueuesShapeContract(): JsonRecord {
|
|
const fetcher = (path: string): JsonRecord => {
|
|
assertCondition(path === "/api/microservices/code-queue/proxy/api/queues", "codex queues should use stable proxy path", { path });
|
|
return fixtureResponse();
|
|
};
|
|
const splitBrainFetcher = (path: string): JsonRecord => {
|
|
assertCondition(path === "/api/microservices/code-queue/proxy/api/queues", "codex queues should use stable proxy path", { path });
|
|
return splitBrainLiveResponse();
|
|
};
|
|
const heartbeatRiskFetcher = (path: string): JsonRecord => {
|
|
assertCondition(path === "/api/microservices/code-queue/proxy/api/queues", "codex queues should use stable proxy path", { path });
|
|
return heartbeatRiskResponse();
|
|
};
|
|
const noActiveFetcher = (path: string): JsonRecord => {
|
|
assertCondition(path === "/api/microservices/code-queue/proxy/api/queues", "codex queues should use stable proxy path", { path });
|
|
return noActiveResponse();
|
|
};
|
|
const activeBelowTargetFetcher = (path: string): JsonRecord => {
|
|
assertCondition(path === "/api/microservices/code-queue/proxy/api/queues", "codex queues should use stable proxy path", { path });
|
|
return activeBelowTargetResponse();
|
|
};
|
|
|
|
const summary = codexQueuesQueryForTest([], fetcher);
|
|
assertQueuesShape("summary", summary, "summary");
|
|
const summaryQueues = asRecord(asRecord(summary).queues);
|
|
assertCondition(summaryQueues.deprecatedFullArray === undefined, "summary should not expose deprecated full array compatibility field", summaryQueues);
|
|
assertCondition(summaryQueues.summaryMode === "commander-first", "summary should default to commander-first mode", summaryQueues);
|
|
|
|
const explicitCommander = codexQueuesQueryForTest(["--commander"], fetcher);
|
|
const explicitCommanderQueues = asRecord(asRecord(explicitCommander).queues);
|
|
assertCondition(explicitCommanderQueues.summaryMode === "commander-first", "--commander should keep commander-first mode", explicitCommanderQueues);
|
|
|
|
const full = codexQueuesQueryForTest(["--full"], fetcher);
|
|
assertQueuesShape("full", full, "full");
|
|
const fullQueues = asRecord(asRecord(full).queues);
|
|
assertCondition(!Array.isArray(fullQueues), "full queues payload must be an object, not the deprecated array shape", fullQueues);
|
|
assertCondition(fullQueues.bounded === true, "full queues output should now be paged by default", fullQueues);
|
|
assertCondition(fullQueues.deprecatedFullArray === undefined, "full should not expose deprecated unbounded array by default", fullQueues);
|
|
const compatibility = asRecord(fullQueues.compatibility);
|
|
assertCondition(compatibility.stablePath === "data.queues.items[]", "compatibility metadata should document stable path", compatibility);
|
|
assertCondition(compatibility.deprecated === true, "compatibility metadata should mark old array path deprecated", compatibility);
|
|
assertCondition(compatibility.deprecatedFullArrayOmitted === true, "compatibility metadata should explain deprecated array omission", compatibility);
|
|
|
|
const limitedFull = codexQueuesQueryForTest(["--full", "--limit", "2"], fetcher);
|
|
const limitedFullQueues = asRecord(asRecord(limitedFull).queues);
|
|
assertCondition(limitedFullQueues.bounded === true, "full with explicit --limit should be bounded", limitedFullQueues);
|
|
assertCondition(asArray(limitedFullQueues.items).length === 2, "full with explicit --limit should limit data.queues.items[]", limitedFullQueues);
|
|
assertCondition(limitedFullQueues.hasMore === true, "limited full should expose next page", limitedFullQueues);
|
|
const limitedCommands = asRecord(limitedFullQueues.commands);
|
|
assertCondition(String(limitedCommands.next ?? "").includes("--offset 2"), "limited full should expose offset pagination command", limitedCommands);
|
|
|
|
const offsetFull = codexQueuesQueryForTest(["--full", "--limit", "2", "--offset", "2"], fetcher);
|
|
const offsetFullQueues = asRecord(asRecord(offsetFull).queues);
|
|
assertCondition(offsetFullQueues.offset === 2, "offset full should preserve offset", offsetFullQueues);
|
|
assertCondition(offsetFullQueues.hasPrevious === true, "offset full should expose previous page", offsetFullQueues);
|
|
assertCondition(asRecord(asArray(offsetFullQueues.items)[0]).id === "gamma", "offset full should return second page rows", offsetFullQueues);
|
|
|
|
const splitSummary = codexQueuesQueryForTest([], splitBrainFetcher);
|
|
assertSplitBrainLiveActivity("split-brain summary", splitSummary);
|
|
const splitFull = codexQueuesQueryForTest(["--full"], splitBrainFetcher);
|
|
assertSplitBrainLiveActivity("split-brain full", splitFull);
|
|
const heartbeatRisk = codexQueuesQueryForTest([], heartbeatRiskFetcher);
|
|
assertHeartbeatRiskCommander("heartbeat-risk summary", heartbeatRisk);
|
|
const noActive = codexQueuesQueryForTest([], noActiveFetcher);
|
|
assertNoActiveCommander("no-active summary", noActive);
|
|
const belowTarget = codexQueuesQueryForTest([], activeBelowTargetFetcher);
|
|
assertBelowTargetCommander("active-below-target summary", belowTarget);
|
|
|
|
return {
|
|
ok: true,
|
|
checks: [
|
|
"summary data.queues.items[] shape",
|
|
"summary queue metadata",
|
|
"full data.queues.items[] shape",
|
|
"full queue metadata",
|
|
"deprecated full array omitted from default output",
|
|
"full explicit limit remains bounded and paged",
|
|
"offset pagination",
|
|
"split-brain live activity counts distinguish scheduler-local queues, DB running tasks, and heartbeat-fresh runners",
|
|
"commander concurrency block names the active runner count and 15-concurrency rule",
|
|
"queues commander-first summary foregrounds active runner count, target 15 deficit, running task ids/names/queues, heartbeat risk, stale recovery candidates, and queued count",
|
|
"queues commander fixtures cover split-brain live, heartbeat risk, no active, and active below target",
|
|
],
|
|
};
|
|
}
|
|
|
|
if (import.meta.main) {
|
|
process.stdout.write(`${JSON.stringify(runCodeQueueQueuesShapeContract(), null, 2)}\n`);
|
|
}
|