pbakaus_impeccable/site/data/live-harnesses.ts

export const harnessPaths = [
  {
    name: 'Dedicated app-server worker',
    harness: 'Codex · isolated persistent thread',
    pickup: '1.47 ms turn wake',
    tradeoff: 'A separate Live-owned thread can generate while the control supervisor keeps polling. Cold setup is 437 ms; a persistent connection amortizes it.',
    status: 'Protocol probe passed',
    statusTone: 'ready',
    source: 'https://learn.chatgpt.com/docs/app-server',
  },
  {
    name: 'Foreground terminal supervisor',
    harness: 'Codex desktop · unified exec session',
    pickup: 'Concurrent shell work proven',
    tradeoff: 'A yielded foreground process keeps running while other commands execute, but new output still needs an explicit session read; it does not wake a finished model turn by itself.',
    status: 'Useful within active turn',
    statusTone: 'measure',
    source: 'https://learn.chatgpt.com/docs/app-server#api-overview',
  },
  {
    name: 'Native generation subagent',
    harness: 'Codex desktop · current shipped path',
    pickup: 'Main turn must dispatch it',
    tradeoff: 'Low-effort compact handoff is safe and fenced, but it cannot start after the desktop task has gone idle.',
    status: 'Current fallback',
    statusTone: 'prototype',
    source: 'https://learn.chatgpt.com/docs/agent-configuration/subagents',
  },
  {
    name: 'Background variant producer',
    harness: 'Claude Code subagent',
    pickup: 'Supported; measure per version',
    tradeoff: 'Model, effort, background execution, and resume are configurable. Preserve the current main-thread path as fallback.',
    status: 'Cross-harness control',
    statusTone: 'control',
    source: 'https://code.claude.com/docs/en/sub-agents',
  },
];

export const liveExperiments = [
  {
    rank: 1,
    title: 'Accept any arrived variant — shipped',
    evidence: 'A real Vite/React run accepts variant 1 while variants 2–3 are delayed, rejects the late worker write, returns to Pick, and leases a second Go under the 1.5 s gate.',
    move: 'Durably fence generation on Accept/Discard, prioritize control events, publish through an epoch + source-hash transaction, and keep a separate poll supervisor active.',
    expected: 'Removes the full-set wait and keeps the page interactive while canceled work unwinds.',
    confidence: 'Protocol + browser E2E',
  },
  {
    rank: 2,
    title: 'Remove the cold-start polling floor — shipped',
    evidence: 'Ten configured Vite runs fell from 327.25 ms baseline to 153.03 ms cold median; p95 is 155.74 ms.',
    move: 'Poll the detached helper readiness record every 5 ms instead of imposing a 200 ms minimum sleep.',
    expected: 'Delivered a 53.2% cold-start reduction without changing injection or browser code.',
    confidence: 'Measured + shipped',
  },
  {
    rank: 3,
    title: 'Dispatch first, capture second — shipped',
    evidence: 'Plain click-handler → generate fetch is now 2.2 ms median; end-to-end model-free latency fell from 916 ms to 414 ms.',
    move: 'Unannotated picks wait for the helper to accept the event, then capture the shader off-path. Annotated picks still capture and upload before dispatch.',
    expected: 'Delivered a 54.8% median reduction on the same fixture and deterministic agent.',
    confidence: 'Measured + shipped',
  },
  {
    rank: 4,
    title: 'Reveal variants progressively — shipped',
    evidence: 'With a simulated 2.00 s variants 2–3 tail, median first-reviewable latency fell from 2.13 s to 145 ms while full-set completion stayed flat.',
    move: 'Codex publishes a monotonically growing prefix as each variant validates. The browser reveals arrived variants and pending dots immediately; Accept and Discard fence unfinished work.',
    expected: 'Delivered a 93.2% median and 92.2% p95 perceived-latency reduction in the matched deterministic run.',
    confidence: 'Measured + shipped',
  },
  {
    rank: 5,
    title: 'Preflight source locally — shipped',
    evidence: 'The helper resolves and wraps the source in roughly 54 ms median as the Generate event is leased, before the model-facing event returns.',
    move: 'Attach durable scaffold metadata to the queued event. Every harness reuses it; discovery failures preserve the existing agent-driven fallback.',
    expected: 'Removes one deterministic source-discovery tool round trip from every successful generation.',
    confidence: 'Measured + shipped',
  },
  {
    rank: 6,
    title: 'Generate knobs after pixels — shipped',
    evidence: 'The first progressive write intentionally carries no parameter manifest; tune controls arrive with the complete variant set.',
    move: 'Plan parameter axes with the trio, but defer their manifests and CSS branches until the final delivery edit.',
    expected: 'Keeps parameter output off the first-reviewable critical path without shrinking the final tuning surface.',
    confidence: 'Protocol shipped',
  },
  {
    rank: 7,
    title: 'Acknowledge first, clean up off-path — shipped',
    evidence: 'React and Svelte release the picker in 1–2 ms after durable Accept. The provider-independent cleanup control reaches marker-free, buildable source in 171 ms with zero console errors.',
    move: 'Keep the durable accept acknowledgement on the foreground path, then hand carbonize cleanup to a source-locked worker while the poll supervisor leases new work.',
    expected: 'Preserves immediate interaction without leaving temporary Live source behind.',
    confidence: 'Browser + build control',
  },
  {
    rank: 8,
    title: 'Do not release before durability — rejected',
    evidence: 'The measured durable acknowledgement already releases the picker in 1–2 ms. Releasing before it lands cannot create a perceptible win, but can show a successful Accept that recovery cannot replay.',
    move: 'Keep the acknowledgement barrier; make every later cleanup and validation step asynchronous instead.',
    expected: 'Retains crash recovery for no measurable interaction penalty.',
    confidence: 'Measured floor + recovery gate',
  },
  {
    rank: 9,
    title: 'Do not batch a whole Live session — rejected as default',
    evidence: 'Immediate transactional Accept already returns control in 1–2 ms. Deferring source commits would move rather than remove work, make the next generation read stale design context, and enlarge the crash-recovery boundary.',
    move: 'Batch only cleanup operations that do not affect the next generation. Commit each chosen design under the source lock before treating it as project truth.',
    expected: 'Keeps later variants on-brand with the latest accepted source and bounds recovery to one interaction.',
    confidence: 'Quality + recovery rejection',
  },
  {
    rank: 10,
    title: 'Keep a harness-native producer warm — not the default',
    evidence: 'A paired Codex probe produced a correct identity lock and guardrails, but resume took 23.1 s versus 21.7 s fresh. One pair is not statistically stable, and it shows no speed signal.',
    move: 'Keep warm resume as an opt-in harness experiment; do not put it on the critical path until repeated spawn/resume measurements beat compact progressive generation.',
    expected: 'Avoids paying context-management overhead for an unproven latency gain.',
    confidence: 'Paired harness probe',
  },
  {
    rank: 11,
    title: 'Parallelize ideas, centralize writes — provider-specific',
    evidence: 'Parallel compact passed 5/5 for GPT-5.5 and Gemini 3.1 Flash-Lite, but only 3/5 for Claude Sonnet 4.6. It cut Gemini first review to 1.64 s and GPT full-set completion to 16.21 s.',
    move: 'Make parallel compact the Gemini default and an OpenAI full-set fast path. Do not enable it for Anthropic until its validation reliability improves.',
    expected: 'Lowers time to usable options without shared-file races or pretending one call shape fits every provider.',
    confidence: 'Sixty-run paid matrix',
  },
  {
    rank: 12,
    title: 'Trim the producer contract — selected',
    evidence: 'Progressive compact passed 5/5 for Claude Sonnet 4.6 and GPT-5.5. It was OpenAI’s fastest and cheapest progressive path; Claude’s other candidates all missed reliability.',
    move: 'Keep the stable generation contract cacheable and send only the picked-element context plus the current action and identity lock.',
    expected: 'Reduces prefill and output work without weakening the design brief.',
    confidence: 'Five runs per candidate',
  },
  {
    rank: 13,
    title: 'Wake a dedicated Codex worker — protocol proven',
    evidence: 'A cold app-server handshake took 36.83 ms, thread creation 400.19 ms, and turn/start reached turn/started in 1.47 ms. A low-effort Spark probe completed in 2.06 s.',
    move: 'Keep one Live-owned app-server connection and isolated worker thread warm. Feed it durable events and structured output; never resume the desktop task from a second server.',
    expected: 'Removes terminal-output pickup and main-turn availability from generation startup while preserving transactional publication fencing.',
    confidence: 'Official protocol + live probe',
  },
];

export const currentHarnessProbe = {
  testedAt: '2026-07-13',
  surface: 'Codex desktop unified exec',
  delayedOutputMs: 250,
  processExitMs: null,
  parallelCommandMs: 0.01,
  parallelWorkSucceeded: true,
  backgroundChildSurvivedShellExit: false,
  requiresExplicitSessionRead: true,
  surfacedAutomatically: false,
  result: 'A yielded foreground poller kept producing output while a separate command completed immediately. A traditional shell-backgrounded child did not survive shell exit. Output still required an explicit session read and did not proactively wake a finished turn.',
};