amness 0.0.0-stage → 0.1.2

package/dist/cli/ui.js

@@ -0,0 +1,224 @@
+// Tiny zero-dependency terminal UI: colors, boxes, arrow-key menus, prompts, spinner. Falls back to plain line input when piped.
+import { createInterface, emitKeypressEvents } from "node:readline";
+const color = (!!process.stdout.isTTY || !!process.env.FORCE_COLOR) && !process.env.NO_COLOR;
+const sgr = (code) => (s) => (color ? `\x1b[${code}m${s}\x1b[0m` : s);
+export const bold = sgr("1"), dim = sgr("2"), red = sgr("31"), green = sgr("32"), yellow = sgr("33"), blue = sgr("34"), magenta = sgr("35"), cyan = sgr("36"), gray = sgr("90");
+export const strip = (s) => s.replace(/\x1b\[[0-9;?]*[A-Za-z]/g, "");
+export const width = () => Math.min(process.stdout.columns || 80, 100);
+/** Word-wrap one line (ANSI-aware) to `w` visible columns; continuation lines are indented 2 spaces. */
+export function wrap(line, w) {
+    if (strip(line).length <= w)
+        return [line];
+    const reset = color ? "\x1b[0m" : "";
+    const out = [];
+    let cur = "", vis = 0, lastSpace = -1;
+    for (const t of line.match(/\x1b\[[0-9;?]*[A-Za-z]|[^\x1b]/g) ?? []) {
+        if (t[0] === "\x1b") {
+            cur += t;
+            continue;
+        }
+        if (vis >= w) {
+            const cut = lastSpace > 0 ? lastSpace : cur.length;
+            out.push(cur.slice(0, cut) + reset);
+            cur = "  " + cur.slice(lastSpace > 0 ? cut + 1 : cut);
+            vis = strip(cur).length;
+            lastSpace = -1;
+        }
+        if (t === " ")
+            lastSpace = cur.length;
+        cur += t;
+        vis++;
+    }
+    out.push(cur);
+    return out;
+}
+export function box(input, paint = cyan, title = "") {
+    const w = Math.min(Math.max(...input.map((l) => strip(l).length), strip(title).length + 2), width() - 4);
+    const lines = input.flatMap((l) => wrap(l, w));
+    const top = title ? `╭─ ${title} ${"─".repeat(Math.max(0, w - strip(title).length - 1))}╮` : `╭${"─".repeat(w + 2)}╮`;
+    return [paint(top), ...lines.map((l) => paint("│ ") + l + " ".repeat(Math.max(0, w - strip(l).length)) + paint(" │")), paint(`╰${"─".repeat(w + 2)}╯`)].join("\n");
+}
+// ---- line input shared by all prompts when stdin is not a TTY (piped / tests)
+let lineIter;
+const nextLine = async () => ((lineIter ??= createInterface({ input: process.stdin })[Symbol.asyncIterator]()), (await lineIter.next()).value);
+const isTTY = () => !!process.stdin.isTTY && !!process.stdout.isTTY;
+/** Thrown when the user presses Esc inside a text prompt; screens let it bubble up to the menu. */
+export class Cancel extends Error {
+    constructor() { super("cancelled"); }
+}
+/**
+ * Arrow-key menu. ↑/↓ or j/k move, 1-9 jump, enter selects, esc goes back, "/" filters long lists, "?" toggles help.
+ * Long lists scroll inside the terminal height. Returns undefined on back.
+ */
+export async function select(title, items, initial = 0) {
+    if (!isTTY()) {
+        console.log(`\n${bold(title)}`);
+        items.forEach((it, i) => console.log(`  ${i + 1}. ${it.label}${it.hint ? "  " + dim(it.hint) : ""}`));
+        const a = (await nextLine())?.trim();
+        return a ? items[Number(a) - 1]?.value : undefined;
+    }
+    const out = process.stdout, inp = process.stdin;
+    let cur = Math.min(initial, items.length - 1), top = 0, drawn = 0, filter = "", filtering = false, help = false;
+    const vis = () => { const f = filter.toLowerCase(); return f ? items.filter((i) => `${i.label} ${i.hint ?? ""}`.toLowerCase().includes(f)) : items; };
+    const draw = () => {
+        if (drawn)
+            out.write(`\x1b[${drawn}A\x1b[J`);
+        const list = vis(), room = Math.max(4, (out.rows || 24) - 7);
+        cur = Math.max(0, Math.min(cur, list.length - 1));
+        if (cur < top)
+            top = cur;
+        if (cur >= top + room)
+            top = cur - room + 1;
+        const slice = list.slice(top, top + room), labelW = Math.max(0, ...slice.map((i) => strip(i.label).length));
+        const rows = [
+            bold(title) + (filtering || filter ? "  " + cyan("/") + filter + (filtering ? cyan("▌") : "") : ""),
+            ...(top > 0 ? [dim(`  ↑ ${top} more`)] : []),
+            ...slice.map((it, k) => {
+                const on = top + k === cur, pad = " ".repeat(labelW - strip(it.label).length);
+                return (on ? cyan("❯ ") + bold(cyan(it.label)) : "  " + it.label) + pad + (it.hint ? "  " + (on ? gray(it.hint) : dim(it.hint)) : "");
+            }),
+            ...(top + room < list.length ? [dim(`  ↓ ${list.length - top - room} more`)] : []),
+            ...(list.length ? [] : [dim("  no matches")]),
+            dim(help ? "  ↑/↓ j/k move · 1-9 jump · enter select · esc back · / filter · ? hide help · ctrl-c quit"
+                : filtering ? "  type to filter · enter select · esc clear filter" : "  ↑/↓ move · enter select · esc back" + (items.length > 6 ? " · / filter" : "") + " · ? help"),
+        ];
+        out.write(rows.map((r) => r.slice(0, Math.max(20, (out.columns || 80) + 20))).join("\n") + "\n");
+        drawn = rows.length;
+    };
+    emitKeypressEvents(inp);
+    inp.setRawMode(true);
+    inp.resume();
+    out.write("\x1b[?25l");
+    draw();
+    return new Promise((resolve) => {
+        const done = (v) => {
+            inp.off("keypress", onKey);
+            inp.setRawMode(false);
+            inp.pause();
+            out.write("\x1b[?25h");
+            out.write(`\x1b[${drawn}A\x1b[J${bold(title)} ${v === undefined ? dim("(back)") : cyan(items.find((i) => i.value === v).label)}\n`);
+            resolve(v);
+        };
+        const onKey = (s, k) => {
+            const list = vis();
+            if (k.ctrl && k.name === "c") {
+                inp.setRawMode(false);
+                out.write("\x1b[?25h\n");
+                process.exit(130);
+            }
+            if (filtering) {
+                if (k.name === "return")
+                    return list.length ? done(list[cur].value) : draw();
+                if (k.name === "escape") {
+                    filtering = false;
+                    filter = "";
+                    cur = 0;
+                }
+                else if (k.name === "backspace")
+                    filter = filter.slice(0, -1);
+                else if (k.name === "up")
+                    cur--;
+                else if (k.name === "down")
+                    cur++;
+                else if (s && s >= " " && !k.ctrl) {
+                    filter += s;
+                    cur = 0;
+                }
+                return draw();
+            }
+            if (k.name === "up" || s === "k")
+                cur = (cur + list.length - 1) % list.length;
+            else if (k.name === "down" || s === "j")
+                cur = (cur + 1) % list.length;
+            else if (k.name === "return")
+                return done(list[cur]?.value);
+            else if (k.name === "escape" || s === "q") {
+                if (filter) {
+                    filter = "";
+                    cur = 0;
+                }
+                else
+                    return done(undefined);
+            }
+            else if (s === "/" && items.length > 6) {
+                filtering = true;
+                filter = "";
+            }
+            else if (s === "?")
+                help = !help;
+            else if (s && /^[1-9]$/.test(s) && list[Number(s) - 1])
+                return done(list[Number(s) - 1].value);
+            draw();
+        };
+        inp.on("keypress", onKey);
+    });
+}
+/**
+ * Text prompt. Esc cancels (throws Cancel), up/down recall `history`, and pasted multi-line text arrives as ONE answer
+ * instead of leaking into later prompts. With `multiline`, newlines in a paste are kept; otherwise they become spaces.
+ */
+export async function ask(prompt, def = "", o = {}) {
+    const q = `${cyan("?")} ${bold(prompt)}${def ? " " + dim(`(${o.secret ? "set" : def})`) : ""} ${cyan("›")} `;
+    if (!isTTY()) {
+        process.stdout.write(q + "\n");
+        return (await nextLine())?.trim() || def;
+    }
+    const rl = createInterface({ input: process.stdin, output: process.stdout, terminal: true, escapeCodeTimeout: 40, history: o.history ? [...o.history] : undefined, historySize: 100 });
+    if (o.secret) {
+        const w = rl._writeToOutput;
+        rl._writeToOutput = (s) => { if (s.includes(q))
+            w.call(rl, s); };
+    }
+    return new Promise((resolve, reject) => {
+        const lines = [];
+        let timer, settled = false;
+        const finish = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer); // settle first: rl.close() fires the "close" handler below
+            process.stdin.off("keypress", onKey);
+            rl.close();
+            if (o.secret)
+                process.stdout.write("\n");
+            err ? reject(err) : resolve(lines.join(o.multiline ? "\n" : " ").trim() || def);
+        };
+        const onKey = (_s, k) => { if (k?.name === "escape") {
+            process.stdout.write("\n");
+            finish(new Cancel());
+        } };
+        process.stdin.on("keypress", onKey);
+        // a paste delivers several lines in one tick; collect them before answering
+        rl.on("line", (l) => { lines.push(l); clearTimeout(timer); timer = setTimeout(() => finish(), 25); });
+        rl.on("close", () => finish()); // e.g. Ctrl-D: answer with what we have
+        rl.setPrompt(q);
+        rl.prompt();
+    });
+}
+export const confirm = async (q, def = false) => (await select(q, [{ label: "Yes", value: true }, { label: "No", value: false }], def ? 0 : 1)) ?? false;
+export const pause = async () => { try {
+    await ask(dim("press enter to continue"), "");
+}
+catch (e) {
+    if (!(e instanceof Cancel))
+        throw e;
+} };
+export const clearScreen = () => { if (process.stdout.isTTY)
+    process.stdout.write("\x1b[2J\x1b[H"); };
+// ---- trace output + ref-counted spinner (parallel model calls share one spinner). The label may be a live function.
+const frames = "⠋⠙⠹⠸⠼⠴⠦⠧⠇⠏";
+let spinners = 0, timer, frame = 0, label = "";
+export function log(line = "") { process.stderr.write(process.stderr.isTTY ? `\r\x1b[2K${line}\n` : line + "\n"); }
+export function spin(text) {
+    if (!process.stderr.isTTY)
+        return () => { };
+    label = text;
+    if (spinners++ === 0)
+        timer = setInterval(() => process.stderr.write(`\r\x1b[2K${cyan(frames[frame++ % frames.length])} ${dim(typeof label === "function" ? label() : label)}`), 100);
+    let stopped = false;
+    return () => { if (stopped)
+        return; stopped = true; if (--spinners === 0) {
+        clearInterval(timer);
+        process.stderr.write("\r\x1b[2K");
+    } };
+}

package/dist/src/acp.d.ts

@@ -0,0 +1,28 @@
+import type { Readable, Writable } from "node:stream";
+import type { Approve, Event, Message } from "./harness.ts";
+export type AcpAgent = {
+    chat: (history: Message[], text: string, extra?: {
+        images?: {
+            mime: string;
+            data: string;
+        }[];
+    }) => Promise<{
+        messages: Message[];
+        text: string;
+        stopped?: string;
+        finished: boolean;
+    }>;
+};
+export type AcpOptions = {
+    input: Readable;
+    output: Writable;
+    version: string;
+    /** Build an agent for a session. `onEvent` and `approve` must be wired into it; `signal` is aborted by session/cancel. */
+    makeAgent: (s: {
+        cwd: string;
+        onEvent: (e: Event) => void;
+        approve: Approve;
+        signal: () => AbortSignal | undefined;
+    }) => AcpAgent;
+};
+export declare function serveAcp(o: AcpOptions): Promise<void>;

package/dist/src/acp.js

@@ -0,0 +1,111 @@
+// Agent Client Protocol server: lets an editor (Zed, JetBrains, ...) host Amness as its coding agent. JSON-RPC 2.0, one JSON message per line over stdio.
+// Implemented: initialize, session/new, session/prompt (streams text and tool calls back as session/update), session/cancel, and session/request_permission for risky calls.
+// Not implemented: session/load, authenticate, fs/* and terminal/* (Amness reads and runs things itself), non-text prompt content other than images and embedded resources.
+import { createInterface } from "node:readline";
+const KIND = { read_file: "read", list_dir: "read", grep: "search", find_refs: "search", repo_map: "search", write_file: "edit", edit_file: "edit", apply_patch: "edit", sh: "execute", sh_start: "execute", web_fetch: "fetch", web_search: "fetch" };
+export function serveAcp(o) {
+    const send = (m) => o.output.write(JSON.stringify({ jsonrpc: "2.0", ...m }) + "\n");
+    const sessions = new Map();
+    const waiting = new Map();
+    let nextId = 1, n = 0;
+    const call = (method, params) => new Promise((res) => { const id = nextId++; waiting.set(id, res); send({ id, method, params }); });
+    const update = (sessionId, u) => send({ method: "session/update", params: { sessionId, update: u } });
+    const newSession = (cwd) => {
+        const id = `sess_${Date.now().toString(36)}${(++n).toString(36)}`, s = { cwd, history: [], agent: undefined };
+        const onEvent = (e) => {
+            if (e.kind === "text")
+                update(id, { sessionUpdate: "agent_message_chunk", content: { type: "text", text: e.delta } });
+            else if (e.kind === "thinking")
+                update(id, { sessionUpdate: "agent_thought_chunk", content: { type: "text", text: e.delta } });
+            else if (e.kind === "toolstart")
+                update(id, { sessionUpdate: "tool_call", toolCallId: e.id, title: `${e.name} ${e.args.slice(0, 80)}`, kind: KIND[e.name] ?? "other", status: "in_progress" });
+            else if (e.kind === "tool" && e.id)
+                update(id, { sessionUpdate: "tool_call_update", toolCallId: e.id, status: /^(ERROR|DENIED|REJECTED)/.test(e.result) ? "failed" : "completed", content: [{ type: "content", content: { type: "text", text: e.result.slice(0, 4000) } }] });
+            else if (e.kind === "todos")
+                update(id, { sessionUpdate: "plan", entries: e.todos.map((t) => ({ content: t.content, priority: "medium", status: t.status === "done" ? "completed" : t.status })) });
+        };
+        const approve = async (req) => {
+            const r = await call("session/request_permission", { sessionId: id, toolCall: { toolCallId: req.id ?? `perm_${++n}`, title: `${req.name}: ${req.reason ?? "needs approval"}`, kind: KIND[req.name] ?? "other", status: "pending", rawInput: req.args, ...(req.preview && { content: [{ type: "content", content: { type: "text", text: req.preview.slice(0, 4000) } }] }) },
+                options: [{ optionId: "allow", name: "Allow", kind: "allow_once" }, { optionId: "reject", name: "Reject", kind: "reject_once" }] });
+            const out = r?.outcome;
+            return out?.outcome === "selected" && out.optionId === "allow" ? true : "the user rejected this in the editor";
+        };
+        s.agent = o.makeAgent({ cwd, onEvent, approve, signal: () => s.ac?.signal });
+        sessions.set(id, s);
+        return id;
+    };
+    const toText = (blocks) => {
+        const parts = [], images = [];
+        for (const b of blocks ?? []) {
+            if (b.type === "text")
+                parts.push(b.text);
+            else if (b.type === "image" && b.data)
+                images.push({ mime: b.mimeType ?? "image/png", data: b.data });
+            else if (b.type === "resource" && b.resource?.text !== undefined)
+                parts.push(`<file uri="${b.resource.uri}">\n${b.resource.text}\n</file>`);
+            else if (b.type === "resource_link" && b.uri)
+                parts.push(`(see ${b.uri})`);
+        }
+        return { text: parts.join("\n\n"), images };
+    };
+    const handle = async (m) => {
+        const ok = (result) => send({ id: m.id, result }), fail = (code, message) => send({ id: m.id, error: { code, message } });
+        try {
+            switch (m.method) {
+                case "initialize": return ok({ protocolVersion: 1, agentCapabilities: { loadSession: false, promptCapabilities: { image: true, embeddedContext: true }, mcpCapabilities: { http: false, sse: false } }, agentInfo: { name: "amness", title: "Amness", version: o.version }, authMethods: [] });
+                case "session/new": return ok({ sessionId: newSession(m.params?.cwd || process.cwd()) });
+                case "session/prompt": {
+                    const s = sessions.get(m.params?.sessionId);
+                    if (!s)
+                        return fail(-32602, "unknown session");
+                    if (s.ac)
+                        return fail(-32000, "a turn is already running in this session");
+                    const { text, images } = toText(m.params.prompt);
+                    s.ac = new AbortController();
+                    try {
+                        const r = await s.agent.chat(s.history, text, { images });
+                        s.history = r.messages;
+                        const stop = s.ac.signal.aborted ? "cancelled" : r.stopped === "budget" || r.stopped === "maxSteps" ? "max_turn_requests" : "end_turn";
+                        return ok({ stopReason: stop });
+                    }
+                    finally {
+                        s.ac = undefined;
+                    }
+                }
+                case "session/cancel":
+                    sessions.get(m.params?.sessionId)?.ac?.abort();
+                    return; // a notification: no reply
+                case "authenticate": return ok({});
+                default: if (m.id !== undefined)
+                    return fail(-32601, `method not found: ${m.method}`);
+            }
+        }
+        catch (e) {
+            if (m.id !== undefined)
+                fail(-32603, e.message);
+        }
+    };
+    return new Promise((resolve) => {
+        const rl = createInterface({ input: o.input });
+        rl.on("line", (line) => {
+            if (!line.trim())
+                return;
+            let m;
+            try {
+                m = JSON.parse(line);
+            }
+            catch {
+                return send({ id: null, error: { code: -32700, message: "parse error" } });
+            }
+            if (m.method)
+                void handle(m);
+            else if (m.id !== undefined) {
+                waiting.get(m.id)?.(m.result ?? { error: m.error });
+                waiting.delete(m.id);
+            }
+        });
+        rl.on("close", () => { for (const s of sessions.values())
+            s.ac?.abort(); for (const w of waiting.values())
+            w({}); resolve(); });
+    });
+}

package/dist/src/agents.d.ts

@@ -0,0 +1,23 @@
+export type AgentDef = {
+    name: string;
+    description: string;
+    tools: string[];
+    model?: string;
+    isolation?: "worktree";
+    maxSteps: number;
+    prompt: string;
+    scope: "project" | "user";
+    source: string;
+    file: string;
+};
+export declare const READ_TOOLS: string[];
+/** Tools an agent definition may name. Everything else (task, background processes, memory) stays with the lead. */
+export declare const AGENT_TOOLS: string[];
+export declare const WRITE_TOOLS: Set<string>;
+export declare function loadAgents(cwd: string, o?: {
+    userHome?: string;
+}): {
+    agents: AgentDef[];
+    warnings: string[];
+};
+export declare const isWriter: (a: Pick<AgentDef, "tools">) => boolean;

package/dist/src/agents.js

@@ -0,0 +1,71 @@
+// Custom subagents: a markdown file per agent (front matter + the agent's system prompt), in .amness/agents/ or .claude/agents/ (project and home).
+//   ---
+//   name: reviewer
+//   description: reviews diffs for bugs
+//   tools: read_file, grep, list_files          (default: the read-only set)
+//   model: fast                                  (a key of the `agentModels` option; default: the main model)
+//   isolation: worktree                          (a writing agent works in its own git worktree and hands back a diff)
+//   max-steps: 20
+//   ---
+//   You are a careful reviewer. ...
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+export const READ_TOOLS = ["list_files", "read_file", "grep"];
+/** Tools an agent definition may name. Everything else (task, background processes, memory) stays with the lead. */
+export const AGENT_TOOLS = ["list_files", "read_file", "grep", "write_file", "edit_file", "apply_patch", "sh", "skill"];
+export const WRITE_TOOLS = new Set(["write_file", "edit_file", "apply_patch", "sh"]);
+const CONVENTIONS = [".amness/agents", ".claude/agents"];
+export function loadAgents(cwd, o = {}) {
+    const agents = [], warnings = [], seen = new Set(["explore"]), home = o.userHome ?? (process.env.AMNESS_HOME ? resolve(process.env.AMNESS_HOME, "..") : homedir());
+    for (const [base, scope] of [[cwd, "project"], [home, "user"]])
+        for (const conv of CONVENTIONS) {
+            const dir = join(base, conv);
+            if (!existsSync(dir))
+                continue;
+            let files = [];
+            try {
+                files = readdirSync(dir).filter((f) => f.endsWith(".md")).sort();
+            }
+            catch {
+                continue;
+            }
+            for (const f of files) {
+                const text = readFileSync(join(dir, f), "utf8"), m = /^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/.exec(text);
+                if (!m) {
+                    warnings.push(`${conv}/${f}: skipped, it needs front matter with a name and description`);
+                    continue;
+                }
+                const meta = {};
+                for (const line of m[1].split(/\r?\n/)) {
+                    const kv = /^([\w-]+):\s*(.*)$/.exec(line);
+                    if (kv)
+                        meta[kv[1]] = kv[2].replace(/^["']|["']$/g, "").trim();
+                }
+                const name = (meta.name || f.replace(/\.md$/, "")).trim();
+                if (!/^[\w][\w.-]{0,40}$/.test(name)) {
+                    warnings.push(`${conv}/${f}: skipped, "${name}" is not a usable agent name`);
+                    continue;
+                }
+                if (!meta.description) {
+                    warnings.push(`${conv}/${f}: skipped, it needs a "description:" line`);
+                    continue;
+                }
+                if (seen.has(name)) {
+                    if (name === "explore")
+                        warnings.push(`${conv}/${f}: "explore" is built in; pick another name`);
+                    continue;
+                }
+                seen.add(name);
+                const asked = (meta.tools ? meta.tools.split(/[,\s]+/).filter(Boolean) : READ_TOOLS), tools = asked.filter((t) => AGENT_TOOLS.includes(t));
+                for (const t of asked)
+                    if (!AGENT_TOOLS.includes(t))
+                        warnings.push(`${conv}/${f}: tool "${t}" is not available to subagents (allowed: ${AGENT_TOOLS.join(", ")})`);
+                if (!/\b(report|return|summar|answer|finish)/i.test(m[2]))
+                    warnings.push(`${conv}/${f}: advice: say what the agent should report back (a short summary with file paths); subagents that do not know tend to ramble or stop without an answer`);
+                agents.push({ name, description: meta.description.slice(0, 200), tools: tools.length ? tools : READ_TOOLS, model: meta.model || undefined, isolation: meta.isolation === "worktree" ? "worktree" : undefined, maxSteps: Math.min(60, Math.max(3, Number(meta["max-steps"]) || 20)), prompt: m[2].trim(), scope, source: conv, file: join(dir, f) });
+            }
+        }
+    return { agents, warnings };
+}
+export const isWriter = (a) => a.tools.some((t) => WRITE_TOOLS.has(t));

package/dist/src/anthropic.d.ts

@@ -0,0 +1,30 @@
+import type { Message, Model } from "./harness.ts";
+/**
+ * Claude backend via the official Anthropic SDK (an optional dependency, installed with the package: `npm i @anthropic-ai/sdk` if it is missing).
+ * Defaults follow Anthropic's guidance for agent loops: adaptive thinking, auto prompt caching, streaming,
+ * server-side refusal fallbacks. Credentials: `apiKey`, ANTHROPIC_API_KEY, or an `ant auth login` profile.
+ */
+export type AnthropicOptions = {
+    /** Advisory token budget for each agentic turn (Claude's `task_budget`, beta): the model sees a running countdown and wraps up gracefully. At least 20000; only sent to models that support it. Set once; it is not changed between requests (that would break the prompt cache). */
+    taskBudget?: number;
+    model?: string;
+    apiKey?: string;
+    baseUrl?: string;
+    effort?: "low" | "medium" | "high" | "xhigh" | "max";
+    maxTokens?: number;
+    /** Re-run a safety-declined request on Anthropic's recommended fallback model. Default: on where the model supports it. */
+    fallbacks?: boolean;
+    /** Adaptive thinking. Default: on for models that support it. */
+    thinking?: boolean;
+    /** Inject a client (tests, proxies, Bedrock/Vertex clients). */
+    client?: any;
+};
+export declare const DEFAULT_CLAUDE = "claude-opus-5-5";
+/** Our transcript -> Anthropic `system` + `messages`. Parallel tool results are merged into ONE user message, as the API wants. */
+export declare function toAnthropic(msgs: Message[]): {
+    system?: string;
+    messages: any[];
+};
+/** Anthropic response -> our Message, keeping the native blocks (thinking!) in `raw`. */
+export declare function fromAnthropic(r: any): Message;
+export declare function anthropic(o?: AnthropicOptions): Model;

package/dist/src/anthropic.js

@@ -0,0 +1,91 @@
+export const DEFAULT_CLAUDE = "claude-opus-5-5";
+const ADAPTIVE = /^claude-(opus-(4-[6-8]|5)|sonnet-(4-6|5)|fable|mythos|haiku-5)/;
+const FALLBACK_OK = /^claude-(opus-5|fable-|sonnet-5-5|mythos-)/;
+const isError = (s) => /^(ERROR|DENIED|REJECTED)/.test(s ?? "");
+const parse = (s) => { try {
+    return JSON.parse(s || "{}");
+}
+catch {
+    return {};
+} };
+/** Our transcript -> Anthropic `system` + `messages`. Parallel tool results are merged into ONE user message, as the API wants. */
+export function toAnthropic(msgs) {
+    let system;
+    const out = [];
+    const push = (role, blocks) => {
+        const last = out.at(-1);
+        if (last?.role === role)
+            last.content.push(...blocks);
+        else
+            out.push({ role, content: blocks });
+    };
+    for (const m of msgs) {
+        if (m.role === "system")
+            system = (system ? system + "\n\n" : "") + (m.content ?? "");
+        else if (m.role === "user")
+            push("user", [...(m.images ?? []).map((i) => ({ type: "image", source: { type: "base64", media_type: i.mime, data: i.data } })), { type: "text", text: m.content || "(continue)" }]);
+        else if (m.role === "tool")
+            push("user", [{ type: "tool_result", tool_use_id: m.tool_call_id, content: m.content ?? "", ...(isError(m.content) && { is_error: true }) }]);
+        else {
+            const blocks = Array.isArray(m.raw) ? m.raw : [
+                ...(m.content ? [{ type: "text", text: m.content }] : []),
+                ...(m.tool_calls ?? []).map((c) => ({ type: "tool_use", id: c.id, name: c.function.name, input: parse(c.function.arguments) })),
+            ];
+            push("assistant", blocks.length ? blocks : [{ type: "text", text: "(no output)" }]);
+        }
+    }
+    return { system, messages: out };
+}
+/** Anthropic response -> our Message, keeping the native blocks (thinking!) in `raw`. */
+export function fromAnthropic(r) {
+    const blocks = r.content ?? [];
+    const text = blocks.filter((b) => b.type === "text").map((b) => b.text).join("");
+    let calls = blocks.filter((b) => b.type === "tool_use").map((b) => ({ id: b.id, type: "function", function: { name: b.name, arguments: JSON.stringify(b.input ?? {}) } }));
+    let content = text || null, raw = blocks;
+    if (r.stop_reason === "refusal" && !calls.length)
+        content = `[model declined: ${r.stop_details?.category ?? "policy"}] ${text}`.trim();
+    if (r.stop_reason === "max_tokens" && calls.length) {
+        // A tool call cut off mid-JSON must never run. Drop it and nudge the model to go smaller (the "I'll" trips the harness nudge).
+        calls = [];
+        raw = blocks.filter((b) => b.type !== "tool_use");
+        content = `${text}\n[output hit the max_tokens limit; I'll redo that in smaller steps]`.trim();
+    }
+    const u = r.usage ?? {}, input = (u.input_tokens ?? 0) + (u.cache_read_input_tokens ?? 0) + (u.cache_creation_input_tokens ?? 0);
+    return {
+        role: "assistant", content, raw, ...(calls.length && { tool_calls: calls }),
+        usage: { prompt_tokens: input, completion_tokens: u.output_tokens ?? 0, total_tokens: input + (u.output_tokens ?? 0), cached_tokens: u.cache_read_input_tokens ?? 0 },
+    };
+}
+const toTool = (t) => ({
+    name: t.name, ...(t.description && { description: t.description }),
+    input_schema: t.parameters.type === "object" ? t.parameters : { type: "object", properties: {} },
+});
+/** Models that accept `task_budget` (beta). Not Sonnet 5, Opus 4.6, Sonnet 4.6 or Haiku 4.5. */
+const TASK_BUDGET_OK = /claude-(fable|mythos|opus-(4-7|4-8|5)|sonnet-5-5|haiku-5-5)/;
+export function anthropic(o = {}) {
+    const model = o.model ?? process.env.AMNESS_MODEL ?? DEFAULT_CLAUDE;
+    const fallbacks = o.fallbacks ?? FALLBACK_OK.test(model);
+    const thinking = o.thinking ?? ADAPTIVE.test(model);
+    const taskBudget = o.taskBudget && o.taskBudget >= 20_000 && TASK_BUDGET_OK.test(model) ? o.taskBudget : undefined;
+    let client = o.client;
+    const call = async (messages, tools, opts) => {
+        client ??= await import("@anthropic-ai/sdk").then((m) => new m.default({ ...(o.apiKey && { apiKey: o.apiKey }), ...(o.baseUrl && { baseURL: o.baseUrl }) }), () => { throw new Error("Claude support needs the SDK: npm install @anthropic-ai/sdk"); });
+        const { system, messages: msgs } = toAnthropic(messages);
+        const req = {
+            model, max_tokens: opts?.maxTokens ?? o.maxTokens ?? 32_000, ...(system && { system }), messages: msgs,
+            ...(tools.length && { tools: tools.map(toTool) }),
+            ...((thinking || taskBudget) && { ...(thinking && { thinking: { type: "adaptive" } }), output_config: { ...(thinking && { effort: o.effort ?? "high" }), ...(taskBudget && { task_budget: { type: "tokens", total: taskBudget } }) } }),
+            cache_control: { type: "ephemeral" }, // the transcript is append-only, so each turn reads the previous one from cache
+        };
+        // Streaming avoids HTTP timeouts on long outputs; we only need the assembled message.
+        const betas = [...(fallbacks ? ["server-side-fallback-2026-07-01"] : []), ...(taskBudget ? ["task-budgets-2026-03-13"] : [])];
+        const stream = betas.length
+            ? client.beta.messages.stream({ ...req, betas, ...(fallbacks && { fallbacks: "default" }) }, { signal: opts?.signal })
+            : client.messages.stream(req, { signal: opts?.signal });
+        if (opts?.onText)
+            stream.on?.("text", (delta) => opts.onText(delta));
+        return fromAnthropic(await stream.finalMessage());
+    };
+    call.appendOnly = true;
+    return call;
+}

package/dist/src/approver.d.ts

@@ -0,0 +1,15 @@
+import type { Approve, Model } from "./harness.ts";
+export type ReviewDecision = {
+    decision: "approve" | "escalate";
+    reason: string;
+};
+export declare function parseDecision(text: string): ReviewDecision;
+/** Wrap `inner` (what asks the user) so a reviewer model gets the first look. `task` is the user's request, for context. */
+export declare function reviewedApprove(inner: Approve, o: {
+    model: Model;
+    task?: () => string | undefined;
+    onDecision?: (d: ReviewDecision & {
+        tool: string;
+    }) => void;
+    timeoutMs?: number;
+}): Approve;

package/dist/src/approver.js

@@ -0,0 +1,40 @@
+const SYSTEM = `You review ONE tool call an autonomous coding agent wants to make, on behalf of the developer who owns the machine. Decide if it is clearly safe to run without asking them.
+Approve only when ALL hold: it does what the task plausibly needs; it stays inside the project; it is easy to undo or only reads; it sends nothing off the machine; it deletes or overwrites nothing that was not just created.
+Escalate (let the developer decide) for anything else, and whenever you are unsure. Network writes, publishing, installing global packages, credentials, deleting data, force operations, and anything you do not fully understand are always escalated.
+Reply with JSON only: {"decision":"approve"|"escalate","reason":"<one short sentence>"}`;
+const clip = (s, n) => (s.length > n ? s.slice(0, n) + "…" : s);
+export function parseDecision(text) {
+    const m = /\{[\s\S]*\}/.exec(text);
+    if (!m)
+        return { decision: "escalate", reason: "reviewer gave no verdict" };
+    try {
+        const j = JSON.parse(m[0]);
+        return { decision: j.decision === "approve" ? "approve" : "escalate", reason: String(j.reason ?? "").slice(0, 200) || (j.decision === "approve" ? "judged safe" : "unsure") };
+    }
+    catch {
+        return { decision: "escalate", reason: "reviewer verdict was not valid JSON" };
+    }
+}
+/** Wrap `inner` (what asks the user) so a reviewer model gets the first look. `task` is the user's request, for context. */
+export function reviewedApprove(inner, o) {
+    return async (req) => {
+        if (req.floor)
+            return inner(req); // the safety floor and untrusted-text policy always reach a human
+        let d;
+        try {
+            const msgs = [{ role: "system", content: SYSTEM }, { role: "user", content: `Developer's request: ${clip(o.task?.() ?? "(unknown)", 600)}\n\nTool: ${req.name}\nWhy it needs approval: ${req.reason ?? "(not stated)"}\nArguments: ${clip(JSON.stringify(req.args), 1500)}${req.preview ? `\nPreview:\n${clip(req.preview, 1500)}` : ""}` }];
+            const ac = new AbortController(), t = setTimeout(() => ac.abort(), o.timeoutMs ?? 20_000);
+            try {
+                d = parseDecision((await o.model(msgs, [], { signal: ac.signal })).content ?? "");
+            }
+            finally {
+                clearTimeout(t);
+            }
+        }
+        catch {
+            d = { decision: "escalate", reason: "reviewer unavailable" };
+        }
+        o.onDecision?.({ ...d, tool: req.name });
+        return d.decision === "approve" ? true : inner(req);
+    };
+}