Go further with your review task

import { task } from "@renderinc/sdk/workflows";
import { REVIEWERS, judge, parseDecision, type Patch } from "@workshop/agent";
import { storeTracer } from "@workshop/db";

const judgeTask = task(
  { name: "judge", timeoutSeconds: 120 },
  async (input: Record<string, unknown>) => judge.run(input, { tracer: storeTracer() }),
);

// Fan out the reviewers, then pair each result with its agent name.
const results = await Promise.all(
  REVIEWERS.map((agent) =>
    task(
      { name: agent.name },
      async (input: { patches: Patch[] }) => agent.run(input, { tracer: storeTracer() }),
    )({ patches: filtered.patches }),
  ),
);
const findings = REVIEWERS.map((agent, i) => ({ agent: agent.name, note: results[i].text }));

// Draft, then reflect: the judge sees its own prior verdict each pass.
let decision = parseDecision((await judgeTask({ findings })).text);
for (let pass = 0; pass < 2; pass++) {
  const reflected = await judgeTask({
    findings,
    previousVerdict: decision,
    instruction: "Critique your previous verdict and revise if needed. Return the same JSON shape.",
  });
  const next = parseDecision(reflected.text);
  if (next.verdict === decision.verdict && next.reason === decision.reason) break;
  decision = next;
}

import asyncio

from render_sdk import Workflows
from workshop_agent import REVIEWERS, judge, parse_decision
from workshop_agent.types import RunContext
from workshop_db import store_tracer

app = Workflows()

@app.task(name="judge", timeout_seconds=120)
async def judge_task(input: dict) -> dict:
    ctx = RunContext(tracer=store_tracer())
    result = await judge.run(input, ctx)
    return {
        "text": result.text,
        "usage": {
            "input_tokens": result.usage.input_tokens,
            "output_tokens": result.usage.output_tokens,
        },
    }

# Fan out the reviewers, then pair each result with its agent name.
ctx = RunContext(tracer=store_tracer())
results = await asyncio.gather(*[
    agent.run({"patches": patches}, ctx) for agent in REVIEWERS
])
findings = [{"agent": agent.name, "note": results[i].text} for i, agent in enumerate(REVIEWERS)]

# Draft, then reflect: the judge sees its own prior verdict each pass.
decision = parse_decision((await judge_task({"findings": findings}))["text"])
for _ in range(2):
    reflected = await judge_task({
        "findings": findings,
        "previousVerdict": {"verdict": decision.verdict, "reason": decision.reason},
        "instruction": "Critique your previous verdict and revise if needed. Return the same JSON shape.",
    })
    next_decision = parse_decision(reflected["text"])
    if next_decision.verdict == decision.verdict and next_decision.reason == decision.reason:
        break
    decision = next_decision

import { defineMcpSource } from "./tool.js";

// Stdio transport: the registry spawns this command and connects over stdio.
// Tools are auto-namespaced as `docs__<toolName>`.
export default defineMcpSource({
  id: "docs",
  command: "npx",
  args: ["-y", "@modelcontextprotocol/server-filesystem", process.cwd()],
});

from workshop_agent.tools.tool import McpSourceSpec, define_mcp_source

# Stdio transport: the registry spawns this command and connects over stdio.
# Tools are auto-namespaced as `docs__<toolName>`.
source = define_mcp_source(McpSourceSpec(
    id="docs",
    command="npx",
    args=["-y", "@modelcontextprotocol/server-filesystem", "."],
))

// Phase 1 - propose. A deterministic gate decides if a human is needed.
const decision = parseDecision((await judgeTask({ findings })).text);
const needsHuman =
  decision.verdict === "request-changes" ||
  decision.findings.some((f) => f.severity === "block");

if (needsHuman) {
  await savePendingApproval(input.url, decision); // park it durably
  return { status: "awaiting-approval", verdict: decision.verdict };
}
return { status: "auto-approved", verdict: decision.verdict };

// Phase 2 - a separate task (or webhook) the human triggers to resolve it:
//   resolveApproval(url, "approve" | "reject") -> finalize and act.

# Phase 1 - propose. A deterministic gate decides if a human is needed.
decision = parse_decision((await judge_task({"findings": findings}))["text"])
needs_human = (
    decision.verdict == "request-changes"
    or any(f.get("severity") == "block" for f in decision.findings)
)

if needs_human:
    await save_pending_approval(url, decision)  # park it durably
    return {"status": "awaiting-approval", "verdict": decision.verdict}
return {"status": "auto-approved", "verdict": decision.verdict}

# Phase 2 - a separate task (or webhook) the human triggers to resolve it:
#   resolve_approval(url, "approve" | "reject") -> finalize and act.

// Minimal store. Swap the Map for a pending_approvals table for real durability.
const pendingApprovals = new Map<string, unknown>();

async function savePendingApproval(url: string, decision: unknown): Promise<void> {
  pendingApprovals.set(url, decision);
}

async function resolveApproval(url: string, action: "approve" | "reject"): Promise<unknown> {
  const decision = pendingApprovals.get(url);
  pendingApprovals.delete(url);
  return { url, action, decision };
}

# Minimal store. Swap the dict for a pending_approvals table for real durability.
_pending_approvals: dict[str, dict] = {}

async def save_pending_approval(url: str, decision: dict) -> None:
    _pending_approvals[url] = decision

async def resolve_approval(url: str, action: str) -> dict:
    decision = _pending_approvals.pop(url, None)
    return {"url": url, "action": action, "decision": decision}