Codex
189 lines
12 KiB
TypeScript
189 lines
12 KiB
TypeScript
import { compactSubmitSuccessResponseForTest } from "./src/code-queue";
|
|
|
|
type JsonRecord = Record<string, unknown>;
|
|
|
|
function assertCondition(condition: unknown, message: string, detail: unknown = {}): 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 assertNoItemsArrayWhenUnavailable(value: JsonRecord, label: string): void {
|
|
assertCondition(value.idsUnavailable === true, `${label} should mark non-enumerated ids unavailable`, value);
|
|
assertCondition(!Object.prototype.hasOwnProperty.call(value, "items"), `${label} must not emit items=[] when count is nonzero but ids are unavailable`, value);
|
|
assertCondition(value.itemsOmitted === true, `${label} should explicitly mark items omitted`, value);
|
|
assertCondition(String(value.itemsMeaning || "") === "not-enumerated-in-default-submit-output", `${label} should explain empty-list semantics`, value);
|
|
assertCondition(String(value.rawCommand || "").includes("microservice proxy code-queue /api/tasks/overview"), `${label} should provide raw drill-down`, value);
|
|
}
|
|
|
|
function task(id: string, status: string, queueId = "commander-efficiency"): JsonRecord {
|
|
return {
|
|
id,
|
|
queueId,
|
|
status,
|
|
prompt: `Focused submit summary contract for ${id}`,
|
|
displayPrompt: `Focused submit summary contract for ${id}`,
|
|
providerId: "D601",
|
|
model: "gpt-5.5",
|
|
currentAttempt: status === "queued" ? 0 : 1,
|
|
maxAttempts: 99,
|
|
createdAt: "2026-05-23T00:00:00.000Z",
|
|
updatedAt: "2026-05-23T00:00:00.000Z",
|
|
};
|
|
}
|
|
|
|
function manyIds(prefix: string, count: number): string[] {
|
|
return Array.from({ length: count }, (_, index) => `${prefix}-${String(index + 1).padStart(2, "0")}`);
|
|
}
|
|
|
|
export function runCodeQueueSubmitSummaryContract(): JsonRecord {
|
|
const submittedId = "codex_submitted_queued";
|
|
const activeIds = manyIds("codex_running", 18);
|
|
const response = compactSubmitSuccessResponseForTest({
|
|
tasks: [task(submittedId, "queued")],
|
|
queue: {
|
|
counts: { running: 18, queued: 5, succeeded: 9 },
|
|
activeTaskIds: [],
|
|
queuedTaskIds: { items: [], count: 5, returned: 0, truncated: true },
|
|
databaseActiveTaskIds: activeIds,
|
|
databaseActiveTaskCount: activeIds.length,
|
|
executionDiagnostics: {
|
|
state: "healthy",
|
|
databaseActiveTaskIds: activeIds,
|
|
databaseActiveTaskCount: activeIds.length,
|
|
schedulerActiveRunSlotCount: 0,
|
|
schedulerActiveTaskIds: [],
|
|
heartbeatFreshTaskIds: activeIds,
|
|
},
|
|
},
|
|
}, { ok: true, status: 200 }, { mode: "local-atomic-directory-submit-serialization", acquiredAfterMs: 1, heldMs: 2, throttleMs: 2000 });
|
|
|
|
const data = asRecord(response);
|
|
const submitted = asRecord(data.submitted);
|
|
const submittedTasks = asArray(submitted.tasks);
|
|
const submittedTask = asRecord(submittedTasks[0]);
|
|
const taskStates = asArray(submitted.taskStates);
|
|
const submittedState = asRecord(taskStates[0]);
|
|
const queue = asRecord(data.queue);
|
|
const queuedTaskIds = asRecord(queue.queuedTaskIds);
|
|
const activeTaskIds = asRecord(queue.activeTaskIds);
|
|
const databaseActiveTaskIds = asRecord(queue.databaseActiveTaskIds);
|
|
const submittedTaskIds = asRecord(queue.submittedTaskIds);
|
|
const countContext = asRecord(queue.countContext);
|
|
const listPreviewPolicy = asRecord(queue.listPreviewPolicy);
|
|
const omittedCounts = asRecord(listPreviewPolicy.omittedCounts);
|
|
const stateDisclosure = asRecord(queue.stateDisclosure);
|
|
const activity = asRecord(queue.activity);
|
|
const responseJson = JSON.stringify(response);
|
|
|
|
assertCondition(submittedTask.id === submittedId && submittedTask.status === "queued", "submit response should keep the newly queued task", submittedTask);
|
|
assertCondition(submittedState.id === submittedId && submittedState.status === "queued" && submittedState.state === "queued", "submitted task state should be explicit and authoritative", submittedState);
|
|
assertCondition(String(submitted.stateSource || "").includes("response.tasks"), "submitted state source should point at response.tasks", submitted);
|
|
assertCondition(asArray(submittedTaskIds.items).includes(submittedId), "submittedTaskIds should expose the just-submitted id", submittedTaskIds);
|
|
assertCondition(asArray(queuedTaskIds.items).includes(submittedId), "queuedTaskIds preview should force-include the just-submitted queued task", queuedTaskIds);
|
|
assertCondition(queuedTaskIds.count === 5 && queuedTaskIds.returned === 1 && queuedTaskIds.omitted === 4, "queuedTaskIds should preserve aggregate queued count without dumping all ids", queuedTaskIds);
|
|
assertCondition(String(queuedTaskIds.source || "").includes("submittedTaskIds"), "queuedTaskIds source should explain submitted-task fallback", queuedTaskIds);
|
|
assertCondition(String(queuedTaskIds.note || "").includes("count remains authoritative"), "queuedTaskIds should explain aggregate-count fallback", queuedTaskIds);
|
|
|
|
assertCondition(asArray(activeTaskIds.items).length === 15, "activeTaskIds preview should stay bounded", activeTaskIds);
|
|
assertCondition(activeTaskIds.count === 18 && activeTaskIds.omitted === 3 && activeTaskIds.truncated === true, "activeTaskIds should preserve active count and truncation", activeTaskIds);
|
|
assertCondition(String(activeTaskIds.source || "").includes("databaseActiveTaskIds"), "activeTaskIds should fall back to database active ids when upstream activeTaskIds is empty", activeTaskIds);
|
|
assertCondition(databaseActiveTaskIds.count === 18 && databaseActiveTaskIds.returned === 15, "databaseActiveTaskIds preview should preserve count context", databaseActiveTaskIds);
|
|
assertCondition(countContext.running === 18 && countContext.active === 18 && countContext.databaseActive === 18, "countContext should expose accurate active counts", countContext);
|
|
assertCondition(activity.effectiveActiveTaskCount === 18, "submit queue activity should expose commander effective active count", activity);
|
|
|
|
assertCondition(listPreviewPolicy.bounded === true && listPreviewPolicy.countsAreAuthoritative === true, "list preview policy should document bounded low-noise output", listPreviewPolicy);
|
|
assertCondition(listPreviewPolicy.truncated === true && omittedCounts.activeTaskIds === 3 && omittedCounts.queuedTaskIds === 4, "list preview policy should disclose omitted counts", listPreviewPolicy);
|
|
assertCondition(String(listPreviewPolicy.emptyItemsSemantics || "").includes("idsUnavailable=true"), "list preview policy should document nonzero-count unavailable ids", listPreviewPolicy);
|
|
assertCondition(String(stateDisclosure.submittedStatusSource || "").includes("response.tasks"), "stateDisclosure should name submitted status source", stateDisclosure);
|
|
assertCondition(String(listPreviewPolicy.note || "").includes("Low-noise mutation output omits"), "list preview policy should include a clear truncation note", listPreviewPolicy);
|
|
assertCondition(submitted.promptOmitted === true && !responseJson.includes("Focused submit summary contract"), "submit confirmation should not leak prompt text", response);
|
|
assertCondition(responseJson.length < 12_000, "submit confirmation should remain low-noise", { chars: responseJson.length });
|
|
|
|
const activeIdsOmitted = compactSubmitSuccessResponseForTest({
|
|
tasks: [task("codex_submitted_queued_while_running", "queued", "live-fast-lane")],
|
|
queue: {
|
|
counts: { running: 9, queued: 1 },
|
|
activeTaskIds: { items: [], count: 9, returned: 0, truncated: true },
|
|
queuedTaskIds: { items: [], count: 1, returned: 0, truncated: true },
|
|
databaseActiveTaskCount: 9,
|
|
executionDiagnostics: {
|
|
state: "split-brain",
|
|
splitBrain: true,
|
|
splitBrainLive: true,
|
|
effectiveLiveness: "live",
|
|
recommendedAction: "continue-supervision",
|
|
databaseActiveTaskCount: 9,
|
|
schedulerActiveRunSlotCount: 0,
|
|
schedulerActiveTaskIds: [],
|
|
activeHeartbeatCount: 9,
|
|
heartbeatFreshTaskIds: [],
|
|
},
|
|
},
|
|
}, { ok: true, status: 200 }, { mode: "local-atomic-directory-submit-serialization", acquiredAfterMs: 1, heldMs: 2, throttleMs: 2000 });
|
|
const omittedQueue = asRecord(asRecord(activeIdsOmitted).queue);
|
|
const omittedActive = asRecord(omittedQueue.activeTaskIds);
|
|
const forcedQueued = asRecord(omittedQueue.queuedTaskIds);
|
|
const omittedPolicy = asRecord(omittedQueue.listPreviewPolicy);
|
|
const unavailable = asRecord(omittedPolicy.unavailableIdLists);
|
|
assertCondition(omittedActive.count === 9 && omittedActive.returned === 0, "running-count nonzero should be preserved even with omitted active ids", omittedActive);
|
|
assertNoItemsArrayWhenUnavailable(omittedActive, "activeTaskIds");
|
|
assertCondition(asArray(forcedQueued.items).includes("codex_submitted_queued_while_running"), "new queued submitted task should be force-included even if upstream queued ids were omitted", forcedQueued);
|
|
assertCondition(unavailable.activeTaskIds === true && unavailable.queuedTaskIds === false, "listPreviewPolicy should summarize unavailable active id list", unavailable);
|
|
|
|
const liveSplitBrain = asRecord(omittedQueue.executionDiagnostics);
|
|
const liveStateDisclosure = asRecord(omittedQueue.stateDisclosure);
|
|
const liveActivity = asRecord(omittedQueue.activity);
|
|
assertCondition(liveSplitBrain.splitBrainLive === true && liveSplitBrain.effectiveLiveness === "live", "split-brain-live heartbeat context should stay explicit", liveSplitBrain);
|
|
assertCondition(liveActivity.splitBrainDisposition === "live-count-as-active", "split-brain-live should be counted as active in activity", liveActivity);
|
|
assertCondition(String(liveStateDisclosure.splitBrainDisposition || "").includes("continue supervision"), "stateDisclosure should explain split-brain-live disposition", liveStateDisclosure);
|
|
assertCondition(String(liveStateDisclosure.idsUnavailableMeaning || "").includes("not that there are no tasks"), "stateDisclosure should prevent empty-list misread", liveStateDisclosure);
|
|
|
|
const queuedIdsOmitted = compactSubmitSuccessResponseForTest({
|
|
tasks: [task("codex_submitted_already_running", "running", "live-fast-lane")],
|
|
queue: {
|
|
counts: { running: 1, queued: 3 },
|
|
activeTaskIds: { items: [], count: 1, returned: 0, truncated: true },
|
|
queuedTaskIds: { items: [], count: 3, returned: 0, truncated: true },
|
|
executionDiagnostics: {
|
|
state: "healthy",
|
|
databaseActiveTaskCount: 1,
|
|
databaseActiveTaskIds: ["codex_submitted_already_running"],
|
|
activeHeartbeatCount: 1,
|
|
heartbeatFreshTaskIds: ["codex_submitted_already_running"],
|
|
},
|
|
},
|
|
}, { ok: true, status: 200 }, { mode: "local-atomic-directory-submit-serialization", acquiredAfterMs: 1, heldMs: 2, throttleMs: 2000 });
|
|
const queuedOmittedQueue = asRecord(asRecord(queuedIdsOmitted).queue);
|
|
const queuedOmitted = asRecord(queuedOmittedQueue.queuedTaskIds);
|
|
const queuedOmittedPolicy = asRecord(queuedOmittedQueue.listPreviewPolicy);
|
|
const queuedUnavailable = asRecord(queuedOmittedPolicy.unavailableIdLists);
|
|
assertCondition(queuedOmitted.count === 3 && queuedOmitted.returned === 0, "queued-count nonzero should be preserved even with omitted queued ids", queuedOmitted);
|
|
assertNoItemsArrayWhenUnavailable(queuedOmitted, "queuedTaskIds");
|
|
assertCondition(queuedUnavailable.queuedTaskIds === true, "listPreviewPolicy should summarize unavailable queued id list", queuedUnavailable);
|
|
|
|
return {
|
|
ok: true,
|
|
checks: [
|
|
"newly queued submitted task is included in queuedTaskIds preview",
|
|
"running count context falls back to database active ids",
|
|
"nonzero count with omitted id lists uses idsUnavailable instead of items=[]",
|
|
"split-brain-live submit summary says continue supervision and count as active",
|
|
"bounded id previews disclose omitted counts",
|
|
"submit confirmation omits prompt text and remains low-noise",
|
|
],
|
|
};
|
|
}
|
|
|
|
if (import.meta.main) {
|
|
process.stdout.write(`${JSON.stringify(runCodeQueueSubmitSummaryContract(), null, 2)}\n`);
|
|
}
|