@codespar/cli 0.14.0 → 0.16.0

package/templates/bills-agent/agents/bills-agent/src/commands/rerun.ts

@@ -1,65 +0,0 @@
-/**
- * `npm run rerun <run-id> [--json]`: replays a recorded run against the
- * deterministic provider, with no network, in a fresh state, and compares
- * the sequence of states with the original bundle. The model's outputs are
- * the recording; every decision of the core is recomputed.
- */
-import { mkdtempSync, readFileSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { stderr, stdout } from "node:process";
-import { ProofBundle, type ApprovalMode, type Execution } from "@codespar/agent-core";
-import { handleExecution } from "../../channels/terminal/index.js";
-import { runsDir, setup } from "../setup.js";
-
-const argv = process.argv.slice(2);
-const json = argv.includes("--json");
-const runId = argv.find((a) => !a.startsWith("--"));
-const say = (l: string) => stderr.write(l + "\n");
-if (!runId) {
-  say("usage: npm run rerun <run-id> [--json]");
-  process.exit(2);
-}
-const original = ProofBundle.open(runsDir(), runId);
-if (!original) {
-  say(`no bundle at runs/${runId}`);
-  process.exit(1);
-}
-const meta = original.readMeta() ?? {};
-const mode = (meta["mode"] as ApprovalMode | undefined) ?? "human";
-const originalTrail = original
-  .readEvents()
-  .filter((e) => e["type"] === "execution.transition")
-  .map((e) => (e["payload"] as { to: string }).to);
-const originalDecisions = original.readEvents().filter((e) => e["type"] === "approval.created").map((e) => ((e["payload"] as { approver: { type: string } }).approver.type === "person" ? "approve" : "mandate"));
-const userTurns = original.readTranscript().filter((l) => l.kind === "user").map((l) => l["text"] as string);
-// The rail's answers are part of the recording: a payee the rail refused in the original run is refused in the rerun.
-const events = original.readEvents();
-const dispatched = new Map(events.filter((e) => e["type"] === "rail.dispatch").map((e) => [(e["payload"] as { attempt_id: string }).attempt_id, (e["payload"] as { payee: string }).payee]));
-const refusedPayees = events
-  .filter((e) => e["type"] === "rail.outcome" && (e["payload"] as { status: string }).status === "failed")
-  .map((e) => dispatched.get((e["payload"] as { attempt_id: string }).attempt_id))
-  .filter((p): p is string => typeof p === "string");
-const transcriptPath = join(original.dir, "transcript.jsonl");
-readFileSync(transcriptPath, "utf8");
-
-const s = setup({ mode, rail: "stub", provider: "replay", transcript: transcriptPath, runId: `${runId}_rerun_${Date.now().toString(36)}`, stateDir: mkdtempSync(join(tmpdir(), "bills-rerun-")), stubRail: { refusePayees: refusedPayees }, say });
-try {
-  let decisionIndex = 0;
-  const runtime = s.makeRuntime();
-  const loop = s.makeLoop(runtime, (execution: Execution) => {
-    const decision = execution.state === "awaiting_approval" ? (originalDecisions[decisionIndex++] === "approve" ? "approve" : "deny") : "none";
-    return handleExecution(execution, { setup: s, approver: { id: "usr_rerun", channel: "terminal" }, decision, say });
-  });
-  for (const text of userTurns) await loop.turn(text);
-  const trail = s.store.listEvents({ run_id: s.runId }).filter((e) => e.type === "execution.transition").map((e) => (e.payload as { to: string }).to);
-  const outcomesOf = (list: Record<string, unknown>[]) => list.filter((e) => e["type"] === "rail.outcome").map((e) => (e["payload"] as { status: string }).status);
-  const originalOutcomes = outcomesOf(events);
-  const rerunOutcomes = outcomesOf(s.bundle.readEvents());
-  const same = JSON.stringify(trail) === JSON.stringify(originalTrail) && JSON.stringify(rerunOutcomes) === JSON.stringify(originalOutcomes);
-  if (json) stdout.write(JSON.stringify({ run_id: runId, rerun_id: s.runId, same_states: same, original: originalTrail, rerun: trail, original_outcomes: originalOutcomes, rerun_outcomes: rerunOutcomes, bundle_dir: s.bundle.dir }) + "\n");
-  say(same ? `rerun ok: ${trail.length} transition(s), same sequence as ${runId}` : `rerun DIFFERS: original ${JSON.stringify(originalTrail)} vs rerun ${JSON.stringify(trail)}`);
-  process.exit(same ? 0 : 1);
-} finally {
-  s.close();
-}

package/templates/bills-agent/agents/bills-agent/src/commands/resume.ts

@@ -1,30 +0,0 @@
-/**
- * `npm run resume [--json]`: after a crash or a restart. Executions left in
- * `executing` are reconciled against the rail (idempotent on attempt_id),
- * never repeated; stale open ones expire.
- */
-import { stderr, stdout } from "node:process";
-import { readDotEnv, setup } from "../setup.js";
-
-const json = process.argv.includes("--json");
-const say = (l: string) => stderr.write(l + "\n");
-readDotEnv();
-const s = setup({ say, runId: `run_resume_${Date.now().toString(36)}` });
-try {
-  const resumed = [];
-  // Only resume dispatches, and only what the outbox proves was never sent; everything else is reconciled from the rail.
-  for (const stuck of s.engine.list({ state: "executing" })) {
-    const closed = await s.engine.resumePending(stuck.id);
-    resumed.push({ id: closed.id, state: closed.state, detail: closed.detail ?? null, receipt_ids: closed.outcomes.filter((o) => o.receipt_id).map((o) => o.receipt_id) });
-    say(closed.state === "executing" ? `${closed.id}: still executing — ${closed.detail}; nothing was re-sent` : `${closed.id}: executing -> ${closed.state}`);
-  }
-  const expired = s.engine.expireStale().map((e) => ({ id: e.id, state: e.state }));
-  for (const e of expired) say(`${e.id}: -> expired`);
-  const open = s.engine.list({ state: ["awaiting_approval", "approved"] }).map((e) => ({ id: e.id, state: e.state }));
-  for (const e of open) say(`${e.id}: still ${e.state}; decide it with npm run approve ${e.id} / npm run deny ${e.id}`);
-  if (json) stdout.write(JSON.stringify({ resumed, expired, open, bundle_dir: s.bundle.dir }) + "\n");
-  else say(resumed.length || expired.length ? "resume done" : "nothing to resume");
-  process.exit(resumed.some((r) => r.state === "executing") ? 3 : 0);
-} finally {
-  s.close();
-}

package/templates/bills-agent/agents/bills-agent/src/main.ts

@@ -1,185 +0,0 @@
-/**
- * `npm start`                                  interactive terminal
- * `npm start -- --input "pague a escola de outubro"`   one turn, no prompt
- * `npm start -- --scenario happy-path`         a scenario pack, both modes it declares
- *
- * `--json` puts machine data on stdout (valid JSON, nothing else) and the
- * human messages on stderr.
- */
-import { stderr, stdout } from "node:process";
-import { relative, resolve } from "node:path";
-import { NotATestKeyError, isTestKey } from "@codespar/agent-core";
-import { closeTerminal, defaultAsk, handleExecution, interactive } from "../channels/terminal/index.js";
-import { runEmbeddedConsent, loadLocalMandate } from "./modules/embedded-consent.js";
-import { checkScenario, listScenarios, loadScenario, runScenario, scenariosDir } from "./scenarios.js";
-import { AGENT_DIR, MANDATE_PATH, NoMandateError, readDotEnv, resolveRailKind, setup, type RailKind } from "./setup.js";
-import { loadMandate, createCodeSparClient } from "@codespar/agent-core";
-
-interface Args {
-  input?: string;
-  scenario?: string;
-  mode?: "human" | "mandate";
-  json: boolean;
-  decision?: "approve" | "deny";
-  provider?: "anthropic" | "replay";
-  transcript?: string;
-  rail?: RailKind;
-  user: string;
-  help: boolean;
-}
-
-export function parseArgs(argv: string[]): Args {
-  const args: Args = { json: false, user: "usr_terminal", help: false };
-  for (let i = 0; i < argv.length; i += 1) {
-    const a = argv[i]!;
-    const next = () => {
-      const v = argv[i + 1];
-      if (v === undefined) throw new Error(`${a} needs a value`);
-      i += 1;
-      return v;
-    };
-    if (a === "--input") args.input = next();
-    else if (a === "--scenario") args.scenario = next();
-    else if (a === "--mode") {
-      const v = next();
-      if (v !== "human" && v !== "mandate") throw new Error("--mode must be human or mandate");
-      args.mode = v;
-    } else if (a === "--json") args.json = true;
-    else if (a === "--approve") args.decision = "approve";
-    else if (a === "--deny") args.decision = "deny";
-    else if (a === "--provider") {
-      const v = next();
-      if (v !== "anthropic" && v !== "replay") throw new Error("--provider must be anthropic or replay");
-      args.provider = v;
-    } else if (a === "--transcript") args.transcript = next();
-    else if (a === "--rail") {
-      const v = next();
-      if (v !== "stub" && v !== "api") throw new Error("--rail must be stub or api");
-      args.rail = v;
-    } else if (a === "--user") args.user = next();
-    else if (a === "--help" || a === "-h") args.help = true;
-    else throw new Error(`unknown argument ${a}`);
-  }
-  return args;
-}
-
-const USAGE = `bills-agent
-  npm start                                         interactive terminal
-  npm start -- --input "pague a escola de outubro"  one turn (add --approve/--deny to decide, --json for machine output)
-  npm start -- --scenario <name>                    run a scenario pack (${"see scenarios/"})
-options: --mode human|mandate  --provider anthropic|replay  --transcript <file>  --rail stub|api  --user <id>  --json`;
-
-export async function main(argv = process.argv.slice(2)): Promise<number> {
-  let args: Args;
-  try {
-    args = parseArgs(argv);
-  } catch (err) {
-    stderr.write(`${err instanceof Error ? err.message : String(err)}\n${USAGE}\n`);
-    return 2;
-  }
-  if (args.help) {
-    stderr.write(USAGE + "\n");
-    return 0;
-  }
-  readDotEnv();
-  const say = (line: string) => stderr.write(line + "\n");
-
-  if (args.scenario) return runScenarioCommand(args, say);
-
-  // Sandbox by construction: a live key dies here, before anything else runs.
-  const railKind = resolveRailKind(process.env, args.rail);
-  if (railKind === "api" && !isTestKey(process.env["CODESPAR_API_KEY"])) {
-    say(new NotATestKeyError().message);
-    return 1;
-  }
-
-  // Embedded consent: with a test key and no signed mandate, the mandate is born first.
-  if (railKind === "api" && !loadLocalMandate(MANDATE_PATH)) {
-    if (args.input) {
-      say(new NoMandateError().message);
-      return 1;
-    }
-    const api = createCodeSparClient({ apiKey: process.env["CODESPAR_API_KEY"], baseUrl: process.env["CODESPAR_API_URL"], projectId: process.env["CODESPAR_PROJECT_ID"] });
-    const example = loadMandate(resolve(AGENT_DIR, "mandate.example.json"));
-    await runEmbeddedConsent({ api, example, mandatePath: MANDATE_PATH, say, confirm: async (q: string) => /^(s|sim|y|yes)$/i.test((await defaultAsk(q)).trim()) });
-  }
-
-  // One-shot without a model: replay the recorded happy-path when the input is its first turn.
-  let transcript = args.transcript;
-  const provider = args.provider ?? (process.env["ANTHROPIC_API_KEY"] && process.env["ANTHROPIC_API_KEY"] !== "sk-ant-your_key_here" ? "anthropic" : "replay");
-  if (provider === "replay" && !transcript && args.input) {
-    const match = listScenarios().map(loadScenario).find((s) => s.turns[0].input === args.input);
-    if (match) transcript = resolve(scenariosDir(), match.transcript);
-    else {
-      say(`no ANTHROPIC_API_KEY and no recorded transcript for that input. Set the key, pass --transcript, or use one of: ${listScenarios().map((n) => `"${loadScenario(n).turns[0].input}"`).join(", ")}`);
-      return 1;
-    }
-  }
-
-  const s = setup({ mode: args.mode, rail: railKind, provider, transcript, say });
-  const approver = { id: args.user, channel: "terminal" };
-  try {
-    const runtime = s.makeRuntime();
-    if (!args.input) {
-      await interactive({ setup: s, approver, runtime, say });
-      return 0;
-    }
-    const loop = s.makeLoop(runtime, (execution) => handleExecution(execution, { setup: s, approver, decision: args.decision ?? "none", say }));
-    const result = await loop.turn(args.input);
-    const executions = s.engine.list().filter((e) => e.run_id === s.runId);
-    const payload = {
-      run_id: s.runId,
-      agent: `${s.manifest.manifest.name}@${s.manifest.manifest.version}`,
-      mode: s.mode,
-      rail: s.railKind,
-      mandate_id: s.mandate.id,
-      actor: s.engine.agentActor,
-      reply: result.reply,
-      tool_calls: result.tool_calls,
-      executions: executions.map((e) => ({
-        id: e.id,
-        state: e.state,
-        reason: e.reason ?? null,
-        escalation: e.escalation ?? null,
-        total_minor: e.total,
-        items: e.items.map((i) => ({ beneficiary: i.beneficiary, amount_minor: i.amount })),
-        approval_id: e.approval_id ?? null,
-        receipt_ids: e.outcomes.filter((o) => o.receipt_id).map((o) => o.receipt_id),
-      })),
-      receipts: s.bundle.listReceipts().map((f) => relative(process.cwd(), `${s.bundle.dir}/receipts/${f}`)),
-      bundle_dir: relative(process.cwd(), s.bundle.dir),
-    };
-    if (args.json) stdout.write(JSON.stringify(payload) + "\n");
-    else stdout.write(result.reply + "\n");
-    return executions.some((e) => e.state === "executing") ? 3 : 0;
-  } finally {
-    closeTerminal();
-    s.close();
-  }
-}
-
-async function runScenarioCommand(args: Args, say: (l: string) => void): Promise<number> {
-  const scenario = loadScenario(args.scenario!);
-  const modes = args.mode ? [args.mode] : scenario.modes;
-  const results = [];
-  for (const mode of modes) {
-    say(`== scenario ${scenario.name} — approval: ${mode}`);
-    say(scenario.description);
-    const run = await runScenario(scenario, { mode, say: args.json ? () => undefined : say });
-    const check = checkScenario(scenario, run);
-    for (const reply of run.replies) say(`agente: ${reply}`);
-    say(check.ok ? `== ok — bundle em ${relative(process.cwd(), run.bundle_dir)}` : `== FAIL: ${check.failures.join("; ")}`);
-    results.push({ mode, ok: check.ok, failures: check.failures, run });
-  }
-  if (args.json) stdout.write(JSON.stringify({ scenario: scenario.name, results }) + "\n");
-  return results.every((r) => r.ok) ? 0 : 1;
-}
-
-if (process.argv[1] && import.meta.url === new URL(`file://${process.argv[1]}`).href) {
-  main()
-    .then((code) => process.exit(code))
-    .catch((err) => {
-      stderr.write(`${err instanceof Error ? err.stack ?? err.message : String(err)}\n`);
-      process.exit(1);
-    });
-}

package/templates/collections-agent/agents/collections-agent/channels/terminal/index.ts

@@ -1,178 +0,0 @@
-/**
- * The terminal channel: what `npm start` opens. No account, no server. The
- * person typing is the PAYER (in production, over WhatsApp); the operator's
- * approval in `human` mode is asked on the same keyboard, labelled as such.
- * It shows what the core decided, presents the QR and the copy-and-paste
- * when the receivable is payable, and tells the payer the outcome once.
- */
-import { createInterface } from "node:readline/promises";
-import { stdin, stderr, stdout } from "node:process";
-import { relative } from "node:path";
-import qrcode from "qrcode-terminal";
-import type { ChargeInstrument, Execution } from "@codespar/agent-core";
-import { formatBRL, formatDate } from "../../src/agreements.js";
-import { pollUntilClosed, type PollResult } from "../../src/poll.js";
-import type { Setup } from "../../src/setup.js";
-
-export interface TerminalOptions {
-  setup: Setup;
-  approver: { id: string; channel: string };
-  /** Non-interactive decision for `--input`: approve, deny, or leave it awaiting. */
-  decision?: "approve" | "deny" | "none";
-  /** Seconds to wait for the payer after issuing. */
-  waitSeconds?: number | undefined;
-  /** Let the sandbox payer (the fixture, or the API's test route) pay once the receivable is payable. */
-  simulatePayer?: boolean | undefined;
-  say?: ((line: string) => void) | undefined;
-  ask?: ((question: string) => Promise<string>) | undefined;
-  /** Where the lines for the PAYER go (the conversation); `say` is the operator's console. */
-  tell?: ((line: string) => void) | undefined;
-}
-
-export function describeExecution(execution: Execution, setup: Setup): string[] {
-  const lines: string[] = [];
-  const debtor = execution.items[0]?.beneficiary ?? "?";
-  lines.push(`  execucao ${execution.id}: ${execution.state}${execution.reason ? ` (${execution.reason})` : ""}`);
-  lines.push(`    acordo de ${debtor} (${execution.items[0]?.alias ?? "?"})`);
-  for (const [i, item] of execution.items.entries()) lines.push(`    - parcela ${i + 1}/${execution.items.length}: ${formatBRL(item.amount)}, vence ${item.due_date ? formatDate(item.due_date) : "?"}`);
-  lines.push(`    total (calculado pelo core): ${formatBRL(execution.total)}`);
-  if (execution.escalation) lines.push(`    escalado por: ${execution.escalation.trigger} — ${execution.escalation.detail}`);
-  if (execution.blocking_reasons.length) lines.push(`    bloqueado: ${execution.blocking_reasons.join(", ")} — a politica nao autoriza; nao ha o que aprovar`);
-  if (execution.detail && execution.state !== "awaiting_approval") lines.push(`    ${execution.detail}`);
-  for (const outcome of execution.outcomes) {
-    if (outcome.transaction_id) lines.push(`    cobranca ${outcome.index + 1}: ${outcome.transaction_id} — ${outcome.status}${outcome.code ? ` (${outcome.code})` : ""}`);
-    if (outcome.receipt_id) lines.push(`    registro: ${relative(process.cwd(), `${setup.bundle.dir}/receipts/${outcome.receipt_id}.json`)}`);
-  }
-  return lines;
-}
-
-/** What the payer reads when a receivable is payable: the QR as an image, the copy-and-paste under it, the bank line if any. */
-export function presentInstrument(execution: Execution, instalment: number, chargeId: string, instrument: ChargeInstrument, tell: (line: string) => void): void {
-  const item = execution.items[instalment - 1];
-  const count = execution.items.length;
-  tell("");
-  tell(`${count > 1 ? `Parcela ${instalment}/${count}: ` : ""}${item ? formatBRL(item.amount) : ""}${instrument.due_date ? `, vence ${formatDate(instrument.due_date)}` : ""} — cobranca ${chargeId}`);
-  if (instrument.pix_copy_paste) {
-    qrcode.generate(instrument.pix_copy_paste, { small: true }, (qr: string) => {
-      for (const line of qr.split("\n")) tell(line);
-    });
-    tell("Pix copia e cola:");
-    tell(instrument.pix_copy_paste);
-  }
-  if (instrument.boleto_bank_line) {
-    tell("Ou pelo boleto, linha digitavel:");
-    tell(instrument.boleto_bank_line);
-  }
-  tell("");
-}
-
-/** The one message per outcome, recorded so a duplicate event never sends it twice. */
-export function announceOutcome(execution: Execution, setup: Setup, tell: (line: string) => void): boolean {
-  if (execution.state === "executing") return false;
-  if (!setup.engine.markTold(execution.id, execution.state)) return false;
-  let text: string;
-  if (execution.state === "settled") text = `Recebemos, acordo quitado. Obrigado! (${execution.outcomes.map((o) => o.transaction_id).filter(Boolean).join(", ")})`;
-  else if (execution.reason === "charge_expired") text = "A cobranca venceu sem pagamento. Se quiser, emito uma nova dentro das mesmas condicoes.";
-  else if (execution.reason === "charge_cancelled") text = "A cobranca foi cancelada. Nada foi pago.";
-  else if (execution.state === "failed") text = `Nao consegui emitir a cobranca (${execution.reason ?? "falha no trilho"}). Nada foi cobrado.`;
-  else if (execution.state === "denied") text = `Nao posso emitir nesses termos (${execution.reason ?? "recusado"}).`;
-  else text = `A proposta expirou sem decisao (${execution.state}).`;
-  tell(text);
-  setup.engine.note("message.debtor", execution.id, { state: execution.state, reason: execution.reason ?? null, text });
-  return true;
-}
-
-/** Decides an `awaiting_approval` execution, runs an `approved` one, and waits for the payer. Returns the final execution of this pass. */
-export async function handleExecution(execution: Execution, options: TerminalOptions): Promise<Execution> {
-  const { setup, approver } = options;
-  const say = options.say ?? ((l: string) => stderr.write(l + "\n"));
-  const tell = options.tell ?? ((l: string) => stdout.write(l + "\n"));
-  const engine = setup.engine;
-
-  for (const line of describeExecution(execution, setup)) say(line);
-
-  let current = execution;
-  if (current.state === "awaiting_approval") {
-    let decision = options.decision;
-    if (!decision) {
-      if (current.blocking_reasons.length > 0) say("  (o unico desfecho possivel e negar; aperte Enter)");
-      const ask = options.ask ?? defaultAsk;
-      const answer = (await ask("  [operador] Aprovar a emissao desta cobranca? [s/N] ")).trim().toLowerCase();
-      decision = answer === "s" || answer === "sim" || answer === "y" || answer === "yes" ? "approve" : "deny";
-    }
-    if (decision === "approve") current = engine.approve(current.id, approver);
-    else if (decision === "deny") current = engine.deny(current.id, approver);
-    else {
-      say("  deixado em awaiting_approval (rode de novo com --approve ou --deny)");
-      return current;
-    }
-    say(`  -> ${current.state}${current.reason ? ` (${current.reason})` : ""}`);
-  }
-
-  if (current.state === "approved") {
-    current = await engine.execute(current.id);
-    say(`  -> ${current.state}${current.reason ? ` (${current.reason})` : ""}`);
-  }
-
-  if (current.state === "executing" && current.reason === "awaiting_settlement") {
-    const result = await waitForPayer(current.id, options);
-    current = result.execution;
-    say(`  -> ${current.state}${current.reason ? ` (${current.reason})` : ""} apos ${result.rounds} consulta(s), ${result.seconds}s${result.timed_out ? " (tempo esgotado; `npm run poll` continua de onde parou)" : ""}`);
-    for (const outcome of current.outcomes) if (outcome.receipt_id) say(`  registro: ${relative(process.cwd(), `${setup.bundle.dir}/receipts/${outcome.receipt_id}.json`)}`);
-  } else if (current.state === "executing") {
-    say("  desfecho desconhecido no trilho; rode `npm run resume` para reconciliar (nunca repita a emissao)");
-  }
-  announceOutcome(current, setup, tell);
-  return current;
-}
-
-export async function waitForPayer(executionId: string, options: TerminalOptions): Promise<PollResult> {
-  const { setup } = options;
-  const say = options.say ?? ((l: string) => stderr.write(l + "\n"));
-  const tell = options.tell ?? ((l: string) => stdout.write(l + "\n"));
-  const waitSeconds = options.waitSeconds ?? (setup.railKind === "api" ? 60 : 0);
-  return pollUntilClosed(setup.engine, executionId, {
-    intervalMs: setup.pollIntervalMs,
-    timeoutMs: waitSeconds * 1000,
-    payer: options.simulatePayer ? setup.payer : undefined,
-    onInstrument: (e, n, id, instrument) => presentInstrument(e, n, id, instrument, tell),
-    onWait: (_e, round) => {
-      if (setup.railKind === "api" && round % 5 === 0) say(`  aguardando o pagador... (${round} consultas)`);
-    },
-  });
-}
-
-let rl: ReturnType<typeof createInterface> | undefined;
-
-export function defaultAsk(question: string): Promise<string> {
-  rl ??= createInterface({ input: stdin, output: stderr });
-  return rl.question(question);
-}
-
-export function closeTerminal(): void {
-  rl?.close();
-  rl = undefined;
-}
-
-export async function interactive(options: TerminalOptions & { runtime: import("@codespar/agent-core").AgentRuntime }): Promise<void> {
-  const { setup } = options;
-  const say = options.say ?? ((l: string) => stderr.write(l + "\n"));
-  const loop = setup.makeLoop(options.runtime, (execution) => handleExecution(execution, options));
-  say(`collections-agent ${setup.manifest.manifest.version} — approval: ${setup.mode} — trilho: ${setup.railKind} — politica ${setup.mandate.id}`);
-  say(`run ${setup.runId} — bundle em ${relative(process.cwd(), setup.bundle.dir)}`);
-  say('Voce e o pagador. Diga algo ("oi, recebi a mensagem sobre o acordo do pedido 1042"). Ctrl+D ou "sair" encerra.');
-  for (;;) {
-    let text: string;
-    try {
-      text = await defaultAsk("pagador> ");
-    } catch {
-      break;
-    }
-    const trimmed = text.trim();
-    if (!trimmed) continue;
-    if (["sair", "exit", "quit"].includes(trimmed.toLowerCase())) break;
-    const result = await loop.turn(trimmed);
-    stdout.write(result.reply + "\n");
-  }
-  closeTerminal();
-}

package/templates/collections-agent/agents/collections-agent/src/commands/approve.ts

@@ -1,10 +0,0 @@
-/**
- * `npm run approve <execution-id> [--user <id>] [--json]`: decides an
- * execution left in `awaiting_approval` (a `--input` run without
- * `--approve`, a restart). Produces the section 4.2 artifact and runs the
- * execution through the same last gate `npm start` uses, then waits for the
- * payer (`--wait`, `--simulate-payer`).
- */
-import { decideFromCli } from "./decide.js";
-
-await decideFromCli("approve");

package/templates/collections-agent/agents/collections-agent/src/commands/check.ts

@@ -1,13 +0,0 @@
-/**
- * `npm run check [--json]`: the manifest-coherence gate of section 4.3.
- */
-import { stderr, stdout } from "node:process";
-import { checkAgent } from "@codespar/agent-core";
-import { AGENT_DIR } from "../setup.js";
-
-const json = process.argv.includes("--json");
-const report = checkAgent(AGENT_DIR);
-if (json) stdout.write(JSON.stringify(report) + "\n");
-for (const f of report.findings) stderr.write(`${f.level === "error" ? "ERROR" : "warn "} ${f.code}: ${f.message}\n`);
-stderr.write(report.ok ? `check ok: ${report.agent} agrees with its agent.yaml\n` : `check FAILED for ${report.agent ?? "agent"}\n`);
-process.exit(report.ok ? 0 : 1);

package/templates/collections-agent/agents/collections-agent/src/commands/decide.ts

@@ -1,48 +0,0 @@
-import { relative } from "node:path";
-import { stderr, stdout } from "node:process";
-import { handleExecution } from "../../channels/terminal/index.js";
-import { readDotEnv, setup } from "../setup.js";
-
-export async function decideFromCli(decision: "approve" | "deny"): Promise<never> {
-  const argv = process.argv.slice(2);
-  const json = argv.includes("--json");
-  const user = argv.includes("--user") ? argv[argv.indexOf("--user") + 1] : undefined;
-  const wait = argv.includes("--wait") ? Number(argv[argv.indexOf("--wait") + 1]) : undefined;
-  const simulatePayer = argv.includes("--simulate-payer");
-  const executionId = argv.find((a, i) => !a.startsWith("--") && argv[i - 1] !== "--user" && argv[i - 1] !== "--wait");
-  const say = (l: string) => stderr.write(l + "\n");
-  if (!executionId) {
-    say(`usage: npm run ${decision} <execution-id> [--user <id>] [--wait <seconds>] [--simulate-payer] [--json]`);
-    process.exit(2);
-  }
-  readDotEnv();
-  const s = setup({ say, runId: `run_${decision}_${Date.now().toString(36)}` });
-  try {
-    const execution = s.engine.get(executionId);
-    if (!execution) {
-      say(`unknown execution ${executionId}`);
-      process.exit(1);
-    }
-    if (execution.state !== "awaiting_approval") {
-      say(`${executionId} is ${execution.state}, not awaiting_approval; nothing to decide`);
-      process.exit(1);
-    }
-    const final = await handleExecution(execution, { setup: s, approver: { id: user ?? "usr_operator", channel: "terminal" }, decision, say, tell: json ? say : undefined, waitSeconds: wait, simulatePayer });
-    if (json) {
-      stdout.write(
-        JSON.stringify({
-          execution_id: final.id,
-          state: final.state,
-          reason: final.reason ?? null,
-          approval_id: final.approval_id ?? null,
-          charge_ids: final.outcomes.map((o) => o.transaction_id ?? null),
-          receipt_ids: final.outcomes.filter((o) => o.receipt_id).map((o) => o.receipt_id),
-          bundle_dir: relative(process.cwd(), s.bundle.dir),
-        }) + "\n",
-      );
-    }
-    process.exit(final.state === "executing" && final.reason !== "awaiting_settlement" ? 3 : 0);
-  } finally {
-    s.close();
-  }
-}

package/templates/collections-agent/agents/collections-agent/src/commands/deny.ts

@@ -1,7 +0,0 @@
-/**
- * `npm run deny <execution-id> [--user <id>] [--json]`: denies an execution
- * left in `awaiting_approval`. Terminal; nothing is issued.
- */
-import { decideFromCli } from "./decide.js";
-
-await decideFromCli("deny");

package/templates/collections-agent/agents/collections-agent/src/commands/eval.ts

@@ -1,39 +0,0 @@
-/**
- * `npm run eval [--json] [--case <name>]`: the adversarial suite of section 9
- * plus every scenario of section 12 in every mode it declares. Runs on the
- * replay provider and the stub rail, with no model and no network. A
- * regression blocks merge.
- */
-import { stderr, stdout } from "node:process";
-import { listAdversarialCases, loadAdversarialCase, runAdversarialCase } from "../adversarial.js";
-import { checkScenario, listScenarios, loadScenario, runScenario } from "../scenarios.js";
-
-const argv = process.argv.slice(2);
-const json = argv.includes("--json");
-const only = argv.includes("--case") ? argv[argv.indexOf("--case") + 1] : undefined;
-const say = (l: string) => stderr.write(l + "\n");
-
-const adversarial = [];
-for (const name of listAdversarialCases()) {
-  if (only && only !== name) continue;
-  const result = await runAdversarialCase(loadAdversarialCase(name));
-  adversarial.push(result);
-  say(`${result.ok ? "ok  " : "FAIL"} adversarial/${name} — ${result.attack} — states ${JSON.stringify(result.states)}${result.failures.length ? ` — ${result.failures.join("; ")}` : ""}`);
-}
-
-const scenarios = [];
-for (const name of listScenarios()) {
-  if (only && only !== name) continue;
-  const scenario = loadScenario(name);
-  if (!scenario.rails.includes("stub")) continue;
-  for (const mode of scenario.modes) {
-    const check = checkScenario(scenario, await runScenario(scenario, { mode, rail: "stub" }));
-    scenarios.push({ name, mode, ok: check.ok, failures: check.failures, states: check.run.executions.map((e) => e.state), receipts: check.run.receipts, charges_issued: check.run.charges_issued, debtor_messages: check.run.debtor_messages });
-    say(`${check.ok ? "ok  " : "FAIL"} scenario/${name} [${mode}] — states ${JSON.stringify(check.run.executions.map((e) => e.state))}, ${check.run.charges_issued} charge(s), ${check.run.receipts} record(s), ${check.run.debtor_messages} message(s)${check.failures.length ? ` — ${check.failures.join("; ")}` : ""}`);
-  }
-}
-
-const ok = adversarial.every((r) => r.ok) && scenarios.every((r) => r.ok);
-if (json) stdout.write(JSON.stringify({ ok, adversarial, scenarios }) + "\n");
-say(ok ? `eval ok: ${adversarial.length} adversarial case(s), ${scenarios.length} scenario run(s)` : "eval FAILED");
-process.exit(ok ? 0 : 1);

package/templates/collections-agent/agents/collections-agent/src/commands/poll.ts

@@ -1,35 +0,0 @@
-/**
- * `npm run poll [--wait <seconds>] [--simulate-payer] [--json]`: keeps
- * looking at every receivable still waiting for its payer until it closes
- * or the wait runs out. This is the loop-closer for a terminal that has no
- * webhook URL; `npm run webhook` is the other. Presents an instrument not yet
- * shown, tells the payer the outcome once, fetches the paid record.
- */
-import { stderr, stdout } from "node:process";
-import { announceOutcome, waitForPayer } from "../../channels/terminal/index.js";
-import { readDotEnv, setup } from "../setup.js";
-
-const argv = process.argv.slice(2);
-const json = argv.includes("--json");
-const wait = argv.includes("--wait") ? Number(argv[argv.indexOf("--wait") + 1]) : undefined;
-const simulatePayer = argv.includes("--simulate-payer");
-const say = (l: string) => stderr.write(l + "\n");
-const tell = (l: string) => (json ? stderr : stdout).write(l + "\n");
-readDotEnv();
-const s = setup({ say, runId: `run_poll_${Date.now().toString(36)}` });
-try {
-  const results = [];
-  for (const open of s.engine.list({ state: "executing" })) {
-    if (open.reason !== "awaiting_settlement") continue;
-    const r = await waitForPayer(open.id, { setup: s, approver: { id: "usr_operator", channel: "terminal" }, say, tell, waitSeconds: wait, simulatePayer });
-    announceOutcome(r.execution, s, tell);
-    if (r.execution.state !== "executing") await s.engine.collectReceipts(r.execution.id);
-    results.push({ id: r.execution.id, state: r.execution.state, reason: r.execution.reason ?? null, rounds: r.rounds, seconds: r.seconds, timed_out: r.timed_out });
-    say(`${r.execution.id}: ${r.execution.state}${r.execution.reason ? ` (${r.execution.reason})` : ""} after ${r.rounds} look(s), ${r.seconds}s`);
-  }
-  if (json) stdout.write(JSON.stringify({ polled: results }) + "\n");
-  else if (!results.length) say("nothing waiting for a payer");
-  process.exit(results.some((r) => r.timed_out) ? 3 : 0);
-} finally {
-  s.close();
-}