@codions/portta 0.1.0 → 0.3.1

package/dist/assets/workflows/bake-off.workflow.js

@@ -1,172 +0,0 @@
-// Bake-off: both providers implement the same task in isolated fork leases, then blind judges
-// from both providers score the two diffs (neutral A/B labels, shuffled per run, so neither judge
-// knows whose work is whose), a tie-break settles splits, and the closing report says what to
-// graft from the loser. Both worktree branches are preserved for the user.
-// Run with: portta flow run workflow bake-off --input '<task>'
-//       or: portta flow workflows run bake-off --args '"<task>"'   (or --args '{"task": "..."}')
-
-export const meta = {
-  name: "bake-off",
-  description:
-    "Implementation bake-off — Codex and Claude each build the same task in isolated worktrees, blind cross-provider judges score the diffs, tie-break on splits, report with graft suggestions.",
-  defaultSandbox: "read-only",
-  workspace: {
-    default: "current_branch",
-    allowed: ["isolated_worktree", "new_branch", "current_branch"],
-    mutatesRepository: true,
-    reason: "The checkout is only the stable base; Taskflow creates one isolated child worktree for each contender.",
-  },
-  phases: [
-    { title: "Implement", detail: "each provider builds the task in its own git worktree" },
-    { title: "Judge", detail: "blind A/B scoring by one judge per provider; tie-break on splits" },
-    { title: "Report", detail: "verdict, preserved branches, what to graft from the loser" },
-  ],
-}
-
-const CONTENDERS = [
-  { provider: "codex", model: "gpt-5.5", name: "Codex" },
-  { provider: "claude-code", model: "claude-fable-5", name: "Claude" },
-]
-
-const task =
-  typeof args === "string" && args.trim()
-    ? args.trim()
-    : args && typeof args === "object" && typeof args.task === "string" && args.task.trim()
-      ? args.task.trim()
-      : null
-if (!task) throw new Error(`bake-off needs a task — pass --args '"<task>"' or --args '{"task": "..."}'`)
-
-// Neutral, unique-per-run branch names (now() is resume-stable) with a shuffled provider→slot
-// mapping, so the judges' A/B labels carry no provider hint. Best-effort blinding: the diff
-// itself can still hint at a model's style, so judges are told to score only the code.
-const stamp = now().toString(36)
-const shuffled = random() < 0.5 ? [CONTENDERS[1], CONTENDERS[0]] : [...CONTENDERS]
-const slots = shuffled.map((c, i) => ({
-  ...c,
-  slot: i === 0 ? "A" : "B",
-  branch: `bake-off/${stamp}-${i === 0 ? "a" : "b"}`,
-}))
-
-const IMPL_SCHEMA = {
-  type: "object",
-  required: ["approach", "tested"],
-  properties: { approach: { type: "string" }, tested: { type: "string" } },
-}
-
-const JUDGE_SCHEMA = {
-  type: "object",
-  required: ["winner", "scoreA", "scoreB", "reasoning"],
-  properties: {
-    winner: { type: "string", enum: ["A", "B", "tie"] },
-    scoreA: { type: "number" },
-    scoreB: { type: "number" },
-    reasoning: { type: "string" },
-  },
-}
-
-// ---------------------------------------------------------------------------
-// Implement — same prompt, separate worktrees. Committing is mandatory: the
-// judges read each entry as `git diff HEAD...<branch>`, so uncommitted work
-// is invisible to them (and an untouched worktree is auto-removed).
-// ---------------------------------------------------------------------------
-phase("Implement")
-log(`bake-off: ${task}`)
-
-const built = (
-  await parallel(
-    slots.map((s) => () =>
-      agent(
-        `Implement the following task in this repository, completely:\n\n${task}\n\n` +
-          `Match the existing code style and conventions. Run the project's relevant tests or build ` +
-          `if available and make them pass. COMMIT all of your work to the current branch with clear ` +
-          `messages — uncommitted changes will not be judged. Do not push.\n\n` +
-          `When done, summarize your approach and exactly what you verified (tests run, manual checks).`,
-        { provider: s.provider, model: s.model, label: `implement: ${s.name}`, phase: "Implement", worktree: s.branch, schema: IMPL_SCHEMA },
-      ).then((r) => ({ ...s, approach: r.approach, tested: r.tested })),
-    ),
-  )
-).filter(Boolean)
-
-if (built.length === 0) throw new Error("both implementations failed — nothing to judge")
-
-// ---------------------------------------------------------------------------
-// Judge — one judge per provider scores both diffs blind. Agreement on a
-// non-tie winner decides it; a split or all-tie goes to a tie-break judge
-// who also sees the first judges' reasoning.
-// ---------------------------------------------------------------------------
-let verdicts = []
-let winnerSlot = null
-
-if (built.length === 1) {
-  winnerSlot = built[0].slot
-  log(`only ${built[0].name} finished — wins by default`)
-} else {
-  phase("Judge")
-  const [a, b] = built[0].slot === "A" ? built : [built[1], built[0]]
-  const judgePrompt =
-    `Two competing implementations of the same task exist as branches in this repository.\n\n` +
-    `Task:\n${task}\n\n` +
-    `Implementation A: branch ${a.branch}\nImplementation B: branch ${b.branch}\n\n` +
-    `Review each with \`git diff HEAD...<branch>\` and read enough surrounding code to judge it in ` +
-    `context. Judge ONLY the code — ignore commit authorship, message style, and anything else ` +
-    `that hints at who wrote it. Score each implementation 0-10 weighing correctness, ` +
-    `completeness against the task, code quality, and test coverage, then pick a winner — "tie" ` +
-    `only when they are genuinely inseparable. Be specific about what decided it.`
-
-  verdicts = (
-    await parallel(
-      CONTENDERS.map((j) => () =>
-        agent(judgePrompt, { provider: j.provider, model: j.model, label: `judge: ${j.name}`, phase: "Judge", schema: JUDGE_SCHEMA }).then(
-          (v) => ({ judge: j.name, ...v }),
-        ),
-      ),
-    )
-  ).filter(Boolean)
-
-  const calls = verdicts.map((v) => v.winner).filter((w) => w !== "tie")
-  if (verdicts.length > 0 && calls.length > 0 && new Set(calls).size === 1) {
-    winnerSlot = calls[0]
-  } else if (verdicts.length === 0) {
-    log("both judges failed — reporting without a verdict")
-  } else {
-    log(`judges split (${verdicts.map((v) => `${v.judge}: ${v.winner}`).join(", ")}) — tie-break`)
-    const tiebreak = await agent(
-      `${judgePrompt}\n\nTwo judges already scored these and could not agree:\n` +
-        `${JSON.stringify(verdicts.map((v) => ({ winner: v.winner, scoreA: v.scoreA, scoreB: v.scoreB, reasoning: v.reasoning })), null, 2)}\n\n` +
-        `You are the tie-break. Weigh their reasoning against the actual diffs and make the final ` +
-        `call — "tie" only as a last resort.`,
-      { label: "tie-break", phase: "Judge", effort: "xhigh", schema: JUDGE_SCHEMA },
-    )
-    verdicts.push({ judge: "tie-break", ...tiebreak })
-    winnerSlot = tiebreak.winner === "tie" ? null : tiebreak.winner
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Report — the A/B mapping is revealed only here, after all judging is done.
-// ---------------------------------------------------------------------------
-phase("Report")
-
-const winner = winnerSlot ? built.find((c) => c.slot === winnerSlot) : null
-log(winner ? `winner: ${winner.name} (${winner.branch})` : "verdict: tie")
-
-const report = await agent(
-  `Write the closing report for an implementation bake-off.\n\n` +
-    `Task:\n${task}\n\n` +
-    `Contenders (the judges saw only the A/B labels):\n` +
-    `${JSON.stringify(built.map((c) => ({ slot: c.slot, provider: c.name, branch: c.branch, approach: c.approach, tested: c.tested })), null, 2)}\n\n` +
-    `Judge verdicts:\n${JSON.stringify(verdicts, null, 2)}\n\n` +
-    `Verdict: ${winner ? `${winner.name} (slot ${winner.slot}) won` : "tie / no verdict"}.\n\n` +
-    `Cover: the verdict and the decisive reasons; concrete strengths of the winner; anything in the ` +
-    `other implementation worth grafting — read its diff (git diff HEAD...<branch>) and name ` +
-    `specific files or ideas; and exact next steps (git commands to inspect each branch, merge the ` +
-    `winner, cherry-pick grafts). Both worktree branches are preserved.`,
-  { label: "report", phase: "Report" },
-)
-
-return {
-  winner: winner ? winner.name : "tie",
-  branches: Object.fromEntries(built.map((c) => [c.name, c.branch])),
-  judges: verdicts,
-  report,
-}

package/dist/assets/workflows/code-review.workflow.js

@@ -1,179 +0,0 @@
-// Code review: one finder agent per review angle, an independent verifier per candidate finding
-// (CONFIRMED / PLAUSIBLE / REFUTED), a gap-sweep at the higher levels, then a ranked, capped report.
-// Run with: portta flow run workflow code-review [--input-json '{"target": "<ref|path|diff>", "level": "high|xhigh|max"}']
-//       or: portta flow workflows run code-review [--args '{"target": "<ref|path|diff>", "level": "high|xhigh|max"}']
-
-export const meta = {
-  name: "code-review",
-  description:
-    "Multi-agent code review — one finder per angle, independent verification of every finding, gap-sweep at higher levels, ranked report.",
-  defaultSandbox: "read-only",
-  workspace: {
-    default: "current_branch",
-    allowed: ["isolated_worktree", "new_branch", "current_branch"],
-    mutatesRepository: false,
-    reason: "Review should inspect the active branch and its uncommitted changes without modifying them.",
-  },
-  phases: [
-    { title: "Review", detail: "one finder agent per review angle" },
-    { title: "Verify", detail: "independent verifier per candidate finding" },
-    { title: "Sweep", detail: "hunt for what the angle reviewers missed (xhigh/max)" },
-    { title: "Report", detail: "rank, cap, and write up the confirmed findings" },
-  ],
-}
-
-// Review angles in priority order; each level takes a prefix and scales the caps.
-const ANGLES = [
-  "correctness — logic errors, wrong conditions, off-by-ones, broken control flow",
-  "security — injection, traversal, unsafe deserialization, secrets, authz gaps",
-  "error-handling — swallowed errors, missing edge/null cases, bad failure modes",
-  "resource-handling — leaks, missing cleanup, unbounded growth, races on shutdown",
-  "concurrency — data races, missing awaits, ordering assumptions, deadlocks",
-  "api-contracts — breaking changes, type mismatches, violated invariants between modules",
-  "performance — accidental O(n²), needless I/O in loops, oversized payloads",
-  "test-gaps — changed behavior with no covering test, tests asserting the wrong thing",
-]
-
-const LEVEL_PARAMS = {
-  high: { angles: 4, maxPerAngle: 8, maxReport: 10, gapSweep: false },
-  xhigh: { angles: 6, maxPerAngle: 10, maxReport: 20, gapSweep: true },
-  max: { angles: 8, maxPerAngle: 12, maxReport: 30, gapSweep: true },
-}
-
-const level = args && typeof args === "object" && typeof args.level === "string" ? args.level : "high"
-const params = LEVEL_PARAMS[level]
-if (!params) throw new Error(`unknown level "${level}" — expected one of: ${Object.keys(LEVEL_PARAMS).join(", ")}`)
-
-const target =
-  args && typeof args === "object" && typeof args.target === "string" && args.target.trim()
-    ? args.target.trim()
-    : "the uncommitted changes in this repository (git diff HEAD; if empty, review the most recent commit)"
-
-const angles = ANGLES.slice(0, params.angles)
-
-const FINDING_SCHEMA = {
-  type: "object",
-  required: ["findings"],
-  properties: {
-    findings: {
-      type: "array",
-      items: {
-        type: "object",
-        required: ["file", "title", "why", "severity"],
-        properties: {
-          file: { type: "string" },
-          line: { type: "number" },
-          title: { type: "string" },
-          why: { type: "string" },
-          severity: { type: "string", enum: ["critical", "high", "medium", "low"] },
-        },
-      },
-    },
-  },
-}
-
-const VERDICT_SCHEMA = {
-  type: "object",
-  required: ["verdict", "reason"],
-  properties: {
-    verdict: { type: "string", enum: ["CONFIRMED", "PLAUSIBLE", "REFUTED"] },
-    reason: { type: "string" },
-  },
-}
-
-// Each candidate gets an independent verifier; CONFIRMED/PLAUSIBLE survive, REFUTED dies.
-const verify = (finding) =>
-  agent(
-    `You are a skeptical senior reviewer double-checking one flagged issue in ${target}. ` +
-      `Read the actual code before judging. Verdicts:\n` +
-      `- CONFIRMED: you reproduced the reasoning against the real code and the issue is real.\n` +
-      `- PLAUSIBLE: you could not refute it, but could not fully confirm it from the code either.\n` +
-      `- REFUTED: false positive — mis-read code, already handled, intended behavior, or not present.\n` +
-      `Default toward REFUTED when the finding is vague or you cannot locate the code it describes.\n\n` +
-      `Finding (JSON):\n${JSON.stringify(finding, null, 2)}`,
-    { label: `verify: ${finding.title.slice(0, 40)}`, phase: "Verify", schema: VERDICT_SCHEMA },
-  ).then((v) => (v.verdict === "REFUTED" ? null : { ...finding, verdict: v.verdict, verdictReason: v.reason }))
-
-// ---------------------------------------------------------------------------
-// Review + Verify — pipeline: each angle's findings go to verification as soon
-// as that finder returns, while slower finders are still reading.
-// ---------------------------------------------------------------------------
-phase("Review")
-log(`reviewing ${target} at level ${level}: ${angles.length} angles`)
-
-const verifiedByAngle = await pipeline(
-  angles,
-  (angle) =>
-    agent(
-      `Review ${target} strictly through this lens:\n${angle}\n\n` +
-        `Read the relevant code (and surrounding context) rather than judging from the diff text ` +
-        `alone. Report up to ${params.maxPerAngle} concrete findings: file, line when you can ` +
-        `pinpoint it, a short title, why it is a real problem through this lens, and a severity ` +
-        `(critical|high|medium|low). Only report issues you can point to in the code — no ` +
-        `speculation, no style nits.`,
-      { label: `find: ${angle.split(" — ")[0]}`, phase: "Review", schema: FINDING_SCHEMA },
-    ),
-  (review, angle) =>
-    parallel(
-      (review.findings || [])
-        .slice(0, params.maxPerAngle)
-        .map((f) => () => verify({ ...f, angle: angle.split(" — ")[0] })),
-    ),
-)
-
-let confirmed = verifiedByAngle.filter(Boolean).flat().filter(Boolean)
-log(`${confirmed.length} findings survived verification`)
-
-// ---------------------------------------------------------------------------
-// Sweep (xhigh/max) — one agent hunts for what the per-angle reviewers missed;
-// its candidates go through the same verifier.
-// ---------------------------------------------------------------------------
-if (params.gapSweep) {
-  phase("Sweep")
-  const sweep = await agent(
-    `You are the final gap-sweep on a multi-agent review of ${target}. The angles already ` +
-      `covered: ${angles.map((a) => a.split(" — ")[0]).join(", ")}. Findings already confirmed ` +
-      `(do NOT re-report these):\n${JSON.stringify(confirmed.map((f) => ({ file: f.file, title: f.title })), null, 2)}\n\n` +
-      `Look for what they missed: cross-cutting issues, interactions between changes, anything in ` +
-      `the changed code that no single angle would catch. Up to ${params.maxPerAngle} findings, ` +
-      `same bar: concrete, code-anchored, no nits.`,
-    { label: "gap-sweep", phase: "Sweep", schema: FINDING_SCHEMA },
-  )
-  const sweepVerified = await parallel(
-    (sweep.findings || []).slice(0, params.maxPerAngle).map((f) => () => verify({ ...f, angle: "gap-sweep" })),
-  )
-  confirmed = confirmed.concat(sweepVerified.filter(Boolean))
-  log(`${confirmed.length} findings after gap-sweep`)
-}
-
-// ---------------------------------------------------------------------------
-// Report — rank (CONFIRMED before PLAUSIBLE, then severity), cap, write up.
-// ---------------------------------------------------------------------------
-phase("Report")
-
-const SEVERITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 }
-const ranked = confirmed
-  .slice()
-  .sort(
-    (a, b) =>
-      (a.verdict === b.verdict ? 0 : a.verdict === "CONFIRMED" ? -1 : 1) ||
-      SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity] ||
-      a.file.localeCompare(b.file),
-  )
-const findings = ranked.slice(0, params.maxReport)
-if (ranked.length > findings.length) log(`reporting top ${params.maxReport} of ${ranked.length} findings (cap)`)
-
-if (findings.length === 0) {
-  return { findings: [], report: `Reviewed ${target} across ${angles.length} angles at level ${level}: no findings survived independent verification.` }
-}
-
-const report = await agent(
-  `Write a concise code-review report for ${target}. The findings below are already independently ` +
-    `verified and ranked — keep that order. For each: severity, verdict (CONFIRMED/PLAUSIBLE), ` +
-    `file:line, what is wrong, and a suggested fix direction in a sentence. Open with a 2-3 ` +
-    `sentence summary of the overall state of the change.\n\n` +
-    `Findings (JSON):\n${JSON.stringify(findings, null, 2)}`,
-  { label: "write report", phase: "Report" },
-)
-
-return { findings, report }

package/dist/assets/workflows/deep-research.workflow.js

@@ -1,223 +0,0 @@
-// Deep research: fan out web searches, deep-read the best sources, adversarially verify every
-// claim with a 3-vote panel, synthesize a cited report.
-// Run with: portta flow run workflow deep-research --input '<question>'
-//       or: portta flow workflows run deep-research --args '"<question>"'
-
-export const meta = {
-  name: "deep-research",
-  description:
-    "Deep research harness — fan-out web searches, fetch sources, adversarially verify claims, synthesize a cited report.",
-  defaultSandbox: "read-only",
-  workspace: {
-    default: "current_branch",
-    allowed: ["isolated_worktree", "new_branch", "current_branch"],
-    mutatesRepository: false,
-    reason: "Research is read-only and normally does not need an isolated Git worktree.",
-  },
-  phases: [
-    { title: "Scope", detail: "break the question into distinct search directives" },
-    { title: "Search", detail: "5 parallel web-search agents" },
-    { title: "Fetch", detail: "dedup URLs, deep-read the top sources" },
-    { title: "Verify", detail: "3-vote adversarial panel per claim" },
-    { title: "Synthesize", detail: "cited report from surviving claims" },
-  ],
-}
-
-const SEARCHERS = 5
-const VOTES_PER_CLAIM = 3
-const REFUTATIONS_REQUIRED = 2 // 2 of 3 refute votes kill a claim
-const MAX_FETCH = 15
-const MAX_VERIFY_CLAIMS = 25
-
-const question =
-  typeof args === "string" && args.trim()
-    ? args.trim()
-    : args && typeof args === "object" && typeof args.question === "string" && args.question.trim()
-      ? args.question.trim()
-      : null
-if (!question) {
-  throw new Error(`deep-research needs a question — pass --args '"<question>"' or --args '{"question": "..."}'`)
-}
-
-// ---------------------------------------------------------------------------
-// Scope — turn the question into SEARCHERS distinct search directives.
-// ---------------------------------------------------------------------------
-phase("Scope")
-log(`scoping: ${question}`)
-
-const scope = await agent(
-  `You are scoping a deep web-research project for this question:\n\n${question}\n\n` +
-    `Produce exactly ${SEARCHERS} distinct search directives. Each directive is a short instruction ` +
-    `for an independent researcher with web search: what to search for and what kind of sources to ` +
-    `prefer (primary data, official docs, expert analysis, recent news, contrarian takes, ...). ` +
-    `The directives must not overlap — together they should cover the question from genuinely ` +
-    `different angles (different sub-questions, source types, or time windows).`,
-  {
-    label: "scope directives",
-    schema: {
-      type: "object",
-      required: ["directives"],
-      properties: {
-        directives: { type: "array", minItems: SEARCHERS, maxItems: SEARCHERS, items: { type: "string" } },
-      },
-    },
-  },
-)
-
-// ---------------------------------------------------------------------------
-// Search — one web-search agent per directive, in parallel. Barrier: the Fetch
-// stage dedups URLs ACROSS all searchers before spending deep-read agents.
-// ---------------------------------------------------------------------------
-phase("Search")
-
-const searches = await parallel(
-  scope.directives.map((directive, i) => () =>
-    agent(
-      `Research question: ${question}\n\nYour directive (#${i + 1} of ${SEARCHERS}):\n${directive}\n\n` +
-        `Use your web search tool to find the most authoritative sources bearing on this directive. ` +
-        `Return up to 6 sources. For each give the exact URL, its title, and a relevance score 1-5 ` +
-        `(5 = directly answers the question with primary evidence). Only return URLs you actually ` +
-        `found via search — never construct or guess a URL.`,
-      {
-        label: `search ${i + 1}: ${directive.slice(0, 40)}`,
-        schema: {
-          type: "object",
-          required: ["sources"],
-          properties: {
-            sources: {
-              type: "array",
-              items: {
-                type: "object",
-                required: ["url", "title", "relevance"],
-                properties: {
-                  url: { type: "string" },
-                  title: { type: "string" },
-                  relevance: { type: "number" },
-                },
-              },
-            },
-          },
-        },
-      },
-    ),
-  ),
-)
-
-// Dedup by URL (highest relevance wins), rank, keep the top MAX_FETCH.
-const byUrl = new Map()
-for (const s of searches.filter(Boolean).flatMap((r) => r.sources || [])) {
-  if (!s || !s.url) continue
-  const prev = byUrl.get(s.url)
-  if (!prev || s.relevance > prev.relevance) byUrl.set(s.url, s)
-}
-const ranked = [...byUrl.values()].sort((a, b) => b.relevance - a.relevance)
-const sources = ranked.slice(0, MAX_FETCH)
-if (ranked.length > sources.length) log(`dropping ${ranked.length - sources.length} lower-relevance sources (cap ${MAX_FETCH})`)
-log(`${sources.length} unique sources to read`)
-
-// ---------------------------------------------------------------------------
-// Fetch — deep-read each source and extract concrete, checkable claims.
-// ---------------------------------------------------------------------------
-phase("Fetch")
-
-const fetched = await parallel(
-  sources.map((src) => () =>
-    agent(
-      `Research question: ${question}\n\nFetch and read this source:\n${src.title}\n${src.url}\n\n` +
-        `Extract the concrete, checkable claims it makes that bear on the research question — facts, ` +
-        `numbers, findings, dated events. For each claim include a short supporting quote from the ` +
-        `source. Skip opinions, marketing, and anything the source merely speculates about. If the ` +
-        `page is unreachable or irrelevant, return an empty list.`,
-      {
-        label: `fetch: ${src.title.slice(0, 40)}`,
-        schema: {
-          type: "object",
-          required: ["claims"],
-          properties: {
-            claims: {
-              type: "array",
-              items: {
-                type: "object",
-                required: ["claim", "quote"],
-                properties: { claim: { type: "string" }, quote: { type: "string" } },
-              },
-            },
-          },
-        },
-      },
-    ).then((r) => (r.claims || []).map((c) => ({ ...c, url: src.url, title: src.title }))),
-  ),
-)
-
-const allClaims = fetched.filter(Boolean).flat()
-const claims = allClaims.slice(0, MAX_VERIFY_CLAIMS)
-if (allClaims.length > claims.length) log(`verifying first ${MAX_VERIFY_CLAIMS} of ${allClaims.length} claims (cap)`)
-log(`${claims.length} claims to verify`)
-
-// ---------------------------------------------------------------------------
-// Verify — a 3-vote adversarial panel per claim; 2 of 3 refutes kill it. Each
-// voter gets a different lens so the panel's failure modes are decorrelated.
-// ---------------------------------------------------------------------------
-phase("Verify")
-
-const LENSES = [
-  "Check the claim against the quoted text: does the source actually say this, or is it an overreach/misreading?",
-  "Check the claim against your own knowledge and a quick independent web search: is it contradicted elsewhere?",
-  "Check the claim's precision: are the numbers, dates, and attributions right, or materially misleading as stated?",
-]
-
-const verified = await pipeline(claims, (claim) =>
-  parallel(
-    LENSES.slice(0, VOTES_PER_CLAIM).map((lens, v) => () =>
-      agent(
-        `You are a skeptical fact-checker. Your job is to try to REFUTE this claim.\n\n` +
-          `Claim: ${claim.claim}\n` +
-          `Source: ${claim.title} — ${claim.url}\n` +
-          `Supporting quote: "${claim.quote}"\n\n` +
-          `${lens}\n\n` +
-          `Vote refuted=true if the claim is false, unsupported, or materially misleading; when ` +
-          `genuinely uncertain, default to refuted=true.`,
-        {
-          label: `verify ${v + 1}/${VOTES_PER_CLAIM}: ${claim.claim.slice(0, 32)}`,
-          schema: {
-            type: "object",
-            required: ["refuted", "reason"],
-            properties: { refuted: { type: "boolean" }, reason: { type: "string" } },
-          },
-        },
-      ),
-    ),
-  ).then((votes) => {
-    const cast = votes.filter(Boolean)
-    const refutes = cast.filter((v) => v.refuted).length
-    // A skipped/errored vote counts as a refute: a claim must EARN its place in the report.
-    const killed = refutes + (VOTES_PER_CLAIM - cast.length) >= REFUTATIONS_REQUIRED
-    return killed ? null : { ...claim, refutes, votes: VOTES_PER_CLAIM }
-  }),
-)
-
-const survivors = verified.filter(Boolean)
-log(`${survivors.length} of ${claims.length} claims survived the panel`)
-
-// ---------------------------------------------------------------------------
-// Synthesize — a cited report from the surviving claims only.
-// ---------------------------------------------------------------------------
-phase("Synthesize")
-
-if (survivors.length === 0) {
-  return (
-    `# Research report: ${question}\n\n` +
-    `No claims survived adversarial verification (${claims.length} candidates, ${VOTES_PER_CLAIM}-vote panel, ` +
-    `${REFUTATIONS_REQUIRED} refutes to kill). The available sourcing was too weak to answer confidently.`
-  )
-}
-
-return await agent(
-  `Write a well-structured research report answering:\n\n${question}\n\n` +
-    `Use ONLY the verified claims below — every factual statement must trace to one of them, cited ` +
-    `inline as a markdown link to its source URL. Group related claims into sections, lead with a ` +
-    `direct answer, and close with what remains uncertain (claims that were killed or angles that ` +
-    `found nothing). Do not introduce facts that are not in the claims.\n\n` +
-    `Verified claims (JSON):\n${JSON.stringify(survivors, null, 2)}`,
-  { label: "synthesize report" },
-)