Codex
387 lines
25 KiB
TypeScript
387 lines
25 KiB
TypeScript
import { spawnSync } from "node:child_process";
|
|
import { codexTasksQueryForTest } from "./src/code-queue";
|
|
|
|
type JsonRecord = Record<string, unknown>;
|
|
type RequestRecord = { path: string; method: string };
|
|
|
|
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 longText(marker: string, repeat: number): string {
|
|
return Array.from({ length: repeat }, (_, index) => `${marker}-${index} status evidence command output final response prompt body should stay capped`).join("\n");
|
|
}
|
|
|
|
function task(id: string, status: string, updatedAt: string, prompt: string, readAt: string | null = null, finalText = ""): JsonRecord {
|
|
return {
|
|
id,
|
|
queueId: "default",
|
|
status,
|
|
currentAttempt: status === "queued" || status === "retry_wait" ? 0 : 1,
|
|
updatedAt,
|
|
finishedAt: status === "succeeded" || status === "failed" || status === "canceled" ? updatedAt : null,
|
|
readAt,
|
|
prompt: `${prompt}\n${longText(`raw-prompt-${id}`, 80)}`,
|
|
basePrompt: `${prompt}\n${longText(`base-prompt-${id}`, 60)}`,
|
|
displayPrompt: `${prompt}\n${longText(`display-prompt-${id}`, 70)}`,
|
|
lastAssistantMessage: finalText.length === 0 ? null : {
|
|
at: updatedAt,
|
|
seq: 42,
|
|
source: "finalResponse",
|
|
text: `${finalText}\n${longText(`assistant-${id}`, 100)}`,
|
|
},
|
|
};
|
|
}
|
|
|
|
function summaryForTask(taskId: string): JsonRecord {
|
|
const finalText = taskId === "task-running-risk"
|
|
? "Blocked by provider auth token timeout and cannot proceed without commander authorization."
|
|
: taskId === "task-failed-unread"
|
|
? "CI failed and final response reports missing e2e evidence."
|
|
: taskId === "task-running-watch"
|
|
? "Implementation finished but task is still awaiting judge."
|
|
: "Completed with compact evidence.";
|
|
return {
|
|
ok: true,
|
|
status: 200,
|
|
body: {
|
|
ok: true,
|
|
summary: {
|
|
id: taskId,
|
|
queueId: "default",
|
|
status: taskId.includes("running") ? "running" : taskId.includes("failed") ? "failed" : "succeeded",
|
|
currentAttempt: 1,
|
|
maxAttempts: 99,
|
|
prompt: longText(`summary-prompt-${taskId}`, 90),
|
|
basePrompt: longText(`summary-base-${taskId}`, 70),
|
|
lastAssistantMessage: {
|
|
at: "2026-05-22T00:59:00.000Z",
|
|
seq: 120,
|
|
source: "finalResponse",
|
|
text: `${finalText}\n${longText(`summary-final-${taskId}`, 120)}`,
|
|
},
|
|
},
|
|
},
|
|
};
|
|
}
|
|
|
|
function noisyCommanderFixture(path: string, requests: RequestRecord[] = []): JsonRecord {
|
|
requests.push({ path, method: "GET" });
|
|
if (path.includes("/summary")) {
|
|
const taskId = decodeURIComponent(path.split("/api/tasks/")[1]?.split("/")[0] ?? "unknown");
|
|
return summaryForTask(taskId);
|
|
}
|
|
assertCondition(path.startsWith("/api/microservices/code-queue/proxy/api/tasks/overview"), "unexpected path", { path });
|
|
return {
|
|
ok: true,
|
|
status: 200,
|
|
body: {
|
|
ok: true,
|
|
queue: {
|
|
counts: {
|
|
running: 12,
|
|
judging: 2,
|
|
queued: 18,
|
|
retry_wait: 4,
|
|
succeeded: 28,
|
|
failed: 3,
|
|
canceled: 1,
|
|
},
|
|
unreadTerminal: 8,
|
|
maxActiveQueues: 15,
|
|
executionDiagnostics: {
|
|
now: "2026-05-22T01:00:00.000Z",
|
|
state: "stale-active",
|
|
effectiveLiveness: "at-risk",
|
|
recommendedAction: "investigate-heartbeat-risk",
|
|
databaseActiveTaskCount: 14,
|
|
databaseActiveTaskIds: ["task-running-risk", "task-running-watch"],
|
|
activeHeartbeatCount: 13,
|
|
heartbeatFreshTaskIds: ["task-running-watch"],
|
|
heartbeatRiskTaskIds: ["task-running-risk"],
|
|
heartbeatExpiredTaskIds: ["task-running-risk"],
|
|
heartbeatMissingTaskIds: [],
|
|
staleRecoveryCandidateTaskIds: ["task-running-risk"],
|
|
traceGapTaskIds: ["task-running-risk", "task-running-watch"],
|
|
reasons: [longText("diagnostic-reason", 30), longText("diagnostic-reason-two", 30)],
|
|
},
|
|
},
|
|
pagination: {
|
|
limit: 200,
|
|
returned: 12,
|
|
total: 68,
|
|
hasMore: true,
|
|
nextBeforeId: "task-oldest-page",
|
|
includeActive: true,
|
|
},
|
|
tasks: [
|
|
task("task-running-risk", "running", "2026-05-22T00:00:00.000Z", "HWLAB#7 backend-core provider token blocker for M3 hardware workbench", null, "Blocked by provider auth token timeout."),
|
|
task("task-running-watch", "judging", "2026-05-22T00:52:00.000Z", "pikasTech/HWLAB#164 user-facing patch-panel verification", null, "Final response ready while judge is pending."),
|
|
task("task-failed-unread", "failed", "2026-05-22T00:50:00.000Z", "UniDesk#20 CI e2e evidence gate for commander view", null, "CI failed and needs read closeout."),
|
|
task("task-succeeded-unread", "succeeded", "2026-05-22T00:49:00.000Z", "pikasTech/HWLAB#317 deployment artifact digest publish evidence", null, "Artifact published."),
|
|
task("task-canceled-unread", "canceled", "2026-05-22T00:48:00.000Z", "UniDesk#118 diagnostics gate report stale commander loop", null, "Canceled after blocker."),
|
|
task("task-queued-priority", "queued", "2026-05-22T00:47:00.000Z", "HWLAB#99 business user-facing dashboard fix waiting for runner"),
|
|
task("task-retry-priority", "retry_wait", "2026-05-22T00:46:00.000Z", "HWLAB#116 infrastructure blocker retry_wait due to github transient"),
|
|
task("task-recent-read-docs", "succeeded", "2026-05-22T00:45:00.000Z", "docs governance reference update", "2026-05-22T00:45:01.000Z"),
|
|
task("task-recent-read-business", "succeeded", "2026-05-22T00:44:00.000Z", "business user-facing workbench UI fix", "2026-05-22T00:44:01.000Z"),
|
|
task("task-recent-read-evidence", "succeeded", "2026-05-22T00:43:00.000Z", "ci e2e evidence smoke report", "2026-05-22T00:43:01.000Z"),
|
|
task("task-recent-read-artifact", "succeeded", "2026-05-22T00:42:00.000Z", "deployment artifact registry digest", "2026-05-22T00:42:01.000Z"),
|
|
task("task-recent-read-diagnostic", "succeeded", "2026-05-22T00:41:00.000Z", "diagnostics gate report", "2026-05-22T00:41:01.000Z"),
|
|
],
|
|
},
|
|
};
|
|
}
|
|
|
|
function readyCommanderFixture(path: string): JsonRecord {
|
|
if (path.includes("/summary")) {
|
|
const taskId = decodeURIComponent(path.split("/api/tasks/")[1]?.split("/")[0] ?? "unknown");
|
|
return {
|
|
ok: true,
|
|
status: 200,
|
|
body: {
|
|
ok: true,
|
|
summary: {
|
|
id: taskId,
|
|
queueId: "default",
|
|
status: "succeeded",
|
|
currentAttempt: 1,
|
|
maxAttempts: 1,
|
|
prompt: "D601 Code Queue GPT-5.5 runner completed normal workflow with ready platform status.",
|
|
lastAssistantMessage: {
|
|
at: "2026-05-22T00:59:00.000Z",
|
|
seq: 12,
|
|
source: "finalResponse",
|
|
text: "Completed routine workflow with ready platform status and no follow-up incident.",
|
|
},
|
|
},
|
|
},
|
|
};
|
|
}
|
|
assertCondition(path.startsWith("/api/microservices/code-queue/proxy/api/tasks/overview"), "unexpected ready fixture path", { path });
|
|
const tasks = Array.from({ length: 12 }, (_, index) => task(
|
|
`task-ready-${index + 1}`,
|
|
"succeeded",
|
|
`2026-05-22T00:${String(40 - index).padStart(2, "0")}:00.000Z`,
|
|
index === 2
|
|
? "D601 Code Queue GPT-5.5 runner commander audit: infrastructure.status=ready riskCounts.infrastructureBlocker=0; do not classify all history as infrastructure-blocker"
|
|
: index % 3 === 0
|
|
? "D601 Code Queue GPT-5.5 runner workflow fix for UniDesk#20 commander CLI behavior"
|
|
: index % 3 === 1
|
|
? "D601 Code Queue GPT-5.5 runner user-facing HWLAB workbench implementation"
|
|
: "D601 Code Queue GPT-5.5 runner routine unknown historical task",
|
|
"2026-05-22T01:00:00.000Z",
|
|
"Routine final response.",
|
|
));
|
|
return {
|
|
ok: true,
|
|
status: 200,
|
|
body: {
|
|
ok: true,
|
|
queue: {
|
|
counts: {
|
|
running: 0,
|
|
judging: 0,
|
|
queued: 0,
|
|
retry_wait: 0,
|
|
succeeded: tasks.length,
|
|
failed: 0,
|
|
canceled: 0,
|
|
},
|
|
unreadTerminal: 0,
|
|
maxActiveQueues: 15,
|
|
storage: {
|
|
postgresReady: true,
|
|
health: {
|
|
status: "ready",
|
|
degraded: false,
|
|
signals: [],
|
|
},
|
|
},
|
|
executionDiagnostics: {
|
|
now: "2026-05-22T01:00:00.000Z",
|
|
state: "ready",
|
|
effectiveLiveness: "idle",
|
|
recommendedAction: "continue-supervision",
|
|
databaseActiveTaskCount: 0,
|
|
schedulerActiveRunSlotCount: 0,
|
|
activeHeartbeatCount: 0,
|
|
heartbeatRiskTaskIds: [],
|
|
staleRecoveryCandidateTaskIds: [],
|
|
traceGapTaskIds: [],
|
|
},
|
|
},
|
|
pagination: {
|
|
limit: 200,
|
|
returned: tasks.length,
|
|
total: tasks.length,
|
|
hasMore: false,
|
|
nextBeforeId: null,
|
|
includeActive: true,
|
|
},
|
|
tasks,
|
|
},
|
|
};
|
|
}
|
|
|
|
export function runCodeQueueCommanderViewContract(): JsonRecord {
|
|
const commanderRequests: RequestRecord[] = [];
|
|
const commanderLimit8Requests: RequestRecord[] = [];
|
|
const fetchCommander = (path: string): JsonRecord => noisyCommanderFixture(path, commanderRequests);
|
|
const fetchCommanderLimit8 = (path: string): JsonRecord => noisyCommanderFixture(path, commanderLimit8Requests);
|
|
const fetchNoisy = (path: string): JsonRecord => noisyCommanderFixture(path);
|
|
const commander = codexTasksQueryForTest(["--view", "commander", "--limit", "260"], fetchCommander);
|
|
const commanderTerminalAliases = codexTasksQueryForTest(["--view", "commander", "--status", "completed,cancelled", "--limit", "8"], fetchNoisy);
|
|
const supervisor = codexTasksQueryForTest(["--view", "supervisor", "--limit", "260"], fetchNoisy);
|
|
const full = codexTasksQueryForTest(["--view", "full", "--limit", "260"], fetchNoisy);
|
|
const commanderLimit8 = codexTasksQueryForTest(["--view", "commander", "--limit", "8"], fetchCommanderLimit8);
|
|
const readyCommander = codexTasksQueryForTest(["--view", "commander", "--limit", "120"], readyCommanderFixture);
|
|
const fullLimit8 = codexTasksQueryForTest(["--view", "full", "--limit", "8"], fetchNoisy);
|
|
const unreadLimit8 = codexTasksQueryForTest(["--unread", "--limit", "8"], fetchNoisy);
|
|
const commanderBody = JSON.stringify(commander);
|
|
const commanderTerminalAliasBody = JSON.stringify(commanderTerminalAliases);
|
|
const commanderLimit8Body = JSON.stringify(commanderLimit8);
|
|
const fullLimit8Body = JSON.stringify(fullLimit8);
|
|
const unreadLimit8Body = JSON.stringify(unreadLimit8);
|
|
const fullBody = JSON.stringify(full);
|
|
const commanderView = asRecord(asRecord(commander).commander);
|
|
const commanderTerminalAliasView = asRecord(asRecord(commanderTerminalAliases).commander);
|
|
const commanderLimit8View = asRecord(asRecord(commanderLimit8).commander);
|
|
const readyCommanderView = asRecord(asRecord(readyCommander).commander);
|
|
const supervisorView = asRecord(asRecord(supervisor).supervisor);
|
|
const filters = asRecord(commanderView.filters);
|
|
const activeRunners = asRecord(commanderView.activeRunners);
|
|
const backlog = asRecord(commanderView.queueBacklog);
|
|
const terminalUnread = asRecord(commanderView.terminalUnread);
|
|
const riskCounts = asRecord(commanderView.riskCounts);
|
|
const attentionCounts = asRecord(riskCounts.attention);
|
|
const highPriorityIssues = asRecord(commanderView.highPriorityIssues);
|
|
const classification = asRecord(commanderView.classification);
|
|
const byCategory = asRecord(classification.byCategory);
|
|
const readyRiskCounts = asRecord(readyCommanderView.riskCounts);
|
|
const readyClassification = asRecord(readyCommanderView.classification);
|
|
const readyByCategory = asRecord(readyClassification.byCategory);
|
|
const readyInfrastructure = asRecord(readyCommanderView.infrastructure);
|
|
const commands = asRecord(commanderView.commands);
|
|
const attention = asRecord(commanderView.attention);
|
|
const attentionItems = asArray(attention.items).map(asRecord);
|
|
const sections = asRecord(commanderView.sections);
|
|
const terminalUnreadSection = asRecord(sections.terminalUnread);
|
|
const recentCompletedSection = asRecord(sections.recentCompleted);
|
|
const recentIds = asArray(recentCompletedSection.items).map((item) => String(asRecord(item).id ?? ""));
|
|
const terminalIds = asArray(terminalUnreadSection.items).map((item) => String(asRecord(item).id ?? ""));
|
|
const terminalAliasFilters = asRecord(commanderTerminalAliasView.filters);
|
|
const terminalAliasSections = asRecord(commanderTerminalAliasView.sections);
|
|
const terminalAliasRecentCompleted = asRecord(terminalAliasSections.recentCompleted);
|
|
const terminalAliasCommands = asRecord(commanderTerminalAliasView.commands);
|
|
const activeItems = asArray(activeRunners.items).map(asRecord);
|
|
const runningRisk = attentionItems.find((item) => item.id === "task-running-risk") ?? {};
|
|
const limit8ActiveRunners = asRecord(commanderLimit8View.activeRunners);
|
|
const limit8Sections = asRecord(commanderLimit8View.sections);
|
|
const limit8TerminalUnread = asRecord(limit8Sections.terminalUnread);
|
|
const limit8Commands = asRecord(commanderLimit8View.commands);
|
|
const limit8Attention = asRecord(commanderLimit8View.attention);
|
|
const limit8AttentionItems = asArray(limit8Attention.items).map(asRecord);
|
|
|
|
assertCondition(commanderBody.length < 30_000, "commander output should stay under the noisy fixture budget", { chars: commanderBody.length });
|
|
assertCondition(commanderBody.length < fullBody.length * 0.65, "commander output should stay materially smaller than full output", { commanderChars: commanderBody.length, fullChars: fullBody.length });
|
|
assertCondition(filters.requestedLimit === 260 && filters.effectiveLimit === 100 && filters.limitCapped === true, "commander view should disclose requested/effective limit cap", filters);
|
|
assertCondition(activeRunners.count === 14 && activeRunners.exact === true && activeRunners.source === "database-active", "commander view should expose exact active runner count and source/disposition", activeRunners);
|
|
assertCondition(backlog.queued === 18 && backlog.retryWait === 4 && backlog.total === 22 && backlog.exact === true, "commander view should expose queued/retry_wait exact counts", backlog);
|
|
assertCondition(terminalUnread.total === 8 && terminalUnread.rowsReturned === 3 && terminalUnread.rowsOmitted === 5 && terminalUnread.exact === true, "commander view should expose terminal unread count plus omitted rows", terminalUnread);
|
|
assertCondition(activeItems.some((item) => item.id === "task-running-risk") && activeItems.some((item) => item.id === "task-running-watch"), "commander activeRunners should include compact active task items", activeRunners);
|
|
assertCondition(attentionCounts.total === 4 && attentionCounts.returned === 4 && attentionCounts.omitted === 0, "commander attention counts should preserve non-terminal attention totals", attentionCounts);
|
|
assertCondition(highPriorityIssues.present === true && highPriorityIssues.matchedCount === 7, "commander should surface tracked high-priority issues", highPriorityIssues);
|
|
assertCondition(Number(byCategory["user-facing"] ?? 0) >= 1
|
|
&& Number(byCategory["cd-artifact"] ?? 0) >= 1
|
|
&& Number(byCategory["noise-report"] ?? 0) >= 1
|
|
&& Number(byCategory["infra-governance"] ?? 0) >= 1
|
|
&& Number(byCategory["infrastructure-blocker"] ?? 0) >= 1, "deterministic classifier should cover requested categories", byCategory);
|
|
assertCondition(classification.deterministic === true, "classification metadata should be deterministic", classification);
|
|
assertCondition(Number(readyRiskCounts.infrastructureBlocker ?? 0) === 0, "ready commander page should not report infrastructure blocker risk", readyRiskCounts);
|
|
assertCondition(readyInfrastructure.infrastructureBlocker === false && readyInfrastructure.status === "ready", "ready commander page should surface ready infrastructure", readyInfrastructure);
|
|
assertCondition(Number(readyByCategory["infrastructure-blocker"] ?? 0) === 0, "runner/governance boilerplate must not classify historical tasks as infrastructure-blocker", readyByCategory);
|
|
assertCondition(Number(readyByCategory["workflow"] ?? 0) + Number(readyByCategory["user-facing"] ?? 0) + Number(readyByCategory["infra-governance"] ?? 0) + Number(readyByCategory["unknown"] ?? 0) === 12, "ready fixture tasks should be split without blocker overreporting", readyByCategory);
|
|
assertCondition(String(commands.refresh ?? "").includes("--view commander"), "commander refresh command should preserve explicit commander view", commands);
|
|
assertCondition(String(commands.supervisor ?? "").startsWith("bun scripts/cli.ts codex tasks") && !String(commands.supervisor ?? "").includes("--view commander"), "commander should keep supervisor drilldown command", commands);
|
|
assertCondition(String(commands.full ?? "").includes("--view full"), "commander should keep full drilldown command", commands);
|
|
assertCondition(String(commands.rawOverview ?? "").includes("microservice proxy code-queue") && String(commands.rawOverview ?? "").includes("--raw"), "commander should expose raw overview drilldown", commands);
|
|
assertCondition(String(commands.traceTemplate ?? "").includes("codex task <taskId> --trace"), "commander should expose trace drilldown template", commands);
|
|
assertCondition(String(commands.outputTemplate ?? "").includes("codex output <taskId>"), "commander should expose output drilldown template", commands);
|
|
assertCondition(String(commands.showTemplate ?? "").includes("codex task <taskId>"), "commander should include task drilldown template for attention rows", commands);
|
|
assertCondition(asArray(runningRisk.riskSignals).includes("stale-recovery-candidate") && asArray(runningRisk.riskSignals).includes("blocked"), "active risk row should expose stale/blocker signals", runningRisk);
|
|
assertCondition(!attentionItems.some((item) => item.id === "task-failed-unread"), "default commander attention should not expand terminal unread items", { attentionItems });
|
|
assertCondition(!commanderBody.includes("raw-prompt-task-running-risk-20"), "commander output should not dump long raw prompt bodies", { chars: commanderBody.length });
|
|
assertCondition(!commanderBody.includes("summary-final-task-running-risk-20"), "commander output should not dump long final response bodies", { chars: commanderBody.length });
|
|
assertCondition(!commanderBody.includes("\"prompt\""), "commander output should not include prompt preview fields by default", { commanderBody });
|
|
assertCondition(!commanderBody.includes("\"last\""), "commander output should not include final-response preview fields by default", { commanderBody });
|
|
assertCondition(!recentIds.some((id) => terminalIds.includes(id)), "recentCompleted section must not duplicate terminalUnread rows", { recentIds, terminalIds });
|
|
assertCondition(recentIds.length === 3, "recentCompleted commander section should be independently capped", { recentIds });
|
|
assertCondition(terminalUnreadSection.returned === 0 && asArray(terminalUnreadSection.items).length === 0, "default commander terminal unread section should omit item details", terminalUnreadSection);
|
|
assertCondition(String(asRecord(terminalUnreadSection.commands).unread ?? "").includes("codex unread"), "terminal unread section should point to codex unread drill-down", terminalUnreadSection);
|
|
assertCondition(JSON.stringify(terminalAliasFilters.status) === JSON.stringify(["succeeded", "canceled"]), "completed/cancelled status aliases should normalize to succeeded/canceled", terminalAliasFilters);
|
|
assertCondition(!commanderTerminalAliasBody.includes("task-failed-unread"), "completed/cancelled aliases should filter out failed tasks", { commanderTerminalAliasBody });
|
|
assertCondition(String(terminalAliasCommands.refresh ?? "").includes("--status succeeded,canceled"), "normalized status aliases should be preserved in drill-down commands", terminalAliasCommands);
|
|
assertCondition(asArray(terminalAliasRecentCompleted.items).some((item) => asRecord(item).id === "task-recent-read-docs"), "completed alias should include read succeeded tasks in recent completed", terminalAliasRecentCompleted);
|
|
|
|
const badStatus = spawnSync("bun", ["scripts/cli.ts", "codex", "tasks", "--status", "done", "--limit", "1"], {
|
|
cwd: process.cwd(),
|
|
encoding: "utf8",
|
|
});
|
|
const badStatusJson = JSON.parse(badStatus.stdout) as JsonRecord;
|
|
assertCondition(badStatus.status !== 0, "unsupported codex tasks --status should fail", { status: badStatus.status, stdout: badStatus.stdout, stderr: badStatus.stderr });
|
|
const badStatusError = asRecord(badStatusJson.error);
|
|
assertCondition(badStatusError.degradedReason === "validation-failed", "unsupported status should return structured validation error", badStatusError);
|
|
assertCondition(Array.isArray(badStatusError.supported) && asArray(badStatusError.supported).includes("succeeded"), "unsupported status should list supported values", badStatusError);
|
|
assertCondition(Array.isArray(badStatusError.aliases) && asArray(badStatusError.aliases).includes("completed->succeeded") && asArray(badStatusError.aliases).includes("cancelled->canceled"), "unsupported status should list common aliases", badStatusError);
|
|
assertCondition(!badStatus.stdout.includes("stack") && !badStatus.stdout.includes("at parseTasksOptions"), "expected codex tasks parameter errors should not print stack traces by default", { stdout: badStatus.stdout });
|
|
assertCondition(asRecord(supervisorView.completedUnread).count === 3 && asRecord(supervisorView.recentCompleted).count === 5, "supervisor view should remain available and keep separate unread/recent sections", supervisorView);
|
|
assertCondition(commanderLimit8Body.length < 16_000, "commander --limit 8 output should stay compact for polling", { chars: commanderLimit8Body });
|
|
assertCondition(asRecord(commanderLimit8View.filters).requestedLimit === 8, "commander --limit 8 should preserve requested limit disclosure", commanderLimit8View);
|
|
assertCondition(asArray(limit8ActiveRunners.items).some((item) => asRecord(item).id === "task-running-risk"), "commander --limit 8 should keep active items", limit8ActiveRunners);
|
|
assertCondition(limit8TerminalUnread.returned === 0 && asArray(limit8TerminalUnread.items).length === 0, "commander --limit 8 should not expand terminal unread item details", limit8TerminalUnread);
|
|
assertCondition(!limit8AttentionItems.some((item) => String(item.id ?? "").includes("unread")), "commander --limit 8 attention should omit terminal unread rows", { limit8AttentionItems });
|
|
assertCondition(String(limit8Commands.unread ?? "").includes("codex unread"), "commander --limit 8 should keep unread drill-down command", limit8Commands);
|
|
assertCondition(String(limit8Commands.full ?? "").includes("--view full"), "commander --limit 8 should keep full drill-down command", limit8Commands);
|
|
assertCondition(!commanderLimit8Body.includes("RAW_PROMPT_SHOULD_NOT_LEAK") && !commanderLimit8Body.includes("raw-prompt-task-failed-unread"), "commander --limit 8 should not print unread prompt details", { commanderLimit8Body });
|
|
assertCondition(!commanderLimit8Body.includes("summary-final-task-failed-unread"), "commander --limit 8 should not print unread final-response details", { commanderLimit8Body });
|
|
assertCondition(fullLimit8Body.includes("raw-prompt-task-failed-unread") || fullLimit8Body.includes("display-prompt-task-failed-unread"), "--view full should still expose task detail previews", { fullLimit8Body });
|
|
assertCondition(unreadLimit8Body.includes("task-failed-unread") && unreadLimit8Body.includes("readTemplate"), "supervisor unread drill-down should still expose terminal unread task ids", { unreadLimit8Body });
|
|
assertCondition(!commanderLimit8Requests.some((request) => request.path.includes("task-failed-unread") && request.path.includes("/summary")), "default commander --limit 8 should not fetch terminal unread summaries", { commanderLimit8Requests });
|
|
|
|
return {
|
|
ok: true,
|
|
checks: [
|
|
"commander view is explicit and bounded",
|
|
"exact active/queued/retry_wait/terminal-unread counts are preserved",
|
|
"attention rows expose active, queued/retry_wait and blocker signals",
|
|
"high-priority issue refs are surfaced",
|
|
"deterministic classifier emits requested categories",
|
|
"ready infrastructure pages do not classify all historical runner tasks as infrastructure-blocker",
|
|
"drilldown commands are present without prompt/final-response flood",
|
|
"commander --limit 8 omits terminal unread details and prompt previews",
|
|
"codex tasks --status completed,cancelled aliases normalize to succeeded,canceled",
|
|
"codex tasks invalid --status returns compact structured suggestions without stack noise",
|
|
"full and unread drill-down paths still expose details",
|
|
"recent completed does not duplicate terminal unread",
|
|
"supervisor/full views remain available",
|
|
],
|
|
commanderChars: commanderBody.length,
|
|
commanderLimit8Chars: commanderLimit8Body.length,
|
|
fullChars: fullBody.length,
|
|
};
|
|
}
|
|
|
|
if (import.meta.main) {
|
|
process.stdout.write(`${JSON.stringify(runCodeQueueCommanderViewContract(), null, 2)}\n`);
|
|
}
|