synartesis 0.1.0

package/dist/cli.js

@@ -0,0 +1,1708 @@
+#!/usr/bin/env node
+import {
+  WORDMARK,
+  banner,
+  canonical,
+  cliCommand,
+  connectStdioUpstream,
+  createPolicyResolver,
+  createRouter,
+  findJournal,
+  findManifest,
+  labelFor,
+  loadManifest,
+  observeState,
+  openJournal,
+  parseManifest,
+  planInverse,
+  planRead,
+  proxyCommand,
+  qualify,
+  rule,
+  style,
+  toPayload,
+  verifyAgainstServers,
+  wasRefused
+} from "./chunk-X4VQNEP5.js";
+import {
+  DriftConflict,
+  ManifestError,
+  RollbackHalted,
+  SynartesisError,
+  UpstreamError,
+  describe
+} from "./chunk-K3QIPVBY.js";
+
+// src/cli.ts
+import { existsSync as existsSync3, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { dirname, resolve } from "path";
+
+// src/init/draft.ts
+import { z } from "zod";
+var toolSchema = z.looseObject({
+  name: z.string(),
+  description: z.string().optional(),
+  annotations: z.looseObject({
+    readOnlyHint: z.boolean().optional(),
+    destructiveHint: z.boolean().optional(),
+    idempotentHint: z.boolean().optional()
+  }).optional()
+});
+var listSchema = z.looseObject({
+  tools: z.array(toolSchema),
+  nextCursor: z.string().optional()
+});
+function quote(value) {
+  return JSON.stringify(value);
+}
+function summarise(text) {
+  if (text === void 0) {
+    return "";
+  }
+  const single = text.replace(/\s+/g, " ").trim();
+  return single.length > 96 ? `${single.slice(0, 93)}...` : single;
+}
+function draftTool(server, tool) {
+  const match = `${server}.${tool.name}`;
+  const lines = [];
+  const description = summarise(tool.description);
+  if (description !== "") {
+    lines.push(`  # ${description}`);
+  }
+  if (tool.annotations?.readOnlyHint === true) {
+    lines.push(`  # classified readonly from the server's readOnlyHint; verify it before relying on it.`);
+    lines.push(`  - match: ${quote(match)}`);
+    lines.push(`    class: readonly`);
+    return lines.join("\n");
+  }
+  lines.push(`  # TODO: this is gated on every call until you describe how to undo it.`);
+  lines.push(`  #   reversible  needs a snapshot (a pre-read) and an inverse.`);
+  lines.push(`  #   compensable needs an inverse only, usually built from $result.`);
+  lines.push(`  #   irreversible is correct when neither exists; leave gate: always.`);
+  lines.push(`  - match: ${quote(match)}`);
+  lines.push(`    class: irreversible`);
+  lines.push(`    gate: always`);
+  return lines.join("\n");
+}
+async function draftManifest(options) {
+  const upstream = await connectStdioUpstream({
+    name: options.name,
+    command: options.command,
+    args: options.args,
+    stderr: "capture"
+  });
+  let tools;
+  try {
+    const collected = [];
+    let cursor;
+    do {
+      const page = listSchema.parse(
+        await upstream.client.request(
+          { method: "tools/list", params: cursor === void 0 ? {} : { cursor } },
+          z.looseObject({})
+        )
+      );
+      collected.push(...page.tools);
+      cursor = page.nextCursor;
+    } while (cursor !== void 0);
+    tools = collected;
+  } catch (error) {
+    throw new UpstreamError(options.name, "tools/list", error);
+  } finally {
+    await upstream.close();
+  }
+  if (tools.length === 0) {
+    throw new ManifestError(`${options.name} exposes no tools, so there is no policy to write`);
+  }
+  const existing = options.existing?.trimEnd();
+  if (existing !== void 0 && existing.includes(`
+  ${options.name}:`)) {
+    throw new ManifestError(
+      `${options.name} is already declared in the manifest; remove it first or choose another name`
+    );
+  }
+  const server = [
+    `  ${options.name}:`,
+    `    command: ${quote(options.command)}`,
+    `    args: [${options.args.map(quote).join(", ")}]`
+  ].join("\n");
+  const policies = tools.map((tool) => draftTool(options.name, tool)).join("\n\n");
+  if (existing === void 0) {
+    return [
+      `# Generated by synartesis init from ${options.name}'s tools/list.`,
+      `# Every tool starts gated. Working through the TODOs is the whole job:`,
+      `# a tool with no inverse is one an agent cannot use unsupervised.`,
+      ``,
+      `version: 1`,
+      ``,
+      `servers:`,
+      server,
+      ``,
+      `tools:`,
+      policies,
+      ``
+    ].join("\n");
+  }
+  return mergeInto(existing, server, policies, options.name);
+}
+function mergeInto(existing, server, policies, name) {
+  const serversAt = existing.indexOf("\nservers:");
+  const toolsAt = existing.indexOf("\ntools:");
+  if (serversAt === -1 || toolsAt === -1 || toolsAt < serversAt) {
+    throw new ManifestError(
+      "the existing manifest does not have a servers: block followed by a tools: block, so it cannot be extended automatically"
+    );
+  }
+  const head = existing.slice(0, toolsAt);
+  const tail = existing.slice(toolsAt);
+  return [
+    head.trimEnd(),
+    server,
+    tail.trimEnd(),
+    ``,
+    `  # --- added by synartesis init for ${name} ---`,
+    policies,
+    ``
+  ].join("\n");
+}
+
+// src/rollback/rollback.ts
+import { z as z2 } from "zod";
+var IDEMPOTENCY_META_KEY = "synartesis.dev/idempotency-key";
+var inversePlan = z2.object({
+  server: z2.string(),
+  tool: z2.string(),
+  args: z2.record(z2.string(), z2.unknown())
+});
+var observation = z2.union([
+  z2.object({ present: z2.literal(true), value: z2.unknown() }),
+  z2.object({ present: z2.literal(false) })
+]);
+var toolResult = z2.looseObject({ isError: z2.boolean().default(false) });
+function sameState(a, b) {
+  return canonical(a) === canonical(b);
+}
+function classify(action, replanning) {
+  switch (action.status) {
+    case "rolled_back":
+      return { kind: "already-reverted", reason: "already rolled back", verified: true };
+    case "failed":
+    case "denied":
+      return { kind: "skip", reason: `never applied (${action.status})`, verified: true };
+    case "pending":
+      return {
+        kind: "halt",
+        reason: "outcome unknown: the process died mid-call, so whether this applied cannot be determined",
+        verified: false
+      };
+    case "gated":
+      return { kind: "skip", reason: "never applied (awaiting approval)", verified: true };
+    case "approved":
+      return { kind: "skip", reason: "never applied (approved, never retried)", verified: true };
+    case "unrecoverable":
+      if (action.inverse === void 0) {
+        return void 0;
+      }
+      return replanning ? void 0 : { kind: "halt", reason: "halted here on an earlier attempt", verified: false };
+    case "applied":
+    case "rolling_back":
+      return void 0;
+  }
+}
+async function rollback(options) {
+  const { journal, router, runId } = options;
+  const dryRun = options.dryRun ?? false;
+  const signal = options.signal ?? new AbortController().signal;
+  const policies = options.replanWith === void 0 ? void 0 : createPolicyResolver(options.replanWith);
+  const replan = (action) => {
+    if (policies === void 0) {
+      return {};
+    }
+    const policy = policies.resolve(qualify(action.server, action.tool)).policy;
+    const context = {
+      args: action.args,
+      ...action.snapshot === void 0 ? {} : { snapshot: action.snapshot },
+      ...action.result === void 0 ? {} : { result: toPayload(action.result) }
+    };
+    try {
+      return {
+        ...policy.inverse === void 0 ? {} : { inverse: planInverse(policy.inverse, context) },
+        ...policy.snapshot === void 0 ? {} : { verify: planRead(policy.snapshot, { args: action.args }) }
+      };
+    } catch (error) {
+      return { error: describe(error) };
+    }
+  };
+  const all = journal.getActions(runId);
+  const inScope = [...all].filter((action) => options.toSeq === void 0 || action.seq >= options.toSeq).sort((a, b) => b.seq - a.seq);
+  const steps = [];
+  let halted;
+  let leftInPlace = false;
+  for (const action of inScope) {
+    const early = classify(action, policies !== void 0);
+    if (early?.kind === "halt") {
+      const seen = action.error ?? "";
+      const detail = action.status === "unrecoverable" && seen !== "" ? `what it saw when it halted, which may no longer hold:
+${seen}
+Resolve the conflict, then run undo --replan to check it against the world as it is now.` : seen;
+      halted = { seq: action.seq, reason: early.reason, detail };
+      steps.push({ ...describeStep(action), ...early });
+      break;
+    }
+    if (early !== void 0) {
+      steps.push({ ...describeStep(action), ...early });
+      continue;
+    }
+    if (action.class === "readonly") {
+      steps.push({ ...describeStep(action), kind: "skip", reason: "readonly", verified: true });
+      continue;
+    }
+    const rebuilt = replan(action);
+    const parsedPlan = inversePlan.safeParse(rebuilt.inverse ?? action.inverse);
+    if (!parsedPlan.success) {
+      const approved = action.approvedBy === void 0 ? "" : `, approved by ${action.approvedBy}`;
+      const reason = action.class === "irreversible" ? `cannot be undone${approved}; left in place` : `no usable inverse was recorded${action.error === void 0 ? "" : `: ${action.error}`}; left in place`;
+      steps.push({ ...describeStep(action), kind: "permanent", reason, verified: false });
+      leftInPlace = true;
+      continue;
+    }
+    const plan = parsedPlan.data;
+    const verifyRead = inversePlan.safeParse(rebuilt.verify ?? action.verify);
+    const recordedPost = observation.safeParse(action.postSnapshot);
+    let verified = false;
+    if (recordedPost.success && verifyRead.success) {
+      let current;
+      try {
+        current = await observeState(router, verifyRead.data, signal);
+      } catch (error) {
+        const reason = `could not read current state to check for drift: ${describe(error)}`;
+        halted = { seq: action.seq, reason, detail: "" };
+        steps.push({ ...describeStep(action), kind: "halt", reason, verified: false });
+        if (!dryRun) {
+          journal.markUnrecoverable(action.id, reason);
+        }
+        break;
+      }
+      if (sameState(current, recordedPost.data)) {
+        verified = true;
+      } else if (sameState(current, intendedAfterInverse(action))) {
+        steps.push({
+          ...describeStep(action),
+          kind: "already-reverted",
+          reason: "the resource is already in the state this inverse would produce",
+          verified: true,
+          plan
+        });
+        if (!dryRun) {
+          journal.markRolledBack(action.id);
+        }
+        continue;
+      } else {
+        const conflict = new DriftConflict(action.seq, recordedPost.data, current);
+        halted = { seq: action.seq, reason: "drift detected", detail: conflict.message };
+        steps.push({
+          ...describeStep(action),
+          kind: "halt",
+          reason: "drift detected",
+          verified: false,
+          plan
+        });
+        if (!dryRun) {
+          journal.markUnrecoverable(action.id, conflict.message);
+        }
+        break;
+      }
+    }
+    if (!verified && action.status === "rolling_back") {
+      const reason = "an inverse was already sent before an interruption and no pre-read is declared, so whether it applied cannot be determined";
+      halted = { seq: action.seq, reason, detail: action.error ?? "" };
+      steps.push({ ...describeStep(action), kind: "halt", reason, verified: false, plan });
+      if (!dryRun) {
+        journal.markUnrecoverable(action.id, reason);
+      }
+      break;
+    }
+    steps.push({
+      ...describeStep(action),
+      kind: "revert",
+      reason: verified ? "state matches; applying inverse" : unverifiedBecause(action),
+      verified,
+      plan,
+      ...rebuilt.inverse === void 0 ? {} : { replanned: true }
+    });
+    if (dryRun) {
+      continue;
+    }
+    const claimed = journal.markRollingBack(action.id);
+    if (!claimed && action.status === "applied") {
+      const reason = "another undo is already working on this action";
+      halted = { seq: action.seq, reason, detail: "" };
+      steps[steps.length - 1] = {
+        ...describeStep(action),
+        kind: "halt",
+        reason,
+        verified,
+        plan
+      };
+      break;
+    }
+    const outcome = await executeInverse(router, plan, action.idempotencyKey, signal);
+    if (outcome.ok) {
+      journal.markRolledBack(action.id);
+      continue;
+    }
+    const halt = new RollbackHalted(action.seq, outcome.message);
+    if (outcome.rejected) {
+      journal.markInverseRejected(action.id, halt.message);
+    } else {
+      journal.markUnknownInverse(action.id, halt.message);
+    }
+    halted = { seq: action.seq, reason: "the inverse failed", detail: halt.message };
+    steps[steps.length - 1] = {
+      ...describeStep(action),
+      kind: "halt",
+      reason: "the inverse failed",
+      verified,
+      plan
+    };
+    break;
+  }
+  const completedWholeRun = halted === void 0 && !leftInPlace && options.toSeq === void 0;
+  const status = completedWholeRun ? "rolled_back" : "partial";
+  if (!dryRun) {
+    journal.endRun(runId, status);
+  }
+  return {
+    runId,
+    status,
+    dryRun,
+    steps,
+    ...halted === void 0 ? {} : { halted }
+  };
+}
+function unverifiedBecause(action) {
+  return action.verify === void 0 ? "no pre-read declared, so drift could not be ruled out" : "the post-state was never captured, so drift could not be ruled out";
+}
+function describeStep(action) {
+  return { seq: action.seq, server: action.server, tool: action.tool };
+}
+function intendedAfterInverse(action) {
+  return action.snapshot === void 0 ? void 0 : { present: true, value: action.snapshot };
+}
+async function executeInverse(router, plan, idempotencyKey, signal) {
+  const upstream = router.byName(plan.server);
+  if (upstream === void 0) {
+    return { ok: false, rejected: false, message: `server ${plan.server} is not connected` };
+  }
+  let raw;
+  try {
+    raw = await upstream.client.request(
+      {
+        method: "tools/call",
+        params: {
+          name: plan.tool,
+          arguments: plan.args,
+          _meta: { [IDEMPOTENCY_META_KEY]: idempotencyKey }
+        }
+      },
+      z2.looseObject({}),
+      { signal }
+    );
+  } catch (error) {
+    return { ok: false, rejected: false, message: describe(error) };
+  }
+  const parsed = toolResult.safeParse(raw);
+  if (parsed.success && parsed.data.isError) {
+    return {
+      ok: false,
+      rejected: true,
+      message: `the inverse was refused: ${JSON.stringify(raw)}`
+    };
+  }
+  return { ok: true };
+}
+
+// src/watch.ts
+import { existsSync } from "fs";
+
+// src/keys.ts
+var SEQUENCE = /^\u001b(\[[0-9;?]*[ -\/]*[@-~]|O[@-~])/;
+function keysIn(chunk) {
+  const keys = [];
+  let at = 0;
+  while (at < chunk.length) {
+    const rest = chunk.slice(at);
+    const sequence = rest.startsWith("\x1B") ? SEQUENCE.exec(rest) : null;
+    const key = sequence?.[0] ?? rest.slice(0, 1);
+    keys.push(key);
+    at += key.length;
+  }
+  return keys;
+}
+
+// src/watch.ts
+var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
+var MARK = {
+  readonly: "\xB7",
+  reversible: "\u2190",
+  compensable: "\u2248",
+  irreversible: "!",
+  unclassified: "?"
+};
+var NOTICE_TICKS = 26;
+function line(action) {
+  const mark = MARK[action.class] ?? "?";
+  const badge = `${mark} ${action.class}`.padEnd(14);
+  const when = action.ts.slice(11, 19);
+  const label = labelFor(action).padEnd(13);
+  const status = action.status === "gated" ? style.strong(label) : wasRefused(action) ? style.accent(label) : style.quiet(label);
+  return `  ${style.quiet(when)}  ${style.quiet(badge)} ${status} ${action.server}.${action.tool}`;
+}
+function waitingForJournal(options, tick) {
+  const spinner = options.live ? `${style.accent(FRAMES[tick % FRAMES.length] ?? "")} ` : "";
+  return [
+    "",
+    `  ${style.plate(WORDMARK)}  ${style.quiet(options.journalPath)}`,
+    `  ${rule(64)}`,
+    "",
+    `  ${spinner}${style.quiet("no journal here yet")}`,
+    "",
+    `  ${style.quiet("One appears the first time an agent calls a tool through the proxy.")}`,
+    `  ${style.quiet("Point your client at it, then work as usual; this will fill in.")}`,
+    ""
+  ].join("\n");
+}
+function render(journal, options, tick, view) {
+  const runs = journal.listRuns();
+  const recent = journal.recentActions(12);
+  const waiting = journal.listGated();
+  const active = runs.filter((run) => run.status === "active").length;
+  const out2 = [];
+  out2.push("");
+  out2.push(`  ${style.plate(WORDMARK)}  ${style.quiet(options.journalPath)}`);
+  out2.push(`  ${rule(64)}`);
+  out2.push("");
+  const spinner = options.live ? `${style.accent(FRAMES[tick % FRAMES.length] ?? "")} ` : "";
+  out2.push(
+    `  ${spinner}${style.quiet("watching")}  ${String(runs.length)} runs, ${String(active)} live  ${style.quiet("\xB7")}  ${String(recent.length)} recent actions  ${style.quiet("\xB7")}  ${waiting.length > 0 ? style.accent(`${String(waiting.length)} awaiting approval`) : style.quiet("nothing waiting")}`
+  );
+  out2.push("");
+  if (recent.length === 0) {
+    out2.push(`  ${style.quiet("No agent has done anything through this journal yet.")}`);
+  } else {
+    for (const action of recent) {
+      out2.push(line(action));
+    }
+  }
+  if (waiting.length > 0) {
+    const at = Math.min(view.cursor, waiting.length - 1);
+    out2.push("");
+    out2.push(`  ${style.label("awaiting approval")}`);
+    waiting.forEach((action, index) => {
+      const here = index === at && canDecide(options);
+      const mark = here ? style.accent("\u276F") : " ";
+      const name = here ? style.accent(`${action.server}.${action.tool}`) : style.quiet(`${action.server}.${action.tool}`);
+      out2.push(`  ${mark} ${name}  ${style.quiet(truncate(JSON.stringify(action.args), 56))}`);
+    });
+    out2.push("");
+    out2.push(
+      canDecide(options) ? `  ${keyHint("a", "approve")}   ${keyHint("d", "deny")}   ${keyHint("j/k", "move")}   ${keyHint("q", "quit")}` : `  ${style.quiet(`${options.approveWith} approve --all`)}`
+    );
+  }
+  if (view.notice !== "") {
+    out2.push("");
+    out2.push(`  ${style.accent(view.notice)}`);
+  }
+  out2.push("");
+  return out2.join("\n");
+}
+function truncate(text, limit) {
+  return text.length <= limit ? text : `${text.slice(0, limit - 3)}...`;
+}
+function keyHint(key, what) {
+  return `${style.strong(`[${key}]`)} ${style.quiet(what)}`;
+}
+function isTerminal(value) {
+  return value === true;
+}
+function canDecide(options) {
+  const keyboard = options.keys !== void 0 || isTerminal(process.stdin.isTTY);
+  return options.live && options.decideAs !== void 0 && keyboard;
+}
+async function* terminalKeys() {
+  const input = process.stdin;
+  if (!input.isTTY) {
+    return;
+  }
+  input.setRawMode(true);
+  input.resume();
+  try {
+    for await (const chunk of input) {
+      const raw = chunk;
+      const text = typeof raw === "string" ? raw : Buffer.isBuffer(raw) ? raw.toString("utf8") : "";
+      for (const key of keysIn(text)) {
+        yield key;
+      }
+    }
+  } finally {
+    input.setRawMode(false);
+    input.pause();
+  }
+}
+async function watch(options) {
+  let journal;
+  const open = () => {
+    if (journal === void 0 && existsSync(options.journalPath)) {
+      journal = openJournal(options.journalPath, { mustExist: true });
+    }
+    return journal;
+  };
+  const interval = options.intervalMs ?? 120;
+  const clear = "\x1B[H\x1B[2J\x1B[3J";
+  const view = { stop: false, cursor: 0, notice: "", noticeUntil: 0 };
+  let tick = 0;
+  const frame = (tick2) => {
+    const ready = open();
+    return ready === void 0 ? waitingForJournal(options, tick2) : render(ready, options, tick2, view);
+  };
+  const decide = (approve) => {
+    const ready = open();
+    if (ready === void 0 || options.decideAs === void 0) {
+      return;
+    }
+    const waiting = ready.listGated();
+    const action = waiting[Math.min(view.cursor, waiting.length - 1)];
+    if (action === void 0) {
+      return;
+    }
+    const changed = approve ? ready.approve(action.id, options.decideAs) : ready.deny(action.id, options.decideAs, "denied from the watch view");
+    view.notice = !changed ? `${action.server}.${action.tool} was already settled` : approve ? `approved ${action.server}.${action.tool} \xB7 now tell the agent to try again` : `denied ${action.server}.${action.tool} \xB7 it will not go through`;
+    view.noticeUntil = tick + NOTICE_TICKS;
+    view.cursor = 0;
+  };
+  const press = (key) => {
+    switch (key) {
+      case "q":
+      case "":
+        view.stop = true;
+        return;
+      case "a":
+        decide(true);
+        return;
+      case "d":
+        decide(false);
+        return;
+      case "j":
+      case "\x1B[B":
+        view.cursor += 1;
+        return;
+      case "k":
+      case "\x1B[A":
+        view.cursor = Math.max(0, view.cursor - 1);
+        return;
+      default:
+        return;
+    }
+  };
+  const stopped = () => view.stop;
+  const onSignal = () => {
+    view.stop = true;
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  const source = canDecide(options) ? options.keys ?? terminalKeys() : void 0;
+  const reader = source?.[Symbol.asyncIterator]();
+  const reading = reader === void 0 ? Promise.resolve() : (async () => {
+    for (; ; ) {
+      const next = await reader.next();
+      if (next.done === true || stopped()) {
+        return;
+      }
+      press(next.value);
+      if (stopped()) {
+        return;
+      }
+    }
+  })();
+  try {
+    if (!options.live) {
+      options.write(`${frame(0)}
+`);
+      return 0;
+    }
+    options.write("\x1B[?25l");
+    for (; !view.stop; tick += 1) {
+      if (view.notice !== "" && tick >= view.noticeUntil) {
+        view.notice = "";
+      }
+      options.write(clear + frame(tick));
+      if (options.maxTicks !== void 0 && tick + 1 >= options.maxTicks) {
+        break;
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, interval));
+    }
+    return 0;
+  } finally {
+    if (options.live) {
+      options.write("\x1B[?25h\n");
+    }
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    view.stop = true;
+    await Promise.race([
+      (async () => {
+        await reader?.return?.(void 0);
+        await reading;
+      })(),
+      new Promise((resolve2) => setTimeout(resolve2, 50).unref())
+    ]);
+    journal?.close();
+  }
+}
+
+// src/console.ts
+import { existsSync as existsSync2 } from "fs";
+var FRAMES2 = [
+  "\u280B",
+  "\u2819",
+  "\u2839",
+  "\u2838",
+  "\u283C",
+  "\u2834",
+  "\u2826",
+  "\u2827",
+  "\u2807",
+  "\u280F"
+];
+var MARK2 = {
+  readonly: "\xB7",
+  reversible: "\u2190",
+  compensable: "\u2248",
+  irreversible: "!",
+  unclassified: "?"
+};
+var CURSOR = "\u276F";
+var DOT = "\xB7";
+var ESC = "\x1B";
+var NOTICE_TICKS2 = 26;
+function roomFor(options) {
+  const rows = options.rows ?? rowsOf(process.stdout.rows) ?? 24;
+  return Math.max(3, rows - 11);
+}
+function windowed(lines, at, room) {
+  if (lines.length <= room) {
+    return [...lines];
+  }
+  const start = Math.max(0, Math.min(at - Math.floor(room / 2), lines.length - room));
+  const shown = lines.slice(start, start + room);
+  const above = start;
+  const below = lines.length - (start + room);
+  return [
+    ...above === 0 ? [] : [`  ${style.quiet(`${String(above)} more above`)}`],
+    ...shown.slice(above === 0 ? 0 : 1, below === 0 ? void 0 : -1),
+    ...below === 0 ? [] : [`  ${style.quiet(`${String(below)} more below`)}`]
+  ];
+}
+function truncate2(text, limit) {
+  return text.length <= limit ? text : `${text.slice(0, limit - 3)}...`;
+}
+function keyHint2(key, what) {
+  return `${style.strong(`[${key}]`)} ${style.quiet(what)}`;
+}
+function isTerminal2(value) {
+  return value === true;
+}
+function rowsOf(value) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : void 0;
+}
+function canPress(options) {
+  return options.live && (options.keys !== void 0 || isTerminal2(process.stdin.isTTY));
+}
+function modeLabel(screen) {
+  switch (screen.mode) {
+    case "runs":
+      return "everything an agent has done through this journal";
+    case "run":
+      return "one run, in the order it happened";
+    case "gates":
+      return "held until a person decides";
+  }
+}
+function header(options, screen, tick) {
+  const spinner = options.live ? `${style.accent(FRAMES2[tick % FRAMES2.length] ?? "")} ` : "";
+  return [
+    "",
+    `  ${style.plate(WORDMARK)}  ${style.quiet(options.journalPath)}`,
+    `  ${rule(70)}`,
+    "",
+    `  ${spinner}${style.quiet(screen.busy ?? modeLabel(screen))}`,
+    ""
+  ];
+}
+function runsView(journal, screen, options) {
+  const runs = [...journal.listRuns()].reverse();
+  if (runs.length === 0) {
+    return [
+      `  ${style.quiet("No agent has done anything through this journal yet.")}`,
+      "",
+      `  ${style.quiet("A run appears the first time one calls a tool through the proxy.")}`
+    ];
+  }
+  const at = Math.min(screen.cursor, runs.length - 1);
+  return runs.map((run, index) => {
+    const actions = journal.getActions(run.id);
+    const held = actions.filter((action) => action.status === "gated").length;
+    const here = index === at && canPress(options);
+    const name = (run.label ?? "an agent").padEnd(24);
+    const note = held === 0 ? "" : `  ${style.accent(`${String(held)} awaiting approval`)}`;
+    return `  ${here ? style.accent(CURSOR) : " "} ${here ? style.accent(name) : style.strong(name)} ${style.quiet(run.startedAt.slice(0, 19).replace("T", " "))}  ${style.quiet(run.status.padEnd(11))} ${style.quiet(`${String(actions.length)} actions`)}${note}`;
+  });
+}
+function statusOf(action) {
+  const text = labelFor(action).padEnd(13);
+  if (wasRefused(action)) {
+    return style.accent(text);
+  }
+  return action.status === "gated" ? style.strong(text) : style.quiet(text);
+}
+function runView(journal, screen) {
+  const runId = screen.openRun;
+  if (runId === void 0) {
+    return [`  ${style.quiet("no run selected")}`];
+  }
+  const run = journal.getRun(runId);
+  const actions = journal.getActions(runId);
+  const out2 = [
+    `  ${style.label("run")}  ${style.strong(run?.label ?? "an agent")}  ${style.quiet(runId.slice(0, 8))}`,
+    ""
+  ];
+  if (actions.length === 0) {
+    out2.push(`  ${style.quiet("nothing was recorded in this run")}`);
+    return out2;
+  }
+  for (const action of actions) {
+    const badge = `${MARK2[action.class] ?? "?"} ${action.class}`.padEnd(14);
+    out2.push(
+      `  ${style.quiet(String(action.seq).padStart(3))}  ${style.quiet(badge)} ${statusOf(action)} ${style.strong(`${action.server}.${action.tool}`)}`
+    );
+    out2.push(`        ${style.quiet(truncate2(JSON.stringify(action.args), 62))}`);
+    if (action.inverse !== void 0) {
+      out2.push(`        ${style.quiet(`undo: ${truncate2(JSON.stringify(action.inverse), 56)}`)}`);
+    }
+  }
+  return out2;
+}
+function gatesView(journal, screen, options) {
+  const waiting = journal.listGated();
+  if (waiting.length === 0) {
+    return [`  ${style.quiet("Nothing is waiting for a decision.")}`];
+  }
+  const at = Math.min(screen.cursor, waiting.length - 1);
+  return waiting.map((action, index) => {
+    const here = index === at && canPress(options);
+    const name = `${action.server}.${action.tool}`;
+    const shown = here ? style.accent(name) : style.quiet(name);
+    const args = style.quiet(truncate2(JSON.stringify(action.args), 54));
+    return `  ${here ? style.accent(CURSOR) : " "} ${shown}  ${args}`;
+  });
+}
+function footer(screen, options) {
+  if (!canPress(options)) {
+    return [];
+  }
+  if (screen.confirming !== void 0) {
+    return [
+      "",
+      `  ${style.accent("undo this whole run?")}  ${keyHint2("y", "yes")}   ${keyHint2("n", "no")}`
+    ];
+  }
+  const keys = screen.mode === "gates" ? [keyHint2("a", "approve"), keyHint2("d", "deny"), keyHint2("j/k", "move"), keyHint2("r", "runs")] : screen.mode === "run" ? [
+    keyHint2("p", "preview undo"),
+    keyHint2("u", "undo"),
+    keyHint2("esc", "back"),
+    keyHint2("g", "held")
+  ] : [
+    keyHint2("enter", "open"),
+    keyHint2("p", "preview undo"),
+    keyHint2("u", "undo"),
+    keyHint2("j/k", "move"),
+    keyHint2("g", "held")
+  ];
+  return ["", `  ${keys.join("   ")}   ${keyHint2("q", "quit")}`];
+}
+function waitingForJournal2(options, tick) {
+  const spinner = options.live ? `${style.accent(FRAMES2[tick % FRAMES2.length] ?? "")} ` : "";
+  return [
+    "",
+    `  ${style.plate(WORDMARK)}  ${style.quiet(options.journalPath)}`,
+    `  ${rule(70)}`,
+    "",
+    `  ${spinner}${style.quiet("no journal here yet")}`,
+    "",
+    `  ${style.quiet("One appears the first time an agent calls a tool through the proxy.")}`,
+    `  ${style.quiet("Point your client at it, then work as usual; this will fill in.")}`,
+    ""
+  ].join("\n");
+}
+async function* terminalKeys2() {
+  const input = process.stdin;
+  if (!isTerminal2(input.isTTY)) {
+    return;
+  }
+  input.setRawMode(true);
+  input.resume();
+  try {
+    for await (const chunk of input) {
+      const raw = chunk;
+      const text = typeof raw === "string" ? raw : Buffer.isBuffer(raw) ? raw.toString("utf8") : "";
+      for (const key of keysIn(text)) {
+        yield key;
+      }
+    }
+  } finally {
+    input.setRawMode(false);
+    input.pause();
+  }
+}
+async function openConsole(options) {
+  let journal;
+  const open = () => {
+    if (journal === void 0 && existsSync2(options.journalPath)) {
+      journal = openJournal(options.journalPath, { mustExist: true });
+    }
+    return journal;
+  };
+  const screen = {
+    stop: false,
+    mode: "runs",
+    cursor: 0,
+    openRun: void 0,
+    confirming: void 0,
+    busy: void 0,
+    notice: "",
+    noticeUntil: 0
+  };
+  let tick = 0;
+  const stopped = () => screen.stop;
+  const say = (text) => {
+    screen.notice = text;
+    screen.noticeUntil = tick + NOTICE_TICKS2;
+  };
+  const frame = () => {
+    const ready = open();
+    if (ready === void 0) {
+      return waitingForJournal2(options, tick);
+    }
+    const room = roomFor(options);
+    const body = screen.mode === "runs" ? windowed(runsView(ready, screen, options), screen.cursor, room) : screen.mode === "run" ? windowed(runView(ready, screen), 0, room) : windowed(gatesView(ready, screen, options), screen.cursor, room);
+    const notice = screen.notice === "" ? [] : ["", `  ${style.accent(screen.notice)}`];
+    return [
+      ...header(options, screen, tick),
+      ...body,
+      ...notice,
+      ...footer(screen, options),
+      ""
+    ].join("\n");
+  };
+  const selectedRun = (ready) => {
+    if (screen.mode === "run" && screen.openRun !== void 0) {
+      return ready.getRun(screen.openRun);
+    }
+    const runs = [...ready.listRuns()].reverse();
+    return runs[Math.min(screen.cursor, runs.length - 1)];
+  };
+  const decide = (approve) => {
+    const ready = open();
+    if (ready === void 0) {
+      return;
+    }
+    const waiting = ready.listGated();
+    const action = waiting[Math.min(screen.cursor, waiting.length - 1)];
+    if (action === void 0) {
+      return;
+    }
+    const changed = approve ? ready.approve(action.id, options.decideAs) : ready.deny(action.id, options.decideAs, "denied from the console");
+    say(
+      !changed ? `${action.server}.${action.tool} was already settled` : approve ? `approved ${action.server}.${action.tool} ${DOT} now tell the agent to try again` : `denied ${action.server}.${action.tool} ${DOT} it will not go through`
+    );
+    screen.cursor = 0;
+  };
+  const perform = async (runId, dryRun) => {
+    if (options.undo === void 0) {
+      say("no way to undo was configured");
+      return;
+    }
+    if (screen.busy !== void 0) {
+      say("still working on the last one");
+      return;
+    }
+    screen.busy = dryRun ? "reading the current state..." : "putting it back...";
+    try {
+      const report2 = await options.undo(runId, dryRun);
+      const reverted = report2.steps.filter((step) => step.kind === "revert").length;
+      const halted = report2.halted === void 0 ? "" : ` ${DOT} halted: ${report2.halted.reason}`;
+      say(
+        dryRun ? `${String(reverted)} would be reverted ${DOT} nothing changed${halted}` : `${report2.status} ${DOT} ${String(reverted)} reverted${halted}`
+      );
+    } catch (error) {
+      say(error instanceof Error ? error.message : "the undo failed");
+    } finally {
+      screen.busy = void 0;
+    }
+  };
+  const press = (key) => {
+    if (screen.confirming !== void 0) {
+      const runId = screen.confirming;
+      screen.confirming = void 0;
+      if (key === "y") {
+        void perform(runId, false);
+      } else {
+        say("left alone");
+      }
+      return;
+    }
+    switch (key) {
+      case "q":
+      case "":
+        screen.stop = true;
+        return;
+      case "j":
+      case `${ESC}[B`:
+        screen.cursor += 1;
+        return;
+      case "k":
+      case `${ESC}[A`:
+        screen.cursor = Math.max(0, screen.cursor - 1);
+        return;
+      case "g":
+        screen.mode = "gates";
+        screen.cursor = 0;
+        return;
+      case "r":
+        screen.mode = "runs";
+        screen.cursor = 0;
+        return;
+      case ESC:
+      case "h":
+        screen.mode = "runs";
+        screen.openRun = void 0;
+        return;
+      case "\r":
+      case "\n": {
+        const ready = open();
+        const run = ready === void 0 ? void 0 : selectedRun(ready);
+        if (run !== void 0) {
+          screen.openRun = run.id;
+          screen.mode = "run";
+        }
+        return;
+      }
+      case "a":
+        if (screen.mode === "gates") {
+          decide(true);
+        }
+        return;
+      case "d":
+        if (screen.mode === "gates") {
+          decide(false);
+        }
+        return;
+      case "p": {
+        const ready = open();
+        const run = ready === void 0 ? void 0 : selectedRun(ready);
+        if (run !== void 0) {
+          void perform(run.id, true);
+        }
+        return;
+      }
+      case "u": {
+        if (screen.busy !== void 0) {
+          say("still working on the last one");
+          return;
+        }
+        const ready = open();
+        const run = ready === void 0 ? void 0 : selectedRun(ready);
+        if (run !== void 0) {
+          screen.confirming = run.id;
+        }
+        return;
+      }
+      default:
+        return;
+    }
+  };
+  const onSignal = () => {
+    screen.stop = true;
+  };
+  process.on("SIGINT", onSignal);
+  process.on("SIGTERM", onSignal);
+  const source = canPress(options) ? options.keys ?? terminalKeys2() : void 0;
+  const reader = source?.[Symbol.asyncIterator]();
+  const reading = reader === void 0 ? Promise.resolve() : (async () => {
+    for (; ; ) {
+      const next = await reader.next();
+      if (next.done === true || stopped()) {
+        return;
+      }
+      press(next.value);
+      if (stopped()) {
+        return;
+      }
+    }
+  })();
+  const interval = options.intervalMs ?? 120;
+  const clear = `${ESC}[H${ESC}[2J${ESC}[3J`;
+  try {
+    if (!options.live) {
+      options.write(`${frame()}
+`);
+      return 0;
+    }
+    options.write(`${ESC}[?25l`);
+    for (; !screen.stop; tick += 1) {
+      if (screen.notice !== "" && tick >= screen.noticeUntil) {
+        screen.notice = "";
+      }
+      options.write(clear + frame());
+      if (options.maxTicks !== void 0 && tick + 1 >= options.maxTicks) {
+        break;
+      }
+      await new Promise((resolve2) => setTimeout(resolve2, interval));
+    }
+    return 0;
+  } finally {
+    if (options.live) {
+      options.write(`${ESC}[?25h
+`);
+    }
+    process.off("SIGINT", onSignal);
+    process.off("SIGTERM", onSignal);
+    screen.stop = true;
+    await Promise.race([
+      (async () => {
+        await reader?.return?.(void 0);
+        await reading;
+      })(),
+      new Promise((resolve2) => setTimeout(resolve2, 50).unref())
+    ]);
+    journal?.close();
+  }
+}
+
+// src/cli.ts
+var NODE_MAJOR = Number(process.versions.node.split(".")[0]);
+if (NODE_MAJOR < 22) {
+  process.stderr.write(
+    `synartesis: needs Node 22 or newer, and this is ${process.version}.
+`
+  );
+  process.exit(2);
+}
+var COMMANDS = `
+  synartesis                                      the screen; everything below,
+                                                  driven with the arrow keys
+  synartesis init <server> -- <command> [args...]  [--manifest <path>]
+  synartesis check [--manifest <path>]
+  synartesis list [--journal <path>]
+  synartesis show <runId> [--journal <path>]
+  synartesis gates [--journal <path>]
+  synartesis close [runId] [--journal <path>]
+  synartesis proxy --manifest <path> [--journal <path>]   what your agent runs
+  synartesis watch [--by <name>] [--journal <path>]
+  synartesis approve [actionId|--all] [--by <name>] [--journal <path>]
+  synartesis deny [actionId|--all] [--by <name>] [--reason <text>] [--journal <path>]
+  synartesis undo [runId] [--to <seq>] [--dry-run] [--replan]
+                          [--manifest <path>] [--journal <path>]
+
+close ends a run left active by a proxy that was killed; nothing guesses at
+that, since several proxies can share one journal.
+
+Ids may be shortened to any unambiguous prefix. show and undo default to the
+most recent run; approve and deny default to the only request waiting. init
+adds to an existing manifest rather than replacing it.
+
+watch is the one to leave running. Anything held for approval appears there,
+and a and d answer it without a second terminal or an id to copy.
+
+  --manifest  synartesis.yaml, looked for here and upwards, then in the home
+  --journal   beside the manifest, or the one in the home
+  --to        lowest sequence to undo; earlier actions are left alone
+  --by        who is deciding; defaults to the logged-in user
+  --all       approve or deny everything currently waiting
+  --once      watch prints the current state and exits
+  --json      machine-readable output for list, show and gates
+  --dry-run   read current state and print the plan without changing anything
+  --replan    rebuild each undo from the current manifest, for a run recorded
+              under a policy that turned out to be wrong
+
+Neither path usually needs giving. A policy that belongs to a project sits in
+it and is found from any directory inside it, the way a version control tool
+finds its root; anything else lives in ~/.synartesis, which is where the
+journal is too. Set SYNARTESIS_HOME to put that somewhere else.
+
+Exit codes: 0 complete, 1 halted or partial, 2 bad usage or configuration.
+`;
+var UsageError = class extends Error {
+};
+function flag(argv, name) {
+  const at = argv.indexOf(name);
+  if (at === -1) {
+    return void 0;
+  }
+  const value = argv[at + 1];
+  if (value === void 0 || value.startsWith("--")) {
+    throw new UsageError(`${name} needs a value`);
+  }
+  return value;
+}
+function positional(argv) {
+  const skip = /* @__PURE__ */ new Set(["--manifest", "--journal", "--to", "--by", "--reason", "--gate-timeout"]);
+  const values = [];
+  const end = argv.indexOf("--");
+  const ours = end === -1 ? argv : argv.slice(0, end);
+  for (let i = 0; i < ours.length; i += 1) {
+    const token = ours[i] ?? "";
+    if (skip.has(token)) {
+      i += 1;
+      continue;
+    }
+    if (!token.startsWith("--")) {
+      values.push(token);
+    }
+  }
+  return values;
+}
+async function runCheck(argv) {
+  const path = findManifest(flag(argv, "--manifest"));
+  const manifest = loadManifest(path);
+  const upstreams = [];
+  try {
+    for (const [name, spec] of Object.entries(manifest.servers)) {
+      upstreams.push(
+        await connectStdioUpstream({
+          name,
+          command: spec.command,
+          args: spec.args,
+          stderr: "capture",
+          ...spec.env === void 0 ? {} : { env: spec.env }
+        })
+      );
+    }
+    await verifyAgainstServers(upstreams, manifest);
+  } finally {
+    for (const upstream of upstreams) {
+      await upstream.close();
+    }
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const policy of manifest.tools) {
+    counts.set(policy.class, (counts.get(policy.class) ?? 0) + 1);
+  }
+  const gated = manifest.tools.filter((policy) => policy.gate !== "never").length;
+  out("");
+  out(`  ${style.label("policy")}  ${style.strong(path)}`);
+  out(`  ${rule(54)}`);
+  out("");
+  out(`  ${style.quiet("servers ")} ${Object.keys(manifest.servers).join(", ")}`);
+  out(`  ${style.quiet("policies")} ${[...counts].map(([k, v]) => `${String(v)} ${k}`).join(", ")}`);
+  out(`  ${style.quiet("guarded ")} ${style.accent(String(gated))}`);
+  out("");
+  out(`  ${style.quiet("Anything not mentioned here is treated as irreversible and guarded.")}`);
+  out("");
+  return 0;
+}
+async function runInit(argv) {
+  const name = positional(argv)[1];
+  const separator = argv.indexOf("--");
+  const command = separator === -1 ? void 0 : argv[separator + 1];
+  if (name === void 0 || command === void 0) {
+    throw new UsageError("init needs a server name and a command, as: init crm -- npx -y some-mcp-server");
+  }
+  if (name.includes(".") || name.includes("__")) {
+    throw new UsageError(`server name ${name} may not contain "." or "__"; both qualify tool names`);
+  }
+  const path = findManifest(flag(argv, "--manifest"));
+  const force = argv.includes("--force");
+  const present = existsSync3(path);
+  if (present && force) {
+    throw new UsageError(
+      `--force would discard ${path}. Delete it yourself if that is what you want; init will otherwise add to it.`
+    );
+  }
+  const yaml = await draftManifest({
+    name,
+    command,
+    args: argv.slice(separator + 2),
+    ...present ? { existing: readFileSync(path, "utf8") } : {}
+  });
+  parseManifest(yaml, path);
+  mkdirSync(dirname(resolve(path)), { recursive: true });
+  writeFileSync(path, yaml);
+  out("");
+  out(`  ${style.label(present ? "extended" : "wrote")}  ${style.strong(path)}`);
+  out(`  ${rule(54)}`);
+  out("");
+  out(`  ${style.quiet("Every tool is guarded until you say how to undo it.")}`);
+  out(`  ${style.quiet("Work through the TODOs, then point your MCP client at:")}`);
+  out("");
+  out(`  ${style.accent(`${proxyCommand()} --manifest ${resolve(path)}`)}`);
+  out("");
+  return 0;
+}
+function pick(candidates, given, noun, newest = false) {
+  const listed = (items) => items.map((item) => `  ${item.id}`).join("\n");
+  if (given === void 0) {
+    const [only, ...rest2] = candidates;
+    if (only === void 0) {
+      throw new UsageError(`there is no ${noun.one} to act on`);
+    }
+    if (rest2.length > 0 && !newest) {
+      throw new UsageError(
+        `there are ${String(candidates.length)} ${noun.many}; name one, or use --all:
+${listed(candidates)}`
+      );
+    }
+    return only;
+  }
+  const exact = candidates.find((item) => item.id === given);
+  if (exact !== void 0) {
+    return exact;
+  }
+  const matches = candidates.filter((item) => item.id.startsWith(given));
+  const [first, ...rest] = matches;
+  if (first === void 0) {
+    throw new UsageError(`no ${noun.one} matches ${given}`);
+  }
+  if (rest.length > 0) {
+    throw new UsageError(
+      `${given} matches ${String(matches.length)} ${noun.many}:
+${listed(matches)}`
+    );
+  }
+  return first;
+}
+var RUN = { one: "run", many: "runs" };
+var WAITING = { one: "action awaiting approval", many: "actions awaiting approval" };
+process.stdout.on("error", (error) => {
+  if (error.code === "EPIPE") {
+    process.exit(0);
+  }
+  throw error;
+});
+function out(line2) {
+  process.stdout.write(`${line2}
+`);
+}
+function runList(journal, asJson) {
+  const runs = [...journal.listRuns()].reverse();
+  if (asJson) {
+    out(JSON.stringify(runs.map((run) => ({ ...run, actions: journal.getActions(run.id).length }))));
+    return 0;
+  }
+  if (runs.length === 0) {
+    out("no runs recorded");
+    return 0;
+  }
+  out("");
+  out(`  ${style.label("runs")}  ${style.quiet("most recent first")}`);
+  out(`  ${rule(96)}`);
+  out("");
+  out(
+    style.quiet(
+      `  ${"run".padEnd(36)}  ${"started".padEnd(24)}  ${"status".padEnd(12)}  actions  agent`
+    )
+  );
+  for (const run of runs) {
+    const actions = journal.getActions(run.id);
+    const unknown = actions.filter((action) => action.status === "pending").length;
+    const waiting = actions.filter((action) => action.status === "gated").length;
+    const notes = [
+      unknown === 0 ? "" : `${String(unknown)} of unknown outcome`,
+      waiting === 0 ? "" : `${String(waiting)} awaiting approval`
+    ].filter((note2) => note2 !== "");
+    const note = notes.length === 0 ? "" : `  ${style.accent(`(${notes.join("; ")})`)}`;
+    out(
+      `  ${style.strong(run.id)}  ${style.quiet(run.startedAt)}  ${run.status.padEnd(12)}  ${String(actions.length).padStart(7)}  ${run.label ?? "-"}${note}`
+    );
+  }
+  out("");
+  return 0;
+}
+function runShow(argv, journal, asJson) {
+  const runs = [...journal.listRuns()].reverse();
+  const run = pick(runs, positional(argv)[1], RUN, true);
+  const runId = run.id;
+  if (asJson) {
+    out(JSON.stringify({ run, actions: journal.getActions(runId) }));
+    return 0;
+  }
+  out("");
+  out(`  ${style.label("run")}  ${style.strong(run.id)}`);
+  out(`  ${rule(54)}`);
+  out("");
+  out(`  ${style.quiet("agent  ")} ${run.label ?? "-"}`);
+  out(`  ${style.quiet("started")} ${run.startedAt}`);
+  out(
+    `  ${style.quiet("status ")} ${run.status}` + (run.endedAt === void 0 ? "" : style.quiet(`  ended ${run.endedAt}`))
+  );
+  const actions = journal.getActions(runId);
+  if (actions.length === 0) {
+    out("");
+    out("no actions recorded");
+    return 0;
+  }
+  out("");
+  out("");
+  out(`  ${style.label("timeline")}`);
+  out(`  ${rule(72)}`);
+  out("");
+  for (const action of actions) {
+    out(
+      `  ${style.quiet(String(action.seq).padStart(3))}  ${badgeOf(action)} ${statusOf2(action)}  ${style.strong(`${action.server}.${action.tool}`)}`
+    );
+    out(`       ${style.quiet(truncate3(JSON.stringify(action.args), 96))}`);
+    if (action.approvedAt !== void 0) {
+      const verb = action.status === "denied" ? "denied" : "approved";
+      out(
+        `       ${style.accent(`${verb} by ${action.approvedBy ?? "nobody"}`)} ${style.quiet(`at ${action.approvedAt}`)}`
+      );
+    }
+    if (action.error !== void 0) {
+      out(`       ${style.quiet(`note: ${truncate3(action.error, 200)}`)}`);
+    }
+    if (action.inverse !== void 0) {
+      out(`       ${style.quiet("undo:")} ${truncate3(JSON.stringify(action.inverse), 200)}`);
+    }
+  }
+  out("");
+  out(`  ${summarise2(actions)}`);
+  out("");
+  return 0;
+}
+var CLASS_MARK = {
+  readonly: "\xB7",
+  reversible: "\u2190",
+  compensable: "\u2248",
+  irreversible: "!",
+  unclassified: "?"
+};
+var BADGE_WIDTH = "irreversible".length + 2;
+function badgeOf(action) {
+  const plain = `${CLASS_MARK[action.class]} ${action.class}`.padEnd(BADGE_WIDTH);
+  return action.class === "irreversible" ? style.accent(plain) : style.quiet(plain);
+}
+function statusOf2(action) {
+  const text = labelFor(action).padEnd(13);
+  if (wasRefused(action)) {
+    return style.accent(text);
+  }
+  if (action.status === "gated") {
+    return style.strong(text);
+  }
+  return style.quiet(text);
+}
+function wrapped(text, width) {
+  const lines = [];
+  let line2 = "";
+  for (const word of text.split(/\s+/).filter((part) => part !== "")) {
+    if (line2 === "") {
+      line2 = word;
+    } else if (line2.length + 1 + word.length <= width) {
+      line2 = `${line2} ${word}`;
+    } else {
+      lines.push(line2);
+      line2 = word;
+    }
+  }
+  if (line2 !== "") {
+    lines.push(line2);
+  }
+  return lines;
+}
+function truncate3(text, limit) {
+  return text.length <= limit ? text : `${text.slice(0, limit - 3)}...`;
+}
+function summarise2(actions) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const action of actions) {
+    counts.set(action.status, (counts.get(action.status) ?? 0) + 1);
+  }
+  const parts = [...counts].sort(([a], [b]) => a < b ? -1 : 1).map(([k, v]) => `${String(v)} ${k}`);
+  const undoable = actions.filter((a) => a.inverse !== void 0).length;
+  return `${String(actions.length)} actions: ${parts.join(", ")} | ${String(undoable)} with a recorded undo`;
+}
+var journalArg = "";
+function runClose(argv, journal) {
+  const active = journal.listRuns().filter((candidate) => candidate.status === "active");
+  const run = pick([...active].reverse(), positional(argv)[1], RUN, true);
+  const closed = journal.closeAbandonedRun(run.id);
+  out("");
+  out(
+    closed ? `  ${style.label("closed")}  ${style.strong(run.id)}` : `  ${style.quiet(`${run.id} was not active.`)}`
+  );
+  out("");
+  return closed ? 0 : 1;
+}
+function runGates(journal, asJson) {
+  const waiting = journal.listGated();
+  if (asJson) {
+    out(JSON.stringify(waiting));
+    return 0;
+  }
+  if (waiting.length === 0) {
+    out("");
+    out(`  ${style.quiet("Nothing is waiting for a decision.")}`);
+    out("");
+    return 0;
+  }
+  out("");
+  out(`  ${style.label("awaiting approval")}`);
+  out(`  ${rule(72)}`);
+  out("");
+  for (const action of waiting) {
+    out(`  ${style.strong(action.id)}  ${style.quiet(action.ts)}`);
+    out(`  ${style.accent(`${action.server}.${action.tool}`)}  ${style.quiet(truncate3(JSON.stringify(action.args), 88))}`);
+    for (const [at, line2] of wrapped(action.error ?? "held by policy", 76).entries()) {
+      out(`  ${at === 0 ? style.quiet(action.class) : " ".repeat(action.class.length)}  ${style.quiet(line2)}`);
+    }
+    out("");
+  }
+  const self = cliCommand();
+  out(
+    `  ${style.quiet(`${self} approve`)} ${style.accent(waiting[0]?.id.slice(0, 8) ?? "<id>")} ${style.quiet(`--by <name>${journalArg}`)}`
+  );
+  out(`  ${style.quiet(`${self} approve --all --by <name>${journalArg}`)}`);
+  out("");
+  return 0;
+}
+function runDecision(argv, journal, approving) {
+  const waiting = journal.listGated();
+  const given = positional(argv)[1];
+  const by = flag(argv, "--by") ?? process.env["USER"] ?? process.env["LOGNAME"] ?? "unknown";
+  const reason = flag(argv, "--reason") ?? "denied by operator";
+  if (given !== void 0) {
+    const settled = journal.getAction(given);
+    if (settled !== void 0 && settled.status !== "gated") {
+      process.stderr.write(
+        `synartesis: ${given} is no longer awaiting approval (it is ${settled.status})
+`
+      );
+      return 1;
+    }
+  }
+  const targets = argv.includes("--all") ? waiting : [pick(waiting, given, WAITING)];
+  if (targets.length === 0) {
+    out("nothing is awaiting approval");
+    return 0;
+  }
+  let failed = 0;
+  for (const action of targets) {
+    const changed = approving ? journal.approve(action.id, by) : journal.deny(action.id, by, reason);
+    if (!changed) {
+      const now = journal.getAction(action.id);
+      process.stderr.write(
+        `synartesis: ${action.id} is no longer awaiting approval (it is ${now?.status ?? "gone"})
+`
+      );
+      failed += 1;
+      continue;
+    }
+    out(
+      `  ${style.accent(approving ? "approved" : "denied")} ${style.strong(`${action.server}.${action.tool}`)} ${style.quiet(action.id)}`
+    );
+  }
+  return failed === 0 ? 0 : 1;
+}
+function report(result) {
+  out("");
+  out(`  ${style.label(result.dryRun ? "dry run" : "undo")}  ${style.strong(result.runId)}`);
+  out(`  ${rule(72)}`);
+  out("");
+  for (const step of result.steps) {
+    const unverified = step.kind === "revert" && !step.verified ? `  ${style.accent("[unverified]")}` : "";
+    const kind = step.kind === "halt" || step.kind === "permanent" ? style.accent(step.kind.padEnd(16)) : step.kind.padEnd(16);
+    out(
+      `  ${style.quiet(String(step.seq).padStart(3))}  ${kind} ${style.strong(`${step.server}.${step.tool}`)}  ${style.quiet(step.reason)}${unverified}`
+    );
+    if (step.plan !== void 0 && step.kind === "revert") {
+      const verb = `${step.replanned === true ? "replanned, " : ""}${result.dryRun ? "would call" : "called"}`;
+      out(
+        `       ${style.quiet(verb)} ${step.plan.server}.${step.plan.tool} ` + style.quiet(truncate3(JSON.stringify(step.plan.args), 120))
+      );
+    }
+  }
+  if (result.halted !== void 0) {
+    out("");
+    out(
+      `  ${style.accent("halted")} ${style.quiet(`at sequence ${String(result.halted.seq)}`)}  ${result.halted.reason}`
+    );
+    if (result.halted.detail !== "") {
+      for (const line2 of result.halted.detail.split("\n")) {
+        out(`  ${style.quiet(line2)}`);
+      }
+    }
+  }
+  const permanent = result.steps.filter((step) => step.kind === "permanent");
+  if (permanent.length > 0) {
+    out("");
+    out(
+      `  ${style.quiet(`${String(permanent.length)} action${permanent.length === 1 ? "" : "s"} could not be undone and ${permanent.length === 1 ? "was" : "were"} left in place.`)}`
+    );
+  }
+  out("");
+  out(
+    `  ${style.label("result")}  ${result.status === "rolled_back" ? result.status : style.accent(result.status)}`
+  );
+  out("");
+  return result.status === "rolled_back" ? 0 : 1;
+}
+async function performUndo(manifestPath, journal, runId, options) {
+  const manifest = loadManifest(manifestPath);
+  const upstreams = [];
+  try {
+    for (const [name, spec] of Object.entries(manifest.servers)) {
+      upstreams.push(
+        await connectStdioUpstream({
+          name,
+          command: spec.command,
+          args: spec.args,
+          stderr: "capture",
+          ...spec.env === void 0 ? {} : { env: spec.env }
+        })
+      );
+    }
+    return await rollback({
+      journal,
+      router: createRouter(upstreams, manifest),
+      runId,
+      ...options.toSeq === void 0 ? {} : { toSeq: options.toSeq },
+      dryRun: options.dryRun,
+      ...options.replan === true ? { replanWith: manifest } : {}
+    });
+  } finally {
+    for (const upstream of upstreams) {
+      await upstream.close();
+    }
+  }
+}
+async function runUndo(argv, journal) {
+  const runId = pick([...journal.listRuns()].reverse(), positional(argv)[1], RUN, true).id;
+  const rawTo = flag(argv, "--to");
+  const toSeq = rawTo === void 0 ? void 0 : Number(rawTo);
+  if (toSeq !== void 0 && (!Number.isInteger(toSeq) || toSeq < 1)) {
+    throw new UsageError("--to needs a positive whole number");
+  }
+  if (toSeq !== void 0) {
+    const highest = journal.getActions(runId).reduce((top, action) => Math.max(top, action.seq), 0);
+    if (toSeq > highest) {
+      throw new UsageError(
+        `--to ${String(toSeq)} is past the end of this run, which goes up to ${String(highest)}`
+      );
+    }
+  }
+  return report(
+    await performUndo(findManifest(flag(argv, "--manifest")), journal, runId, {
+      dryRun: argv.includes("--dry-run"),
+      ...toSeq === void 0 ? {} : { toSeq },
+      replan: argv.includes("--replan")
+    })
+  );
+}
+async function main(argv) {
+  const command = positional(argv)[0];
+  if (command === "proxy") {
+    await import("./proxy.js");
+    return 0;
+  }
+  if (argv.includes("--help") || argv.includes("-h")) {
+    process.stdout.write(`${banner()}
+${COMMANDS}`);
+    return 0;
+  }
+  if (command === void 0) {
+    const manifestPath = findManifest(flag(argv, "--manifest"));
+    const journalPath2 = findJournal(flag(argv, "--journal"), manifestPath);
+    return await openConsole({
+      journalPath: journalPath2,
+      write: (text) => process.stdout.write(text),
+      live: process.stdout.isTTY,
+      decideAs: flag(argv, "--by") ?? process.env["USER"] ?? process.env["LOGNAME"] ?? "unknown",
+      undo: async (runId, dryRun) => {
+        const journal2 = openJournal(journalPath2, { mustExist: true });
+        try {
+          return await performUndo(manifestPath, journal2, runId, { dryRun });
+        } finally {
+          journal2.close();
+        }
+      }
+    });
+  }
+  if (command === "init") {
+    return await runInit(argv);
+  }
+  if (command === "check") {
+    return await runCheck(argv);
+  }
+  const asJson = argv.includes("--json");
+  const given = flag(argv, "--journal");
+  const journalPath = findJournal(given, findManifest(flag(argv, "--manifest")));
+  if (command === "watch") {
+    const live = process.stdout.isTTY && !argv.includes("--once");
+    return await watch({
+      journalPath,
+      approveWith: cliCommand(),
+      write: (text) => process.stdout.write(text),
+      live,
+      // A decision has to be attributable, so the view can only make one when
+      // it knows whose it is.
+      decideAs: flag(argv, "--by") ?? process.env["USER"] ?? process.env["LOGNAME"] ?? "unknown"
+    });
+  }
+  journalArg = given === void 0 ? "" : ` --journal ${resolve(given)}`;
+  const journal = openJournal(journalPath, { mustExist: true });
+  try {
+    switch (command) {
+      case "list":
+        return runList(journal, asJson);
+      case "show":
+        return runShow(argv, journal, asJson);
+      case "close":
+        return runClose(argv, journal);
+      case "gates":
+        return runGates(journal, asJson);
+      case "approve":
+        return runDecision(argv, journal, true);
+      case "deny":
+        return runDecision(argv, journal, false);
+      case "undo":
+        return await runUndo(argv, journal);
+      default:
+        throw new UsageError(`unknown command ${command}`);
+    }
+  } finally {
+    journal.close();
+  }
+}
+try {
+  process.exitCode = await main(process.argv.slice(2));
+} catch (error) {
+  if (error instanceof UsageError) {
+    process.stderr.write(`synartesis: ${error.message}
+
+${COMMANDS}`);
+    process.exitCode = 2;
+  } else if (error instanceof ManifestError) {
+    process.stderr.write(`synartesis: ${error.message}
+`);
+    process.exitCode = 2;
+  } else if (error instanceof SynartesisError) {
+    process.stderr.write(`synartesis: ${error.message}
+`);
+    process.exitCode = 1;
+  } else {
+    process.stderr.write(`synartesis: ${describe(error)}
+`);
+    process.exitCode = 1;
+  }
+}
+//# sourceMappingURL=cli.js.map