pikasTech-unidesk/scripts/code-queue-submit-summary-contract-test.ts

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 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 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 responseJson = JSON.stringify(response);

  assertCondition(submittedTask.id === submittedId && submittedTask.status === "queued", "submit response should keep the newly queued task", submittedTask);
  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(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.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 });

  return {
    ok: true,
    checks: [
      "newly queued submitted task is included in queuedTaskIds preview",
      "running count context falls back to database active ids",
      "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`);
}