synartesis 0.6.12 → 0.6.15

package/dist/{chunk-FUVEHRJP.js → chunk-OODDXM36.js}

@@ -6,6 +6,19 @@ import {
   describe
 } from "./chunk-YVOO3PTV.js";
 
+// src/proxy/flags.ts
+var PROXY_FLAGS = [
+  "--manifest",
+  "--journal",
+  "--server",
+  "--gate-timeout",
+  "--log-level",
+  "--http",
+  "--http-host",
+  "--http-idle",
+  "--token"
+];
+
 // src/invocation.ts
 import { spawnSync } from "child_process";
 import { accessSync, constants } from "fs";
@@ -131,23 +144,25 @@ var INK = `${ESC}38;2;214;201;197m`;
 var DIM = `${ESC}2m`;
 var BOLD = `${ESC}1m`;
 var RESET = `${ESC}0m`;
-var enabled = process.env["NO_COLOR"] === void 0 && process.env["TERM"] !== "dumb" && process.stdout.isTTY;
-function paint(codes, text) {
-  return enabled ? `${codes}${text}${RESET}` : text;
+function usable(stream) {
+  return process.env["NO_COLOR"] === void 0 && process.env["TERM"] !== "dumb" && stream.isTTY;
 }
 function spaced(text) {
   return Array.from(text).join(" ");
 }
-var style = {
-  /** A section label: small, capital, spaced out. */
-  label: (text) => paint(ACCENT + DIM, spaced(text.toUpperCase())),
-  heading: (text) => paint(INK, text.toUpperCase()),
-  accent: (text) => paint(ACCENT, text),
-  strong: (text) => paint(INK, text),
-  quiet: (text) => paint(DIM, text),
-  /** Off-white on oxblood, the way the wordmark is set. */
-  plate: (text) => paint(ON_ACCENT + BOLD, ` ${text} `)
-};
+function palette(on) {
+  const paint = (codes, text) => on ? `${codes}${text}${RESET}` : text;
+  return {
+    label: (text) => paint(ACCENT + DIM, spaced(text.toUpperCase())),
+    heading: (text) => paint(INK, text.toUpperCase()),
+    accent: (text) => paint(ACCENT, text),
+    strong: (text) => paint(INK, text),
+    quiet: (text) => paint(DIM, text),
+    plate: (text) => paint(ON_ACCENT + BOLD, ` ${text} `)
+  };
+}
+var style = palette(usable(process.stdout));
+var errorStyle = palette(usable(process.stderr));
 var WORDMARK = spaced("SYNARTESIS");
 function meander(width) {
   const unit = "\u2517\u2501\u2513\u250F\u2501\u251B";
@@ -257,6 +272,47 @@ CREATE INDEX IF NOT EXISTS actions_by_run ON actions(run_id, seq);
 -- two-kilobyte snapshots: 61ms to 0.01ms, and 56ms to 0.00ms.
 CREATE INDEX IF NOT EXISTS actions_approved ON actions(server, tool, status, approved_at);
 CREATE INDEX IF NOT EXISTS actions_gated ON actions(status, ts);
+
+-- Covering, and that is the whole point. listRuns needs a count and three
+-- status tallies per run, and without this the group-by scans the table --
+-- which carries the snapshots, so the cost of listing sessions grew with the
+-- size of the data those sessions touched, not with how many there were.
+-- Adding status to the run index lets sqlite answer entirely from the index.
+-- Measured on forty runs of five hundred actions with two-kilobyte snapshots,
+-- a hundred-megabyte journal: 76ms to 2ms.
+--
+-- Added the same way as the two above and for the same reason: no row changes,
+-- no meaning changes, IF NOT EXISTS makes it idempotent, and an older build
+-- opening the same file afterwards neither notices nor cares.
+CREATE INDEX IF NOT EXISTS actions_run_status ON actions(run_id, status);
+
+-- Partial, which is what makes it small: newestUndoable asks for the newest run
+-- holding something an undo would reverse, and that is a handful of rows out of
+-- a table where every other row is a read, a refusal or something already put
+-- back. Without it the question can only be answered by reaching into the table
+-- to test inverse_json on every applied row -- and those rows carry the
+-- snapshots, so the cost of the hint at the foot of a session list grew with
+-- the size of the data rather than with the number of sessions, which is
+-- exactly what the index above was added to stop. Measured on sixty runs of a
+-- thousand actions with two-kilobyte snapshots, a 246MB journal: 56ms to
+-- 0.01ms.
+--
+-- newestUndoable names this index with INDEXED BY, and has to: left to choose,
+-- sqlite takes actions_gated for the status seek and then reads the rows. See
+-- the query for why that is preferred to running ANALYZE.
+--
+-- Added the same way as the three above and for the same reason: no row
+-- changes, no meaning changes, IF NOT EXISTS makes it idempotent, and an older
+-- build opening the same file afterwards neither notices nor cares.
+CREATE INDEX IF NOT EXISTS actions_undoable ON actions(run_id)
+  WHERE status = 'applied' AND inverse_json IS NOT NULL;
+
+-- Partial for the same reason: findPending runs on the way in to every write,
+-- looking for an earlier attempt at that exact call whose outcome was never
+-- established. Those are rare, so the index holds almost nothing -- while the
+-- rows it saves reading are the ones carrying the snapshots.
+CREATE INDEX IF NOT EXISTS actions_unresolved ON actions(run_id, server, tool)
+  WHERE status = 'pending';
 `;
 
 // src/journal/journal.ts
@@ -268,6 +324,13 @@ var runSchema = z.object({
   ended_at: z.string().nullable(),
   status: z.enum(["active", "complete", "rolled_back", "partial"])
 });
+var tallySchema = z.object({
+  run_id: z.string(),
+  actions: z.number(),
+  unknown: z.number().nullable(),
+  waiting: z.number().nullable(),
+  applied: z.number().nullable()
+});
 var actionSchema = z.object({
   id: z.string(),
   run_id: z.string(),
@@ -661,6 +724,17 @@ var SqliteJournal = class {
       return rows.find((row) => canonical(row.args) === wanted);
     });
   }
+  findPending(query) {
+    return this.#run("findPending", () => {
+      const rows = this.#db.prepare(
+        `SELECT * FROM actions INDEXED BY actions_unresolved
+            WHERE run_id = ? AND server = ? AND tool = ? AND status = 'pending'
+            ORDER BY seq`
+      ).all(query.runId, query.server, query.tool).map(toAction);
+      const wanted = canonical(query.args ?? {});
+      return rows.find((row) => canonical(row.args) === wanted);
+    });
+  }
   getAction(actionId) {
     return this.#run("getAction", () => {
       const raw = this.#db.prepare("SELECT * FROM actions WHERE id = ?").get(actionId);
@@ -699,6 +773,57 @@ var SqliteJournal = class {
       () => this.#db.prepare("SELECT * FROM actions WHERE run_id = ? ORDER BY seq").all(runId).map(toAction)
     );
   }
+  tallyRuns() {
+    return this.#run("tallyRuns", () => {
+      const rows = this.#db.prepare(
+        `SELECT run_id,
+                  COUNT(*) AS actions,
+                  SUM(status = 'pending') AS unknown,
+                  SUM(status = 'gated') AS waiting,
+                  SUM(status = 'applied') AS applied
+             FROM actions
+            GROUP BY run_id`
+      ).all();
+      const tally = /* @__PURE__ */ new Map();
+      for (const row of rows) {
+        const counts = tallySchema.parse(row);
+        tally.set(counts.run_id, {
+          actions: counts.actions,
+          unknown: counts.unknown ?? 0,
+          waiting: counts.waiting ?? 0,
+          applied: counts.applied ?? 0
+        });
+      }
+      return tally;
+    });
+  }
+  /**
+   * The newest run that still holds something an undo would put back.
+   *
+   * Not simply the newest run, and not the newest run with an applied action
+   * either. A client that connects and reads opens a session like any other,
+   * and reads are recorded and left `applied` -- rollback steps past them --
+   * so `applied` alone regularly points at a session in which nothing
+   * happened. What makes a run worth offering is an action that is still
+   * applied and carries the inverse that would reverse it, which is the same
+   * test `undo` itself uses when it goes looking for the session somebody
+   * meant. That inverse is also what excludes the reads: the manifest loader
+   * refuses an inverse on a readonly tool, so a read can never carry one, and
+   * a second condition on the class would be a condition that cannot fire.
+   */
+  newestUndoable() {
+    return this.#run("newestUndoable", () => {
+      const raw = this.#db.prepare(
+        `SELECT * FROM runs
+            WHERE id IN (SELECT run_id FROM actions INDEXED BY actions_undoable
+                          WHERE status = 'applied'
+                            AND inverse_json IS NOT NULL)
+            ORDER BY started_at DESC, rowid DESC
+            LIMIT 1`
+      ).get();
+      return raw === void 0 ? void 0 : toRun(raw);
+    });
+  }
   recentActions(limit) {
     return this.#run(
       "recentActions",
@@ -973,17 +1098,20 @@ var toolPolicy = z2.strictObject({
   gate: z2.enum(["always", "on_write", "never"]).optional(),
   refusal: z2.enum(["uncertain", "clean"]).optional(),
   snapshot: callTemplate.optional(),
-  inverse: callTemplate.optional()
+  inverse: callTemplate.optional(),
+  verify: callTemplate.optional()
 });
 var serverSpec = z2.strictObject({
   command: z2.string().min(1),
   args: z2.array(z2.string()).default([]),
-  env: z2.record(z2.string(), z2.string()).optional()
+  env: z2.record(z2.string(), z2.string()).optional(),
+  provenance: z2.enum(["live", "documented"]).optional()
 });
 var manifestSchema = z2.strictObject({
   version: z2.literal(1),
   servers: z2.record(z2.string(), serverSpec),
-  tools: z2.array(toolPolicy).default([])
+  tools: z2.array(toolPolicy).default([]),
+  pins: z2.record(z2.string(), z2.record(z2.string(), z2.string().min(1))).optional()
 });
 var Source = class {
   constructor(doc, lines, file) {
@@ -1066,6 +1194,11 @@ function validate(source, manifest) {
   if (servers.length === 0) {
     source.fail(["servers"], "at least one server must be declared");
   }
+  for (const name of Object.keys(manifest.pins ?? {})) {
+    if (!servers.includes(name)) {
+      source.fail(["pins", name], `pins name server ${name}, which is not declared`);
+    }
+  }
   const seen = /* @__PURE__ */ new Map();
   manifest.tools.forEach((policy, index) => {
     const path = ["tools", index];
@@ -1087,6 +1220,9 @@ function validate(source, manifest) {
         `${policy.match} names server ${segment}, which is not declared`
       );
     }
+    if (policy.verify !== void 0 && policy.class === "readonly") {
+      source.fail([...path, "verify"], "a readonly tool has no post-state to check for drift");
+    }
     const needsInverse = policy.class === "reversible" || policy.class === "compensable";
     if (needsInverse && policy.inverse === void 0) {
       source.fail(path, `a ${policy.class} tool must declare an inverse`);
@@ -1130,7 +1266,8 @@ function withGate(policy) {
     gate,
     refusal: policy.refusal ?? "uncertain",
     ...policy.snapshot === void 0 ? {} : { snapshot: toCall(policy.snapshot) },
-    ...policy.inverse === void 0 ? {} : { inverse: toCall(policy.inverse) }
+    ...policy.inverse === void 0 ? {} : { inverse: toCall(policy.inverse) },
+    ...policy.verify === void 0 ? {} : { verify: toCall(policy.verify) }
   };
 }
 function parseManifest(text, file) {
@@ -1166,11 +1303,13 @@ function parseManifest(text, file) {
         {
           command: spec.command,
           args: spec.args,
-          ...spec.env === void 0 ? {} : { env: expandEnvironment(source, ["servers", name], spec.env) }
+          ...spec.env === void 0 ? {} : { env: expandEnvironment(source, ["servers", name], spec.env) },
+          ...spec.provenance === void 0 ? {} : { provenance: spec.provenance }
         }
       ])
     ),
-    tools: parsed.data.tools.map(withGate)
+    tools: parsed.data.tools.map(withGate),
+    ...parsed.data.pins === void 0 ? {} : { pins: parsed.data.pins }
   };
   validate(source, manifest);
   return manifest;
@@ -1193,8 +1332,41 @@ function loadManifest(path) {
   return parseManifest(text, path);
 }
 
-// src/manifest/verify.ts
-import { z as z3 } from "zod";
+// src/manifest/pin.ts
+import { createHash } from "crypto";
+
+// src/manifest/match.ts
+function toRegExp(pattern) {
+  const source = pattern.split("*").map((literal) => literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[^.]*");
+  return new RegExp(`^${source}$`);
+}
+function literalLength(pattern) {
+  return pattern.length - pattern.split("*").length + 1;
+}
+function failClosed(qualifiedName) {
+  return { match: qualifiedName, class: "irreversible", gate: "always", refusal: "uncertain" };
+}
+function createPolicyResolver(manifest) {
+  const compiled = manifest.tools.map((policy) => ({
+    policy,
+    test: toRegExp(policy.match),
+    specificity: literalLength(policy.match),
+    wildcards: policy.match.split("*").length - 1
+  })).sort((a, b) => b.specificity - a.specificity || a.wildcards - b.wildcards);
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    resolve(qualifiedName) {
+      const cached2 = cache.get(qualifiedName);
+      if (cached2 !== void 0) {
+        return cached2;
+      }
+      const hit = compiled.find((candidate) => candidate.test.test(qualifiedName));
+      const match = hit === void 0 ? { policy: failClosed(qualifiedName), matched: false } : { policy: hit.policy, matched: true };
+      cache.set(qualifiedName, match);
+      return match;
+    }
+  };
+}
 
 // src/manifest/types.ts
 function qualify(server, tool) {
@@ -1208,13 +1380,77 @@ function splitQualified(qualified) {
   return { server: qualified.slice(0, dot), tool: qualified.slice(dot + 1) };
 }
 
+// src/manifest/pin.ts
+function fingerprint(inputSchema) {
+  return `sha256:${createHash("sha256").update(canonical(inputSchema)).digest("hex")}`;
+}
+function auditPins(server, advertised, manifest) {
+  const pins = manifest.pins?.[server];
+  if (pins === void 0) {
+    return [];
+  }
+  const resolver = createPolicyResolver(manifest);
+  const faults = [];
+  const present = /* @__PURE__ */ new Set();
+  for (const tool of advertised) {
+    present.add(tool.name);
+    if (!resolver.resolve(qualify(server, tool.name)).matched) {
+      continue;
+    }
+    const found = fingerprint(tool.inputSchema);
+    const pinned = pins[tool.name];
+    if (pinned === void 0) {
+      faults.push({ kind: "unpinned", tool: tool.name, found });
+    } else if (pinned !== found) {
+      faults.push({ kind: "moved", tool: tool.name, pinned, found });
+    }
+  }
+  for (const name of Object.keys(pins)) {
+    if (!present.has(name)) {
+      faults.push({ kind: "gone", tool: name });
+    }
+  }
+  return faults;
+}
+function pinBlock(shapes, manifest) {
+  const resolver = createPolicyResolver(manifest);
+  const lines = ["pins:"];
+  for (const server of [...shapes.keys()].sort()) {
+    const governed = (shapes.get(server) ?? []).filter((tool) => resolver.resolve(qualify(server, tool.name)).matched).sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    if (governed.length === 0) {
+      continue;
+    }
+    lines.push(`  ${server}:`);
+    for (const tool of governed) {
+      lines.push(`    ${tool.name}: "${fingerprint(tool.inputSchema)}"`);
+    }
+  }
+  return lines.join("\n");
+}
+function explainPins(server, faults) {
+  return faults.map((fault) => {
+    switch (fault.kind) {
+      case "moved":
+        return `${server}.${fault.tool} no longer has the shape it was pinned at. Its policy was written for the old one, so the snapshot and inverse it carries may no longer describe this tool.
+      pinned ${fault.pinned}
+      now    ${fault.found}`;
+      case "unpinned":
+        return `${server}.${fault.tool} is governed by a policy and has no pin, on a server where everything else is pinned.
+      add    ${fault.tool}: "${fault.found}"`;
+      case "gone":
+        return `${server}.${fault.tool} is pinned but the server does not expose it, so the pin vouches for nothing. Remove it, or connect the server that has it.`;
+    }
+  });
+}
+
 // src/manifest/verify.ts
+import { z as z3 } from "zod";
 var listSchema = z3.looseObject({
-  tools: z3.array(z3.looseObject({ name: z3.string() })),
+  tools: z3.array(z3.looseObject({ name: z3.string(), inputSchema: z3.unknown() })),
   nextCursor: z3.string().optional()
 });
-async function toolNames(upstream) {
-  const names = /* @__PURE__ */ new Set();
+async function toolShapes(upstream) {
+  const shapes = [];
   let cursor;
   do {
     const page = listSchema.parse(
@@ -1224,16 +1460,19 @@ async function toolNames(upstream) {
       )
     );
     for (const tool of page.tools) {
-      names.add(tool.name);
+      shapes.push({ name: tool.name, inputSchema: tool.inputSchema });
     }
     cursor = page.nextCursor;
   } while (cursor !== void 0);
-  return names;
+  return shapes;
 }
 async function verifyAgainstServers(upstreams, manifest) {
+  const shapes = /* @__PURE__ */ new Map();
   const available = /* @__PURE__ */ new Map();
   for (const upstream of upstreams) {
-    available.set(upstream.name, await toolNames(upstream));
+    const advertised = await toolShapes(upstream);
+    shapes.set(upstream.name, advertised);
+    available.set(upstream.name, new Set(advertised.map((tool) => tool.name)));
   }
   const problems = [];
   const check = (qualified, role, match) => {
@@ -1259,11 +1498,50 @@ async function verifyAgainstServers(upstreams, manifest) {
     if (policy.inverse !== void 0) {
       check(policy.inverse.tool, "inverse", policy.match);
     }
+    if (policy.verify !== void 0) {
+      check(policy.verify.tool, "verify", policy.match);
+    }
   }
   if (problems.length > 0) {
     throw new ManifestError(`the manifest calls tools that do not exist:
   ${problems.join("\n  ")}`);
   }
+  const drifted = [];
+  for (const upstream of upstreams) {
+    const faults = auditPins(upstream.name, shapes.get(upstream.name) ?? [], manifest);
+    drifted.push(...explainPins(upstream.name, faults));
+  }
+  if (drifted.length > 0) {
+    throw new ManifestError(
+      "a pinned tool no longer matches the policy written for it:\n  " + drifted.join("\n  ") + "\n\n  Review what changed before trusting undo on these tools. `synartesis pin` prints the block for the servers you have now."
+    );
+  }
+}
+
+// src/manifest/standing.ts
+function standing(manifest) {
+  return Object.entries(manifest.servers).map(([server, spec]) => ({
+    server,
+    provenance: spec.provenance ?? "unstated"
+  }));
+}
+function untested(manifest) {
+  return standing(manifest).filter((entry) => entry.provenance === "documented").map((entry) => entry.server);
+}
+function describeStanding(entry) {
+  switch (entry.provenance) {
+    case "live":
+      return "checked against the real server";
+    case "documented":
+      return "written from documentation, never run against the real server";
+    case "unstated":
+      return "no claim either way";
+  }
+}
+function warnUntested(servers) {
+  const names = servers.join(", ");
+  const these = servers.length === 1 ? "this policy has" : "these policies have";
+  return `${names}: ${these} never been run against the real server. The classes and inverses here come from documentation, so undo may not work where it says it will. Run \`synartesis check\` against your own credentials, and expect to correct something.`;
 }
 
 // src/proxy/routing.ts
@@ -1329,6 +1607,25 @@ function describeError(error) {
   return error instanceof Error ? error.message : String(error);
 }
 var PROXY_CLIENT_INFO = { name: "synartesis-proxy", version: "0.0.0" };
+var STDERR_KEPT = 256 * 1024;
+var STDERR_SETTLE_MS = 200;
+function settled(stream, ms) {
+  if (stream.readableEnded === true) {
+    return Promise.resolve();
+  }
+  return new Promise((resolve2) => {
+    const done = () => {
+      clearTimeout(timer);
+      resolve2();
+    };
+    const timer = setTimeout(done, ms);
+    timer.unref?.();
+    stream.on("end", done);
+  });
+}
+function isReadable(stream) {
+  return typeof stream === "object" && stream !== null && "on" in stream && typeof stream.on === "function";
+}
 function bufferedText(stream) {
   if (typeof stream !== "object" || stream === null || !("read" in stream)) {
     return "";
@@ -1337,14 +1634,26 @@ function bufferedText(stream) {
   if (typeof read2 !== "function") {
     return "";
   }
-  const chunk = read2.call(stream);
-  if (typeof chunk === "string") {
-    return chunk;
+  let text = "";
+  for (; ; ) {
+    const chunk = read2.call(stream);
+    if (typeof chunk === "string") {
+      text += chunk;
+    } else if (Buffer.isBuffer(chunk)) {
+      text += chunk.toString("utf8");
+    } else {
+      break;
+    }
   }
-  return Buffer.isBuffer(chunk) ? chunk.toString("utf8") : "";
+  return text;
 }
+var NAMES_A_FAULT = /^(?:[A-Za-z]*(?:Error|Exception)\b|Cannot find |ENOENT\b|EACCES\b|EADDRINUSE\b|.*: command not found)/;
 function lastWords(text) {
-  const lines = text.split("\n").map((line) => line.trimEnd()).filter((line) => line.trim() !== "");
+  const lines = text.split("\n").map((line) => line.trim()).filter((line) => line !== "" && !/^at\s/.test(line));
+  const named = lines.find((line) => NAMES_A_FAULT.test(line));
+  if (named !== void 0) {
+    return named;
+  }
   const kept = lines.slice(-4).join("; ");
   return kept === "" ? void 0 : kept;
 }
@@ -1376,11 +1685,22 @@ async function start(spec) {
   });
   const client = new Client({ ...PROXY_CLIENT_INFO });
   let said = "";
+  const stderr = transport.stderr;
+  const listening = isReadable(stderr);
+  if (listening) {
+    stderr.on("data", (chunk) => {
+      if (chunk !== void 0 && said.length < STDERR_KEPT) {
+        said += typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      }
+    });
+  }
   try {
     await client.connect(transport);
   } catch (error) {
-    said = bufferedText(transport.stderr);
-    const reason = lastWords(said);
+    if (listening) {
+      await settled(stderr, STDERR_SETTLE_MS);
+    }
+    const reason = lastWords(said === "" ? bufferedText(transport.stderr) : said);
     throw new UpstreamError(
       spec.name,
       "connect",
@@ -1390,37 +1710,17 @@ async function start(spec) {
   return { client };
 }
 
-// src/manifest/match.ts
-function toRegExp(pattern) {
-  const source = pattern.split("*").map((literal) => literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[^.]*");
-  return new RegExp(`^${source}$`);
-}
-function literalLength(pattern) {
-  return pattern.length - pattern.split("*").length + 1;
-}
-function failClosed(qualifiedName) {
-  return { match: qualifiedName, class: "irreversible", gate: "always", refusal: "uncertain" };
-}
-function createPolicyResolver(manifest) {
-  const compiled = manifest.tools.map((policy) => ({
-    policy,
-    test: toRegExp(policy.match),
-    specificity: literalLength(policy.match),
-    wildcards: policy.match.split("*").length - 1
-  })).sort((a, b) => b.specificity - a.specificity || a.wildcards - b.wildcards);
-  const cache = /* @__PURE__ */ new Map();
-  return {
-    resolve(qualifiedName) {
-      const cached2 = cache.get(qualifiedName);
-      if (cached2 !== void 0) {
-        return cached2;
-      }
-      const hit = compiled.find((candidate) => candidate.test.test(qualifiedName));
-      const match = hit === void 0 ? { policy: failClosed(qualifiedName), matched: false } : { policy: hit.policy, matched: true };
-      cache.set(qualifiedName, match);
-      return match;
+// src/idempotency.ts
+var IDEMPOTENCY_META_KEY = "synartesis.dev/idempotency-key";
+function withIdempotencyKey(meta, key) {
+  const merged = {};
+  if (typeof meta === "object" && meta !== null) {
+    for (const [name, value] of Object.entries(meta)) {
+      merged[name] = value;
     }
-  };
+  }
+  merged[IDEMPOTENCY_META_KEY] = key;
+  return merged;
 }
 
 // src/proxy/snapshot.ts
@@ -1564,6 +1864,7 @@ async function observeState(router, read2, signal) {
 }
 
 export {
+  PROXY_FLAGS,
   cliCommand,
   cliCommandFrom,
   proxyCommand,
@@ -1571,6 +1872,7 @@ export {
   findManifest,
   findJournal,
   style,
+  errorStyle,
   WORDMARK,
   rule,
   mark,
@@ -1582,9 +1884,17 @@ export {
   wasRefused,
   parseManifest,
   loadManifest,
+  createPolicyResolver,
   qualify,
+  pinBlock,
+  toolShapes,
   verifyAgainstServers,
-  createPolicyResolver,
+  standing,
+  untested,
+  describeStanding,
+  warnUntested,
+  IDEMPOTENCY_META_KEY,
+  withIdempotencyKey,
   createRouter,
   refusal,
   toPayload,
@@ -1597,4 +1907,4 @@ export {
   observeState,
   connectStdioUpstream
 };
-//# sourceMappingURL=chunk-FUVEHRJP.js.map
+//# sourceMappingURL=chunk-OODDXM36.js.map