@codions/portta 0.0.0-develop.147.sha-1859ad1

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

@@ -0,0 +1,222 @@
+// Port of Claude Code's built-in `deep-research` workflow: 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 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" },
+)

package/dist/assets/workflows/multi-provider-review.workflow.js

@@ -0,0 +1,168 @@
+// taskflow-original built-in: the same change reviewed twice — once by Codex, once by Claude —
+// each over the ENTIRE feature/branch, then a synthesis pass merges both: consensus findings
+// (both providers saw it → highest confidence), unique catches, and disagreements called out.
+// Run with: portta flow workflows run multi-provider-review [--args '{"target": "<ref|path|diff>"}']
+
+export const meta = {
+  name: "multi-provider-review",
+  description:
+    "Dual-provider review — Codex and Claude each review the full feature/branch independently, then a synthesis merges both: consensus, unique catches, disagreements.",
+  defaultSandbox: "read-only",
+  workspace: {
+    default: "current_branch",
+    allowed: ["isolated_worktree", "new_branch", "current_branch"],
+    mutatesRepository: false,
+    reason: "Both reviewers inspect the active checkout read-only.",
+  },
+  phases: [
+    { title: "Review", detail: "Codex and Claude each review the entire change independently" },
+    { title: "Synthesize", detail: "merge both reviews: consensus, unique findings, ranked report" },
+  ],
+}
+
+const MAX_FINDINGS_PER_REVIEW = 15
+
+const REVIEWERS = [
+  { provider: "codex", model: "gpt-5.5", name: "Codex" },
+  { provider: "claude-code", model: "claude-fable-5", name: "Claude" },
+]
+
+const target =
+  typeof args === "string" && args.trim()
+    ? args.trim()
+    : args && typeof args === "object" && typeof args.target === "string" && args.target.trim()
+      ? args.target.trim()
+      : "the current branch in its entirety — every change relative to its merge-base with the " +
+        "repository's default branch (git merge-base, then git diff <base>...HEAD), plus any " +
+        "uncommitted changes; if already on the default branch, the most recent commit plus any " +
+        "uncommitted changes"
+
+const REVIEW_SCHEMA = {
+  type: "object",
+  required: ["assessment", "findings"],
+  properties: {
+    assessment: { type: "string" },
+    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 SYNTHESIS_SCHEMA = {
+  type: "object",
+  required: ["report", "findings"],
+  properties: {
+    report: { type: "string" },
+    findings: {
+      type: "array",
+      items: {
+        type: "object",
+        required: ["file", "title", "why", "severity", "foundBy"],
+        properties: {
+          file: { type: "string" },
+          line: { type: "number" },
+          title: { type: "string" },
+          why: { type: "string" },
+          severity: { type: "string", enum: ["critical", "high", "medium", "low"] },
+          foundBy: { type: "array", items: { type: "string", enum: REVIEWERS.map((r) => r.name) } },
+        },
+      },
+    },
+  },
+}
+
+// ---------------------------------------------------------------------------
+// Review — both providers read the same full change, blind to each other.
+// The prompts are identical so differences in output reflect the models, not
+// the framing; neither is told another reviewer exists.
+// ---------------------------------------------------------------------------
+phase("Review")
+log(`dual-provider review of ${target}`)
+
+const reviewPrompt =
+  `You are conducting a complete, independent code review of ${target}. Review the WHOLE change, ` +
+  `not a slice of it: read the full diff and enough surrounding code to judge it in context. ` +
+  `Cover correctness, security, error handling, concurrency, resource handling, API contracts, ` +
+  `performance, and test coverage.\n\n` +
+  `Report up to ${MAX_FINDINGS_PER_REVIEW} concrete findings: file, line when you can pinpoint ` +
+  `it, a short title, why it is a real problem, and a severity (critical|high|medium|low). Only ` +
+  `report issues you can point to in the code — no speculation, no style nits. Also give an ` +
+  `overall assessment (2-4 sentences): the state of the change, its main risks, and whether it ` +
+  `looks ready to merge.`
+
+const reviews = (
+  await parallel(
+    REVIEWERS.map((r) => () =>
+      agent(reviewPrompt, {
+        provider: r.provider,
+        model: r.model,
+        label: `review: ${r.name}`,
+        phase: "Review",
+        schema: REVIEW_SCHEMA,
+      }).then((review) => ({
+        reviewer: r.name,
+        assessment: review.assessment,
+        findings: (review.findings || []).slice(0, MAX_FINDINGS_PER_REVIEW),
+      })),
+    ),
+  )
+).filter(Boolean)
+
+if (reviews.length === 0) throw new Error("both provider reviews failed — nothing to synthesize")
+if (reviews.length < REVIEWERS.length)
+  log(`warning: only ${reviews.map((r) => r.reviewer).join(", ")} completed — synthesis will lack cross-provider consensus`)
+for (const r of reviews) log(`${r.reviewer}: ${r.findings.length} findings`)
+
+// ---------------------------------------------------------------------------
+// Synthesize — one agent (run-default provider; override with --provider) sees
+// both labeled reviews and merges them into a single ranked picture.
+// ---------------------------------------------------------------------------
+phase("Synthesize")
+
+const synthesis = await agent(
+  `You are synthesizing ${reviews.length} independent full code reviews of ${target}, each from a ` +
+    `different model provider. Merge them into one picture:\n` +
+    `1. Match findings that describe the same underlying issue — even when worded differently or ` +
+    `pointing at slightly different lines — and merge them into one finding with foundBy listing ` +
+    `every reviewer that caught it. Consensus findings are the highest-confidence ones; rank them ` +
+    `first, then by severity.\n` +
+    `2. Keep findings only one reviewer caught, attributed via foundBy. Spot-check any that look ` +
+    `dubious against the actual code and drop clear false positives (say so in the report).\n` +
+    `3. Where the reviews DISAGREE — about the same code, or in their overall assessments — call ` +
+    `the disagreement out explicitly in the report rather than silently picking a side.\n\n` +
+    `The report should open with a 2-4 sentence overall verdict that synthesizes both assessments, ` +
+    `then note where the reviewers agreed and disagreed, then walk the merged findings in ranked ` +
+    `order (severity, foundBy, file:line, what is wrong, fix direction in a sentence).\n\n` +
+    `Reviews (JSON):\n${JSON.stringify(reviews, null, 2)}`,
+  { label: "synthesize", phase: "Synthesize", schema: SYNTHESIS_SCHEMA },
+)
+
+const SEVERITY_RANK = { critical: 0, high: 1, medium: 2, low: 3 }
+const findings = (synthesis.findings || [])
+  .slice()
+  .sort(
+    (a, b) =>
+      (b.foundBy || []).length - (a.foundBy || []).length ||
+      SEVERITY_RANK[a.severity] - SEVERITY_RANK[b.severity] ||
+      a.file.localeCompare(b.file),
+  )
+
+const consensus = findings.filter((f) => (f.foundBy || []).length > 1).length
+log(`${findings.length} merged findings (${consensus} consensus)`)
+
+return {
+  reviews: reviews.map((r) => ({ reviewer: r.reviewer, assessment: r.assessment, findingCount: r.findings.length })),
+  findings,
+  report: synthesis.report,
+}

package/dist/assets/workflows/provider-debate.workflow.js

@@ -0,0 +1,140 @@
+// taskflow-original built-in: one provider proposes a position, the other attacks it, the
+// proposer rebuts or concedes, for N rounds — then a judge rules on what actually survived.
+// The cross-provider attacker is the point: a model is measurably worse at finding holes in its
+// own reasoning than another model is.
+// Run with: portta flow workflows run provider-debate --args '"<question>"'
+//       or: --args '{"question": "...", "rounds": 2, "proposer": "codex" | "claude-code"}'
+
+export const meta = {
+  name: "provider-debate",
+  description:
+    "Adversarial debate — one provider proposes, the other attacks, N rounds of rebuttal, then a judge rules on what survived, what was conceded, and what to actually do.",
+  defaultSandbox: "read-only",
+  workspace: {
+    default: "current_branch",
+    allowed: ["isolated_worktree", "new_branch", "current_branch"],
+    mutatesRepository: false,
+    reason: "The debate is read-only and normally needs no Git isolation.",
+  },
+  phases: [
+    { title: "Propose", detail: "the proposer takes a concrete position" },
+    { title: "Debate", detail: "attack and rebuttal, one exchange per round" },
+    { title: "Verdict", detail: "a judge rules: survived, conceded, open, recommendation" },
+  ],
+}
+
+const PROVIDERS = {
+  codex: { provider: "codex", model: "gpt-5.5", name: "Codex" },
+  "claude-code": { provider: "claude-code", model: "claude-fable-5", name: "Claude" },
+}
+
+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(`provider-debate needs a question — pass --args '"<question>"' or --args '{"question": "..."}'`)
+}
+
+const proposerId = args && typeof args === "object" && args.proposer !== undefined ? args.proposer : "codex"
+const proposer = PROVIDERS[proposerId]
+if (!proposer) throw new Error(`unknown proposer "${proposerId}" — expected "codex" or "claude-code"`)
+const attacker = proposer === PROVIDERS.codex ? PROVIDERS["claude-code"] : PROVIDERS.codex
+
+const rawRounds = args && typeof args === "object" && typeof args.rounds === "number" ? args.rounds : 2
+const rounds = Math.max(1, Math.min(5, Math.floor(rawRounds)))
+
+const VERDICT_SCHEMA = {
+  type: "object",
+  required: ["recommendation", "survived", "conceded", "open", "report"],
+  properties: {
+    recommendation: { type: "string" },
+    survived: { type: "array", items: { type: "string" } },
+    conceded: { type: "array", items: { type: "string" } },
+    open: { type: "array", items: { type: "string" } },
+    report: { type: "string" },
+  },
+}
+
+const transcriptText = (transcript) =>
+  transcript
+    .map((t) => `--- Round ${t.round} ---\nObjections:\n${t.critique}\n\nRebuttal:\n${t.rebuttal}`)
+    .join("\n\n")
+
+// ---------------------------------------------------------------------------
+// Propose — a concrete, attackable position.
+// ---------------------------------------------------------------------------
+phase("Propose")
+log(`debate: ${question} (${proposer.name} proposes, ${attacker.name} attacks, ${rounds} round${rounds === 1 ? "" : "s"})`)
+
+const proposal = await agent(
+  `Take a clear position on the following and propose a concrete answer or design:\n\n${question}\n\n` +
+    `If this concerns the repository you are in, read the relevant code first and ground your ` +
+    `position in it. Make your reasoning, assumptions, and tradeoffs explicit — this proposal will ` +
+    `be scrutinized line by line, so vagueness counts against it.`,
+  { provider: proposer.provider, model: proposer.model, label: `propose: ${proposer.name}`, phase: "Propose" },
+)
+
+// ---------------------------------------------------------------------------
+// Debate — each round is one attack/rebuttal exchange. The rebuttal ends with
+// the full current proposal, which becomes the target of the next attack.
+// ---------------------------------------------------------------------------
+phase("Debate")
+
+const transcript = []
+let current = proposal
+
+for (let round = 1; round <= rounds; round++) {
+  const history = transcript.length > 0 ? `\n\nDebate so far:\n${transcriptText(transcript)}` : ""
+
+  const critique = await agent(
+    `You are the adversarial examiner in round ${round} of ${rounds} of a structured debate.\n\n` +
+      `Question:\n${question}\n\n` +
+      `Current proposal:\n${current}${history}\n\n` +
+      `Attack the proposal with the strongest objections you can ground in evidence: flaws in ` +
+      `reasoning, missing considerations, risks, and concretely better alternatives. Where the ` +
+      `question concerns this repository, verify your objections against the actual code — a ` +
+      `refuted attack weakens your side. Do not be agreeable, and do not repeat objections that ` +
+      `earlier rebuttals already answered; move to stronger ground instead.`,
+    { provider: attacker.provider, model: attacker.model, label: `attack: round ${round}`, phase: "Debate" },
+  )
+
+  const rebuttal = await agent(
+    `You are the proposer in round ${round} of ${rounds} of a structured debate, defending your proposal.\n\n` +
+      `Question:\n${question}\n\n` +
+      `Your current proposal:\n${current}${history}\n\n` +
+      `New objections:\n${critique}\n\n` +
+      `Respond to each objection in turn: defend it with reasoning and evidence (check the code ` +
+      `where it applies), or concede it explicitly and revise. Conceding a weak point is better ` +
+      `than defending it badly. End with your full current proposal, revised where you conceded.`,
+    { provider: proposer.provider, model: proposer.model, label: `rebut: round ${round}`, phase: "Debate" },
+  )
+
+  transcript.push({ round, critique, rebuttal })
+  current = rebuttal
+}
+
+// ---------------------------------------------------------------------------
+// Verdict — the judge runs on the run-default provider (override with
+// --provider); it rules on the merits, not on who argued better.
+// ---------------------------------------------------------------------------
+phase("Verdict")
+
+const verdict = await agent(
+  `You are the judge of a structured debate. Rule on the merits of the arguments, not the rhetoric.\n\n` +
+    `Question:\n${question}\n\n` +
+    `Initial proposal:\n${proposal}\n\n` +
+    `Full debate:\n${transcriptText(transcript)}\n\n` +
+    `Where a decisive claim about this repository can be checked, check it yourself rather than ` +
+    `taking either side's word. Deliver:\n` +
+    `- recommendation: the position the asker should act on (it may differ from both sides),\n` +
+    `- survived: the claims that withstood attack,\n` +
+    `- conceded: the points the proposer gave up or clearly lost,\n` +
+    `- open: unresolved questions worth investigating before committing,\n` +
+    `- report: a concise walkthrough of how you weighed it.`,
+  { label: "verdict", phase: "Verdict", schema: VERDICT_SCHEMA },
+)
+
+return { question, proposer: proposer.name, attacker: attacker.name, proposal, transcript, verdict }