synartesis 0.8.8 → 0.9.1

package/dist/cli.js

@@ -1,368 +1,238 @@
 #!/usr/bin/env node
 import {
+  CLIENT_IDS,
+  ConfigError,
   IDEMPOTENCY_META_KEY,
   LIVE_IS_NOT_RECOVERY,
+  LOOKED_FOR,
   NOTHING_RECORDED_YET,
   PROXY_FLAGS,
   WORDMARK,
+  applyInstall,
+  applyUninstall,
   banner,
+  canNotify,
   canonical,
   cliCommand,
-  connectStdioUpstream,
+  clientEnvFor,
+  connectUpstream,
   counted,
   createPolicyResolver,
   createRouter,
   describeStanding,
+  desktopNotifier,
+  differing,
+  discover,
+  draftManifest,
   errorStyle,
   findJournal,
   findManifest,
+  fingerprint,
+  fingerprint2,
+  invokerFor,
+  isClientId,
+  isWrapped,
   labelFor,
+  listAll,
   loadManifest,
   observeState,
   openJournal,
   parseManifest,
-  pathBinaryMatches,
   pinBlock,
+  planInstall,
   planInverse,
   planRead,
   proxyCommand,
   qualify,
   resolvedRead,
   rule,
+  serversAt,
+  splitQualified,
   standing,
+  startAll,
+  startTogether,
   style,
   toPayload,
   toResolvedRead,
   toolShapes,
+  trustsMarks,
   ungoverned,
   untested,
+  upstreamEnv,
   verifyAgainstServers,
   warnUntested,
   wasRefused
-} from "./chunk-JE7MOCZO.js";
+} from "./chunk-H4SPMXQW.js";
 import {
   DriftConflict,
   ManifestError,
   RollbackHalted,
   SynartesisError,
-  UpstreamError,
   changedLines,
   describe
 } from "./chunk-YVOO3PTV.js";
 
 // src/cli.ts
+import { platform } from "os";
 import { spawn } from "child_process";
-import { existsSync as existsSync8, mkdirSync as mkdirSync2, readFileSync as readFileSync4, statSync, writeFileSync as writeFileSync3 } from "fs";
-import { dirname as dirname3, join as join3, resolve as resolve3 } from "path";
-import { fileURLToPath as fileURLToPath2 } from "url";
-
-// src/init/draft.ts
-import { z } from "zod";
-
-// src/init/known.ts
-import { existsSync, readFileSync } from "fs";
+import { existsSync as existsSync5, mkdirSync, readFileSync, renameSync, statSync, writeFileSync } from "fs";
+import { createInterface } from "readline/promises";
+import { dirname, join as join2, resolve } from "path";
 import { fileURLToPath } from "url";
-var KNOWN = [
-  { marker: "server-filesystem", manifest: "filesystem" },
-  { marker: "server-github", manifest: "github" },
-  { marker: "github-mcp-server", manifest: "github" },
-  { marker: "server-memory", manifest: "memory" },
-  { marker: "mcp-server-git", manifest: "git" },
-  { marker: "server-git", manifest: "git" }
-];
-function manifestsDir() {
-  for (const up of ["../manifests/", "../../manifests/"]) {
-    const candidate = fileURLToPath(new URL(up, import.meta.url));
-    if (existsSync(candidate)) {
-      return candidate;
-    }
-  }
-  return void 0;
-}
-function knownPolicyFor(command, args) {
-  const line2 = [command, ...args].join(" ");
-  const hit = KNOWN.find((entry) => line2.includes(entry.marker));
-  const dir = manifestsDir();
-  if (hit === void 0 || dir === void 0) {
-    return void 0;
-  }
-  const path = `${dir}${hit.manifest}.yaml`;
-  if (!existsSync(path)) {
-    return void 0;
-  }
-  try {
-    const text = readFileSync(path, "utf8");
-    const source = toolsBlock(text);
-    const key = serverKey(text);
-    if (source === void 0 || key === void 0) {
-      return void 0;
+
+// src/manifest/edit.ts
+import { isMap, isNode, isScalar, isSeq, parseDocument, stringify } from "yaml";
+var PolicyEditError = class extends Error {
+  name = "PolicyEditError";
+};
+function allowAlways(input) {
+  const { text, file, server, tool } = input;
+  const qualified = `${server}.${tool}`;
+  const before = parseManifest(text, file);
+  if (before.servers[server] === void 0) {
+    throw new PolicyEditError(`${file} has no server called ${server}`);
+  }
+  const current = createPolicyResolver(before).resolve(qualified);
+  const doc = parseDocument(text, { keepSourceTokens: true });
+  const tools = doc.get("tools", true);
+  const exact = isSeq(tools) ? tools.items.find((item) => isMap(item) && item.get("match") === qualified) : void 0;
+  let edited;
+  let how;
+  if (exact !== void 0) {
+    if (!isMap(exact) || exact.flow === true) {
+      throw new PolicyEditError(`the rule for ${qualified} is written on one line; change its gate by hand`);
+    }
+    const gate = exact.items.find((pair) => isScalar(pair.key) && pair.key.value === "gate");
+    if (gate !== void 0 && isScalar(gate.value) && gate.value.value === "never") {
+      how = "already";
+      edited = text;
+    } else if (gate !== void 0) {
+      const at = rangeOf(gate.value, qualified);
+      edited = text.slice(0, at[0]) + "never" + text.slice(at[1]);
+      how = "changed";
+    } else {
+      const cls = exact.items.find((pair) => isScalar(pair.key) && pair.key.value === "class");
+      const key = cls?.key;
+      if (cls === void 0 || !isScalar(key)) {
+        throw new PolicyEditError(`the rule for ${qualified} has no class; add one by hand first`);
+      }
+      const keyAt = rangeOf(key, qualified)[0];
+      const indent = " ".repeat(keyAt - lineStart(text, keyAt));
+      const lineEnd = endOfLine(text, rangeOf(cls.value, qualified)[1]);
+      edited = `${text.slice(0, lineEnd)}
+${indent}gate: never${text.slice(lineEnd)}`;
+      how = "changed";
     }
-    const rules = parseManifest(
-      `version: 1
-servers:
-  ${key}:
-    command: "true"
+  } else {
+    if (tools !== void 0 && (!isSeq(tools) || tools.flow === true || tools.items.length === 0)) {
+      throw new PolicyEditError(`the tools list in ${file} is not written one rule to a line; add the rule by hand`);
+    }
+    const base = current.matched ? { ...current.policy } : { class: "irreversible" };
+    delete base["match"];
+    delete base["refusal"];
+    const rule2 = { match: qualified, ...base, gate: "never" };
+    const said = [`# Let through without asking, by ${input.by} on ${input.date}.`];
+    if (base["class"] === "irreversible") {
+      said.push("# It still cannot be undone: it is recorded, and no longer held.");
+    }
+    const body = stringify([rule2], { lineWidth: 0 }).trimEnd().replace(/^- match: .*$/m, `- match: ${JSON.stringify(qualified)}`);
+    if (isSeq(tools)) {
+      const seqAt = rangeOf(tools, "tools")[0];
+      const indent = " ".repeat(seqAt - lineStart(text, seqAt));
+      const lines = [...said, ...body.split("\n")].map((line2) => indent + line2);
+      edited = insertAfter(text, rangeOf(tools, "tools")[2], `
+${lines.join("\n")}
+`);
+    } else {
+      edited = `${text.replace(/\n*$/, "\n")}
 tools:
-${source}
-`,
-      path
-    ).tools;
-    const claimed = /^\s*provenance:\s*(live|documented)\s*$/m.exec(text)?.[1];
-    return {
-      key,
-      rules,
-      name: hit.manifest,
-      source,
-      ...claimed === "live" || claimed === "documented" ? { provenance: claimed } : {}
-    };
-  } catch {
-    return void 0;
-  }
-}
-function toolsBlock(text) {
-  const at = text.search(/^tools:[ \t]*$/m);
-  if (at === -1) {
-    return void 0;
+${[...said, ...body.split("\n")].map((line2) => `  ${line2}`).join("\n")}
+`;
+    }
+    how = "added";
   }
-  const body = text.slice(text.indexOf("\n", at) + 1);
-  const lines = [];
-  for (const line2 of body.split("\n")) {
-    if (/^[^\s#]/.test(line2)) {
-      break;
+  const pins = before.pins?.[server];
+  if (how !== "already" && pins !== void 0 && pins[tool] === void 0) {
+    if (input.pin === void 0) {
+      throw new PolicyEditError(`${server} is pinned, and ${tool} has no pin yet`);
     }
-    lines.push(line2);
+    edited = addPin(edited, server, tool, input.pin, qualified);
   }
-  return lines.join("\n").replace(/\s+$/, "");
+  const after = parseManifest(edited, file);
+  const policy = createPolicyResolver(after).resolve(qualified).policy;
+  confirmOnly(before, after, { server, tool }, current.policy, policy, input.pin);
+  return { text: edited, how, policy };
 }
-function serverKey(text) {
-  const at = text.search(/^servers:[ \t]*$/m);
-  if (at === -1) {
-    return void 0;
-  }
-  const body = text.slice(text.indexOf("\n", at) + 1);
-  for (const line2 of body.split("\n")) {
-    if (/^[^\s#]/.test(line2)) {
-      return void 0;
-    }
-    const named = /^ {2}([A-Za-z0-9_-]+):[ \t]*$/.exec(line2);
-    if (named?.[1] !== void 0) {
-      return named[1];
-    }
+function rangeOf(node, what) {
+  const range = isNode(node) ? node.range : void 0;
+  if (range === void 0 || range === null) {
+    throw new PolicyEditError(`could not find where ${what} is written in the policy`);
   }
-  return void 0;
+  return range;
 }
-function toolsReferencedBy(rule2, key) {
-  const local = (qualified) => qualified === void 0 || !qualified.startsWith(`${key}.`) ? void 0 : qualified.slice(key.length + 1);
-  return [local(rule2.snapshot?.tool), local(rule2.inverse?.tool)].filter(
-    (name) => name !== void 0
-  );
+function lineStart(text, at) {
+  return text.lastIndexOf("\n", at - 1) + 1;
 }
-
-// src/init/draft.ts
-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 endOfLine(text, at) {
+  const next = text.indexOf("\n", Math.max(0, at - 1));
+  return next === -1 ? text.length : next;
 }
-function summarise(text) {
-  if (text === void 0) {
-    return "";
+function insertAfter(text, at, block2) {
+  if (at > 0 && text[at - 1] === "\n") {
+    return text.slice(0, at) + block2.slice(1) + text.slice(at);
   }
-  const single = text.replace(/\s+/g, " ").trim();
-  return single.length > 96 ? `${single.slice(0, 93)}...` : single;
+  const end = endOfLine(text, at);
+  return text.slice(0, end) + block2.replace(/\n$/, "") + text.slice(end);
 }
-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");
-}
-function patternFor(match) {
-  const source = match.split("*").map((literal) => literal.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("[^.]*");
-  return new RegExp(`^${source}$`);
-}
-function adopt(known, name, tools) {
-  const advertised = new Set(tools.map((tool) => tool.name));
-  const covered = /* @__PURE__ */ new Set();
-  for (const rule2 of known.rules) {
-    for (const needed of toolsReferencedBy(rule2, known.key)) {
-      if (!advertised.has(needed)) {
-        return void 0;
-      }
-    }
-    const test = patternFor(rule2.match);
-    for (const tool of tools) {
-      if (test.test(`${known.key}.${tool.name}`)) {
-        covered.add(tool.name);
-      }
-    }
-  }
-  if (covered.size === 0) {
-    return void 0;
+function addPin(text, server, tool, pin, qualified) {
+  const doc = parseDocument(text, { keepSourceTokens: true });
+  const map = doc.getIn(["pins", server], true);
+  if (!isMap(map) || map.flow === true || map.items.length === 0) {
+    throw new PolicyEditError(`the pins for ${server} are not written one to a line; pin ${qualified} by hand`);
   }
-  const renamed = known.source.replaceAll(`"${known.key}.`, `"${name}.`);
-  const missing = tools.filter((tool) => !covered.has(tool.name));
-  const extra = missing.length === 0 ? "" : [
-    "",
-    `  # Not mentioned by the bundled ${known.name} policy, so gated until you say otherwise.`,
-    ...missing.map((tool) => draftTool(name, tool))
-  ].join("\n");
-  return { source: `${renamed}${extra}`, covered: covered.size };
-}
-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();
+  const at = rangeOf(map, "pins")[0];
+  const indent = " ".repeat(at - lineStart(text, at));
+  return insertAfter(text, rangeOf(map, "pins")[2], `
+${indent}${tool}: ${JSON.stringify(pin)}
+`);
+}
+function confirmOnly(before, after, { server, tool }, was, now, pin) {
+  const qualified = `${server}.${tool}`;
+  const refuse = (why) => {
+    throw new PolicyEditError(`the edit came out wrong (${why}), so nothing was written`);
+  };
+  if (now.match !== qualified || now.gate !== "never") {
+    refuse(`${qualified} is not let through`);
   }
-  if (tools.length === 0) {
-    throw new ManifestError(`${options.name} exposes no tools, so there is no policy to write`);
+  if (now.class !== was.class) {
+    refuse(`${qualified} would change from ${was.class} to ${now.class}`);
   }
-  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 others = (manifest) => manifest.tools.filter((rule2) => rule2.match !== qualified).map((rule2) => canonical(rule2));
+  if (canonical(others(before)) !== canonical(others(after))) {
+    refuse("another rule changed");
   }
-  const known = knownPolicyFor(options.command, options.args);
-  const claim = known?.provenance === void 0 ? [] : [
-    ...known.provenance === "documented" ? [
-      `    # This policy has never been run against the real server. Check it`,
-      `    # against your own setup before trusting undo on it.`
-    ] : [],
-    `    provenance: ${known.provenance}`
-  ];
-  const server = [
-    `  ${options.name}:`,
-    `    command: ${quote(options.command)}`,
-    `    args: [${options.args.map(quote).join(", ")}]`,
-    ...claim
-  ].join("\n");
-  const adopted = known === void 0 ? void 0 : adopt(known, options.name, tools);
-  const policies = adopted?.source ?? tools.map((tool) => draftTool(options.name, tool)).join("\n\n");
-  if (existing === void 0) {
-    const yaml = [
-      `# Generated by synartesis init from ${options.name}'s tools/list.`,
-      ...adopted === void 0 ? [
-        `# Every tool starts gated. Working through the TODOs is the whole job:`,
-        `# a tool with no inverse is one an agent cannot use unsupervised.`
-      ] : [
-        `# ${String(adopted.covered)} of its tools were recognised, so the policy that ships`,
-        `# with Synartesis for ${known?.name ?? "this server"} was used and checked against what this`,
-        `# server actually advertises. Read it before trusting it: it is a starting`,
-        `# point that happens to be finished, not a promise about your setup.`
-      ],
-      ``,
-      `version: 1`,
-      ``,
-      `servers:`,
-      server,
-      ``,
-      `tools:`,
-      policies,
-      ``
-    ].join("\n");
-    return adopted === void 0 || known === void 0 ? { yaml } : {
-      yaml,
-      adopted: {
-        server: known.name,
-        tools: adopted.covered,
-        ...known.provenance === void 0 ? {} : { provenance: known.provenance }
-      }
-    };
+  if (canonical(before.servers) !== canonical(after.servers)) {
+    refuse("a server changed");
   }
-  const merged = mergeInto(existing, server, policies, options.name);
-  return adopted === void 0 || known === void 0 ? { yaml: merged } : {
-    yaml: merged,
-    adopted: {
-      server: known.name,
-      tools: adopted.covered,
-      ...known.provenance === void 0 ? {} : { provenance: known.provenance }
-    }
-  };
-}
-function mergeInto(existing, server, policies, name) {
-  const serversAt2 = existing.indexOf("\nservers:");
-  const toolsAt = existing.indexOf("\ntools:");
-  if (serversAt2 === -1 || toolsAt === -1 || toolsAt < serversAt2) {
-    throw new ManifestError(
-      "the existing manifest does not have a servers: block followed by a tools: block, so it cannot be extended automatically"
-    );
+  const pinned = before.pins?.[server];
+  const expected = pin === void 0 || pinned === void 0 || pinned[tool] !== void 0 ? before.pins : { ...before.pins, [server]: { ...pinned, [tool]: pin } };
+  if (canonical(expected ?? null) !== canonical(after.pins ?? null)) {
+    refuse("the pins changed");
   }
-  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 inversePlan = z2.object({
-  server: z2.string(),
-  tool: z2.string(),
-  args: z2.record(z2.string(), z2.unknown())
+import { z } from "zod";
+var inversePlan = z.object({
+  server: z.string(),
+  tool: z.string(),
+  args: z.record(z.string(), z.unknown())
 });
-var observation = z2.union([
-  z2.object({ present: z2.literal(true), value: z2.unknown() }),
-  z2.object({ present: z2.literal(false) })
+var observation = z.union([
+  z.object({ present: z.literal(true), value: z.unknown() }),
+  z.object({ present: z.literal(false) })
 ]);
-var toolResult = z2.looseObject({ isError: z2.boolean().default(false) });
+var toolResult = z.looseObject({ isError: z.boolean().default(false) });
 function sameState(a, b) {
   return canonical(a) === canonical(b);
 }
@@ -505,7 +375,11 @@ ${seen}` : seen;
       }
       if (sameState(current, recordedPost.data)) {
         verified = true;
-      } else if (sameState(current, intendedAfterInverse(action))) {
+      } else if (sameState(current, intendedAfterInverse(action)) || // An inverse this undo sent before it was killed, whose owner is gone:
+      // the resource having reached the state it produces is the inverse
+      // having landed. Found by SIGKILLing undo mid-compensation: the delete
+      // had gone through, and every later attempt called its absence drift.
+      action.status === "rolling_back" && journal.leaseFor(action.id)?.alive === false && looksUndone(current, action)) {
         steps.push({
           ...describeStep(action),
           kind: "already-reverted",
@@ -582,7 +456,7 @@ ${seen}` : seen;
     steps.push({
       ...describeStep(action),
       kind: "revert",
-      reason: verified ? "state matches; applying inverse" : forcedOver ?? unverifiedBecause(action),
+      reason: verified ? "unchanged since, so safe to put back" : forcedOver ?? unverifiedBecause(action),
       verified,
       plan,
       ...rebuilt.inverse === void 0 ? {} : { replanned: true },
@@ -620,6 +494,19 @@ ${seen}` : seen;
       journal.markRolledBack(action.id);
       continue;
     }
+    const landed = outcome.rejected && recordedPost.success && verifyRead.success ? await landedAnyway(router, toResolvedRead(verifyRead.data), recordedPost.data, action, signal) : void 0;
+    if (landed !== void 0) {
+      journal.markRolledBack(action.id);
+      steps[steps.length - 1] = {
+        ...describeStep(action),
+        kind: "revert",
+        reason: landed,
+        verified,
+        plan,
+        note: `the server reported an error (${truncated(outcome.message)}), but the resource had changed as this inverse changes it`
+      };
+      continue;
+    }
     const halt = new RollbackHalted(action.seq, outcome.message);
     if (outcome.rejected) {
       journal.markInverseRejected(action.id, halt.message);
@@ -677,6 +564,28 @@ function overwriteText(current, action) {
   }
   return changedLines(current, intended2);
 }
+async function landedAnyway(router, read, post, action, signal) {
+  let now;
+  try {
+    now = await observeState(router, read, signal);
+  } catch {
+    return void 0;
+  }
+  if (sameState(now, post)) {
+    return void 0;
+  }
+  return looksUndone(now, action) ? "done, despite the server reporting an error" : void 0;
+}
+function looksUndone(now, action) {
+  const intended2 = intendedAfterInverse(action);
+  if (intended2 !== void 0) {
+    return sameState(now, intended2);
+  }
+  return action.class === "compensable" && !now.present;
+}
+function truncated(text) {
+  return text.length > 160 ? `${text.slice(0, 157)}...` : text;
+}
 function intendedAfterInverse(action) {
   return action.snapshot === void 0 ? void 0 : { present: true, value: action.snapshot };
 }
@@ -696,11 +605,11 @@ async function executeInverse(router, plan, idempotencyKey, signal) {
           _meta: { [IDEMPOTENCY_META_KEY]: idempotencyKey }
         }
       },
-      z2.looseObject({}),
+      z.looseObject({}),
       { signal }
     );
   } catch (error) {
-    return { ok: false, rejected: false, message: describe(error) };
+    return { ok: false, rejected: upstream.classify?.(error) !== void 0, message: describe(error) };
   }
   const parsed = toolResult.safeParse(raw);
   if (parsed.success && parsed.data.isError) {
@@ -714,10 +623,10 @@ async function executeInverse(router, plan, idempotencyKey, signal) {
 }
 
 // src/rollback/inspect.ts
-import { z as z3 } from "zod";
-var observation2 = z3.union([
-  z3.object({ present: z3.literal(true), value: z3.unknown() }),
-  z3.object({ present: z3.literal(false) })
+import { z as z2 } from "zod";
+var observation2 = z2.union([
+  z2.object({ present: z2.literal(true), value: z2.unknown() }),
+  z2.object({ present: z2.literal(false) })
 ]);
 function sameState2(a, b) {
   return canonical(a) === canonical(b);
@@ -1035,7 +944,7 @@ function shortList() {
 }
 
 // src/watch.ts
-import { existsSync as existsSync2 } from "fs";
+import { existsSync } from "fs";
 
 // src/keys.ts
 var SEQUENCE = /^\u001b(\[[0-9;?]*[ -\/]*[@-~]|O[@-~])/;
@@ -1157,6 +1066,7 @@ function summariseArgs(args, limit = 60) {
 }
 
 // src/watch.ts
+var HOUR_MS = 60 * 60 * 1e3;
 var FRAMES = ["\u280B", "\u2819", "\u2839", "\u2838", "\u283C", "\u2834", "\u2826", "\u2827", "\u2807", "\u280F"];
 var NOTICE_TICKS = 26;
 function line(action, now) {
@@ -1216,7 +1126,7 @@ function render(journal, options, tick, view) {
     });
     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`)}`
+      canDecide(options) ? `  ${keyHint("a", "approve")}   ${keyHint("A", "and for an hour")}   ${keyHint("d", "deny")}   ${keyHint("j/k", "move")}   ${keyHint("q", "quit")}` : `  ${style.quiet(`${options.approveWith} approve --all`)}`
     );
   }
   if (view.notice !== "") {
@@ -1262,7 +1172,7 @@ async function* terminalKeys() {
 async function watch(options) {
   let journal;
   const open = () => {
-    if (journal === void 0 && existsSync2(options.journalPath)) {
+    if (journal === void 0 && existsSync(options.journalPath)) {
       journal = openJournal(options.journalPath, { mustExist: true });
     }
     return journal;
@@ -1275,7 +1185,7 @@ async function watch(options) {
     const ready = open();
     return ready === void 0 ? waitingForJournal(options, tick2) : render(ready, options, tick2, view);
   };
-  const decide = (approve) => {
+  const decide = (approve, forAnHour = false) => {
     const ready = open();
     if (ready === void 0 || options.decideAs === void 0) {
       return;
@@ -1285,8 +1195,11 @@ async function watch(options) {
     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`;
+    const changed = approve ? ready.approve(action.id, options.decideAs) : ready.denyByPerson(action.id, options.decideAs, "denied from the watch view");
+    if (changed && approve && forAnHour) {
+      ready.allow(action.server, action.tool, options.decideAs, new Date(Date.now() + HOUR_MS).toISOString());
+    }
+    view.notice = !changed ? `${action.server}.${action.tool} was already settled` : approve ? forAnHour ? `approved ${action.server}.${action.tool} \xB7 not asked again for an hour \xB7 tell the agent to try again` : `approved ${action.server}.${action.tool} \xB7 now tell the agent to try again` : `denied ${action.server}.${action.tool} \xB7 the agent is told if it asks again`;
     view.noticeUntil = tick + NOTICE_TICKS;
     view.cursor = 0;
   };
@@ -1299,6 +1212,9 @@ async function watch(options) {
       case "a":
         decide(true);
         return;
+      case "A":
+        decide(true, true);
+        return;
       case "d":
         decide(false);
         return;
@@ -1349,7 +1265,7 @@ async function watch(options) {
       if (options.maxTicks !== void 0 && tick + 1 >= options.maxTicks) {
         break;
       }
-      await new Promise((resolve4) => setTimeout(resolve4, interval));
+      await new Promise((resolve2) => setTimeout(resolve2, interval));
     }
     return 0;
   } finally {
@@ -1364,613 +1280,17 @@ async function watch(options) {
         await reader?.return?.(void 0);
         await reading;
       })(),
-      new Promise((resolve4) => setTimeout(resolve4, 50).unref())
+      new Promise((resolve2) => setTimeout(resolve2, 50).unref())
     ]);
     journal?.close();
   }
 }
 
 // src/console.ts
-import { existsSync as existsSync6 } from "fs";
-
-// src/install/connections.ts
-import { existsSync as existsSync5 } from "fs";
-
-// src/install/clients.ts
-import { existsSync as existsSync3, readFileSync as readFileSync2, readdirSync, renameSync, rmSync, unlinkSync, writeFileSync } from "fs";
-import { homedir, platform } from "os";
-import { basename as basename2, dirname, join, resolve } from "path";
-
-// src/install/toml.ts
-var HEADER = /^\s*\[(?!\[)([^[\]]+)\]\s*$/;
-function serverTables(lines) {
-  const tables = [];
-  let open;
-  const close = (at) => {
-    if (open !== void 0) {
-      tables.push({ name: open.name, start: open.start, end: at });
-      open = void 0;
-    }
-  };
-  lines.forEach((line2, index) => {
-    const header2 = HEADER.exec(line2)?.[1];
-    if (header2 === void 0) {
-      return;
-    }
-    const parts = header2.split(".");
-    if (parts[0] === "mcp_servers" && parts.length === 2 && parts[1] !== void 0) {
-      close(index);
-      open = { name: unquote(parts[1]), start: index };
-      return;
-    }
-    close(index);
-  });
-  close(lines.length);
-  return tables;
-}
-function unquote(text) {
-  const trimmed = text.trim();
-  if (/^'.*'$/s.test(trimmed)) {
-    return trimmed.slice(1, -1);
-  }
-  if (!/^".*"$/s.test(trimmed)) {
-    return trimmed;
-  }
-  return trimmed.slice(1, -1).replace(/\\(["\\])/g, "$1");
-}
-function readKey(lines, table, key) {
-  const pattern = new RegExp(`^\\s*${key}\\s*=\\s*(.*)$`);
-  for (let index = table.start + 1; index < table.end; index += 1) {
-    const line2 = lines[index];
-    if (line2 === void 0 || HEADER.test(line2)) {
-      break;
-    }
-    const value = pattern.exec(line2)?.[1];
-    if (value !== void 0) {
-      return value.trim();
-    }
-  }
-  return void 0;
-}
-function splitItems(inner) {
-  const items = [];
-  let current = "";
-  let quote3;
-  let escaped = false;
-  for (const character of inner) {
-    if (escaped) {
-      current += character;
-      escaped = false;
-      continue;
-    }
-    if (character === "\\" && quote3 === '"') {
-      current += character;
-      escaped = true;
-      continue;
-    }
-    if (quote3 === void 0 && (character === '"' || character === "'")) {
-      quote3 = character;
-      current += character;
-      continue;
-    }
-    if (character === quote3) {
-      quote3 = void 0;
-      current += character;
-      continue;
-    }
-    if (character === "," && quote3 === void 0) {
-      items.push(current);
-      current = "";
-      continue;
-    }
-    current += character;
-  }
-  items.push(current);
-  return items;
-}
-function parseArray(value) {
-  if (value === void 0 || !value.startsWith("[")) {
-    return void 0;
-  }
-  if (!value.endsWith("]")) {
-    return void 0;
-  }
-  const inner = value.slice(1, -1).trim();
-  if (inner === "") {
-    return [];
-  }
-  return splitItems(inner).map((item) => item.trim()).filter((item, index, all) => item !== "" || index !== all.length - 1).map(unquote);
-}
-function readServers(text) {
-  const lines = text.split("\n");
-  const servers = {};
-  for (const table of serverTables(lines)) {
-    const command = readKey(lines, table, "command");
-    const entry = {};
-    if (command !== void 0) {
-      entry["command"] = unquote(command);
-    }
-    const args = parseArray(readKey(lines, table, "args"));
-    if (args !== void 0) {
-      entry["args"] = args;
-    }
-    const url = readKey(lines, table, "url");
-    if (url !== void 0) {
-      entry["url"] = unquote(url);
-    }
-    const enabled = readKey(lines, table, "enabled");
-    if (enabled !== void 0) {
-      entry["enabled"] = enabled.trim() === "true";
-    }
-    servers[table.name] = entry;
-  }
-  return servers;
-}
-var quote2 = (text) => `"${text.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
-function writeServers(text, servers) {
-  const lines = text.split("\n");
-  const current = readServers(text);
-  for (const table of serverTables(lines).reverse()) {
-    const wanted = servers[table.name];
-    if (wanted === void 0 || wanted.command === void 0) {
-      continue;
-    }
-    const now = current[table.name];
-    if (now?.command === wanted.command && JSON.stringify(now.args ?? []) === JSON.stringify(wanted.args ?? [])) {
-      continue;
-    }
-    setKey(lines, table, "command", quote2(wanted.command));
-    setKey(lines, table, "args", `[${(wanted.args ?? []).map(quote2).join(", ")}]`);
-  }
-  return lines.join("\n");
-}
-function setKey(lines, table, key, value) {
-  const pattern = new RegExp(`^(\\s*)${key}\\s*=`);
-  for (let index = table.start + 1; index < table.end; index += 1) {
-    const line2 = lines[index];
-    if (line2 === void 0 || HEADER.test(line2)) {
-      break;
-    }
-    const indent = pattern.exec(line2)?.[1];
-    if (indent !== void 0) {
-      lines[index] = `${indent}${key} = ${value}`;
-      return;
-    }
-  }
-  lines.splice(table.start + 1, 0, `${key} = ${value}`);
-}
-
-// src/install/clients.ts
-var LABELS = {
-  "claude-code": "Claude Code",
-  "claude-desktop": "Claude Desktop",
-  cursor: "Cursor",
-  codex: "Codex"
-};
-var CLIENT_IDS = Object.keys(LABELS).filter(
-  (name) => name in LABELS
-);
-function isClientId(value) {
-  return CLIENT_IDS.some((known) => known === value);
-}
-function claudeDesktopPath() {
-  const home = homedir();
-  switch (platform()) {
-    case "darwin":
-      return join(home, "Library", "Application Support", "Claude", "claude_desktop_config.json");
-    case "win32":
-      return join(process.env["APPDATA"] ?? join(home, "AppData", "Roaming"), "Claude", "claude_desktop_config.json");
-    default:
-      return join(process.env["XDG_CONFIG_HOME"] ?? join(home, ".config"), "Claude", "claude_desktop_config.json");
-  }
-}
-function discover(cwd) {
-  const home = homedir();
-  const sites = [];
-  const claudeCode = join(home, ".claude.json");
-  if (existsSync3(claudeCode)) {
-    const document = readJson(claudeCode);
-    const projects = document?.["projects"];
-    const here = resolve(cwd);
-    if (isRecord2(projects) && Object.prototype.hasOwnProperty.call(projects, here)) {
-      sites.push({
-        client: "claude-code",
-        label: LABELS["claude-code"],
-        format: "json",
-        path: claudeCode,
-        scope: `project ${here}`,
-        at: ["projects", here, "mcpServers"]
-      });
-    }
-    sites.push({
-      client: "claude-code",
-      label: LABELS["claude-code"],
-      format: "json",
-      path: claudeCode,
-      scope: "global",
-      at: ["mcpServers"]
-    });
-  }
-  const projectFile = join(resolve(cwd), ".mcp.json");
-  if (existsSync3(projectFile)) {
-    sites.push({
-      client: "claude-code",
-      label: LABELS["claude-code"],
-      format: "json",
-      path: projectFile,
-      scope: "project file",
-      at: ["mcpServers"]
-    });
-  }
-  const desktop = claudeDesktopPath();
-  if (existsSync3(desktop)) {
-    sites.push({
-      client: "claude-desktop",
-      label: LABELS["claude-desktop"],
-      format: "json",
-      path: desktop,
-      scope: "global",
-      at: ["mcpServers"]
-    });
-  }
-  const codex = join(process.env["CODEX_HOME"] ?? join(home, ".codex"), "config.toml");
-  if (existsSync3(codex)) {
-    sites.push({
-      client: "codex",
-      label: LABELS.codex,
-      format: "toml",
-      path: codex,
-      scope: "global",
-      at: ["mcp_servers"]
-    });
-  }
-  for (const [path, scope] of [
-    [join(resolve(cwd), ".cursor", "mcp.json"), "project"],
-    [join(home, ".cursor", "mcp.json"), "global"]
-  ]) {
-    if (existsSync3(path)) {
-      sites.push({ client: "cursor", label: LABELS.cursor, format: "json", path, scope, at: ["mcpServers"] });
-    }
-  }
-  return sites;
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function readJson(path) {
-  try {
-    const parsed = JSON.parse(readFileSync2(path, "utf8"));
-    return isRecord2(parsed) ? parsed : void 0;
-  } catch {
-    return void 0;
-  }
-}
-var ConfigError = class extends Error {
-};
-function readDocument(site) {
-  let text;
-  try {
-    text = readFileSync2(site.path, "utf8");
-  } catch (error) {
-    throw new ConfigError(`cannot read ${site.path}: ${error instanceof Error ? error.message : String(error)}`);
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(text);
-  } catch (error) {
-    throw new ConfigError(
-      `${site.path} is not valid JSON (${error instanceof Error ? error.message : String(error)}). Fix it or move it aside; synartesis will not rewrite a file it cannot read.`
-    );
-  }
-  if (!isRecord2(parsed)) {
-    throw new ConfigError(`${site.path} is not a JSON object, so it has no server list to change`);
-  }
-  return parsed;
-}
-function readServers2(document, at) {
-  let node = document;
-  for (const key of at) {
-    if (!isRecord2(node)) {
-      return {};
-    }
-    node = node[key];
-  }
-  if (!isRecord2(node)) {
-    return {};
-  }
-  const servers = {};
-  for (const [name, entry] of Object.entries(node)) {
-    if (isRecord2(entry)) {
-      servers[name] = entry;
-    }
-  }
-  return servers;
-}
-function withServers(document, at, servers) {
-  const head = at[0];
-  if (head === void 0) {
-    throw new ConfigError("no path to the server list");
-  }
-  const rest = at.slice(1);
-  const below = document[head];
-  const child = rest.length === 0 ? servers : withServers(isRecord2(below) ? below : {}, rest, servers);
-  return { ...document, [head]: child };
-}
-function indentOf(path) {
-  try {
-    const line2 = /\n([ \t]+)"/.exec(readFileSync2(path, "utf8"));
-    const found = line2?.[1];
-    if (found === void 0) {
-      return 2;
-    }
-    return found.startsWith("	") ? "	" : found.length;
-  } catch {
-    return 2;
-  }
-}
-function backupPathFor(path) {
-  return `${path}.synartesis-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-")}`;
-}
-var KEEP_BACKUPS = 5;
-function pruneBackups(path) {
-  try {
-    const dir = dirname(path);
-    const prefix = `${basename2(path)}.synartesis-backup-`;
-    const ours2 = readdirSync(dir).filter((name) => name.startsWith(prefix)).sort();
-    for (const name of ours2.slice(0, Math.max(0, ours2.length - KEEP_BACKUPS))) {
-      rmSync(join(dir, name), { force: true });
-    }
-  } catch {
-  }
-}
-function writeDocument(site, document) {
-  return writeText(site, `${JSON.stringify(document, void 0, indentOf(site.path))}
-`);
-}
-function writeText(site, text) {
-  const backup = backupPathFor(site.path);
-  const original = readFileSync2(site.path);
-  writeFileSync(backup, original);
-  pruneBackups(site.path);
-  const temporary = join(dirname(site.path), `.synartesis-write-${String(process.pid)}.tmp`);
-  try {
-    writeFileSync(temporary, text);
-    renameSync(temporary, site.path);
-  } catch (error) {
-    try {
-      unlinkSync(temporary);
-    } catch {
-    }
-    throw new ConfigError(
-      `could not write ${site.path}: ${error instanceof Error ? error.message : String(error)}. The original is untouched, and a copy is at ${backup}.`
-    );
-  }
-  return backup;
-}
-function serversAt(site) {
-  if (site.format === "toml") {
-    try {
-      return readServers(readFileSync2(site.path, "utf8"));
-    } catch (error) {
-      throw new ConfigError(
-        `cannot read ${site.path}: ${error instanceof Error ? error.message : String(error)}`
-      );
-    }
-  }
-  return readServers2(readDocument(site), site.at);
-}
-function saveServers(site, servers) {
-  if (site.format === "toml") {
-    const text = readFileSync2(site.path, "utf8");
-    return writeText(site, writeServers(text, servers));
-  }
-  return writeDocument(site, withServers(readDocument(site), site.at, servers));
-}
-
-// src/install/install.ts
-import { existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, writeFileSync as writeFileSync2 } from "fs";
-import { dirname as dirname2, resolve as resolve2 } from "path";
-function recordPathFor(manifestPath) {
-  return resolve2(dirname2(manifestPath), "installed.json");
-}
-var EMPTY = { version: 1, wrapped: {} };
-function isRecord3(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function asRecord(value) {
-  if (!isRecord3(value)) {
-    return void 0;
-  }
-  const wrapped2 = value["wrapped"];
-  if (!isRecord3(wrapped2)) {
-    return void 0;
-  }
-  const kept = {};
-  for (const [key, entry] of Object.entries(wrapped2)) {
-    if (!isRecord3(entry)) {
-      continue;
-    }
-    const original = entry["original"];
-    const at = entry["at"];
-    if (!isRecord3(original)) {
-      continue;
-    }
-    if (!Array.isArray(at) || !at.every((step) => typeof step === "string")) {
-      continue;
-    }
-    kept[key] = { original, at };
-  }
-  return { version: 1, wrapped: kept };
-}
-function keyFor(site, server) {
-  return [site.path, site.scope, server].join("");
-}
-function readRecord(manifestPath) {
-  const path = recordPathFor(manifestPath);
-  if (!existsSync4(path)) {
-    return EMPTY;
-  }
-  try {
-    const parsed = JSON.parse(readFileSync3(path, "utf8"));
-    const record = asRecord(parsed);
-    if (record !== void 0) {
-      return record;
-    }
-  } catch {
-  }
-  return EMPTY;
-}
-function writeRecord(manifestPath, record) {
-  mkdirSync(dirname2(recordPathFor(manifestPath)), { recursive: true, mode: 448 });
-  writeFileSync2(recordPathFor(manifestPath), `${JSON.stringify(record, void 0, 2)}
-`);
-}
-function proxyEntry(manifestPath, server, original, invoker) {
-  const command = { command: invoker.command, args: [...invoker.args] };
-  return {
-    ...command,
-    args: [...command.args, "--manifest", resolve2(manifestPath), "--server", server],
-    // The agent's environment, not ours: the upstream is started by the proxy
-    // from the manifest, but a client that set `env` here meant it for the
-    // server, and the manifest reads `${VAR}` out of exactly this environment.
-    ...original.env === void 0 ? {} : { env: original.env },
-    ...original.cwd === void 0 ? {} : { cwd: original.cwd }
-  };
-}
-function isWrapped(entry) {
-  const args = entry.args ?? [];
-  return args.includes("proxy") && (entry.command === "synartesis" || entry.command === "synartesis-proxy" || args.includes("synartesis") || args.some((arg) => arg.endsWith("dist/cli.js") || arg.endsWith("dist/proxy.js")));
-}
-function invokerFor(ourVersion, cliPath) {
-  if (pathBinaryMatches(ourVersion)) {
-    return { command: "synartesis", args: ["proxy"] };
-  }
-  return {
-    command: process.execPath,
-    args: [cliPath, "proxy"],
-    note: "the synartesis on your PATH is a different build, so the entries name this one directly"
-  };
-}
-async function planInstall(sites, manifestPath, invoker) {
-  let yaml = existsSync4(manifestPath) ? readFileSync3(manifestPath, "utf8") : void 0;
-  const plans = [];
-  const claimed = new Set(
-    yaml === void 0 ? [] : Object.keys(parseManifest(yaml, manifestPath).servers)
-  );
-  for (const site of sites) {
-    const servers = serversAt(site);
-    const planned = [];
-    const skipped = [];
-    for (const [name, entry] of Object.entries(servers)) {
-      if (isWrapped(entry)) {
-        skipped.push({ name, why: "already covered" });
-        continue;
-      }
-      if (entry.command === void 0) {
-        skipped.push({ name, why: entry.url === void 0 ? "no command to start" : "remote (http); stdio only today" });
-        continue;
-      }
-      if (entry.enabled === false) {
-        skipped.push({ name, why: "switched off in the config" });
-        continue;
-      }
-      const key = claimed.has(name) ? `${name}-${site.client}` : name;
-      if (claimed.has(key)) {
-        skipped.push({ name, why: `already in the policy as ${key}` });
-        continue;
-      }
-      let draft;
-      try {
-        draft = await draftManifest({
-          name: key,
-          command: entry.command,
-          args: [...entry.args ?? []],
-          ...yaml === void 0 ? {} : { existing: yaml }
-        });
-      } catch (error) {
-        skipped.push({
-          name,
-          why: `will not start: ${(error instanceof Error ? error.message : String(error)).slice(0, 60)}`
-        });
-        continue;
-      }
-      yaml = draft.yaml;
-      claimed.add(key);
-      planned.push({
-        name,
-        original: entry,
-        wrapped: proxyEntry(manifestPath, key, entry, invoker),
-        ...draft.adopted === void 0 ? {} : {
-          adopted: draft.adopted.server,
-          tools: draft.adopted.tools,
-          ...draft.adopted.provenance === void 0 ? {} : { provenance: draft.adopted.provenance }
-        }
-      });
-    }
-    plans.push({ site, servers: planned, skipped });
-  }
-  return { plans, yaml: yaml ?? "" };
-}
-function applyInstall(plans, manifestPath, yaml) {
-  if (!plans.some((plan) => plan.servers.length > 0)) {
-    return [];
-  }
-  parseManifest(yaml, manifestPath);
-  mkdirSync(dirname2(resolve2(manifestPath)), { recursive: true, mode: 448 });
-  writeFileSync2(manifestPath, yaml);
-  const record = readRecord(manifestPath);
-  const wrapped2 = { ...record.wrapped };
-  const applied = [];
-  for (const plan of plans) {
-    if (plan.servers.length === 0) {
-      continue;
-    }
-    const servers = { ...serversAt(plan.site) };
-    for (const server of plan.servers) {
-      servers[server.name] = server.wrapped;
-      wrapped2[keyFor(plan.site, server.name)] = { original: server.original, at: plan.site.at };
-    }
-    writeRecord(manifestPath, { version: 1, wrapped: wrapped2 });
-    const backup = saveServers(plan.site, servers);
-    applied.push({ site: plan.site, backup, servers: plan.servers.map((server) => server.name) });
-  }
-  return applied;
-}
-function applyUninstall(sites, manifestPath) {
-  const record = readRecord(manifestPath);
-  const restoredKeys = /* @__PURE__ */ new Set();
-  const restored = [];
-  for (const site of sites) {
-    const servers = { ...serversAt(site) };
-    const put = [];
-    const unknown = [];
-    for (const [name, entry] of Object.entries(servers)) {
-      if (!isWrapped(entry)) {
-        continue;
-      }
-      const known = record.wrapped[keyFor(site, name)];
-      if (known === void 0) {
-        unknown.push(name);
-        continue;
-      }
-      servers[name] = known.original;
-      put.push(name);
-      restoredKeys.add(keyFor(site, name));
-    }
-    if (put.length === 0 && unknown.length === 0) {
-      continue;
-    }
-    const backup = put.length === 0 ? "" : saveServers(site, servers);
-    restored.push({ site, backup, servers: put, unknown });
-  }
-  const remaining = Object.fromEntries(
-    Object.entries(record.wrapped).filter(([key]) => !restoredKeys.has(key))
-  );
-  writeRecord(manifestPath, { version: 1, wrapped: remaining });
-  return restored;
-}
+import { existsSync as existsSync3 } from "fs";
 
 // src/install/connections.ts
+import { existsSync as existsSync2 } from "fs";
 var ACTIVE_WITHIN_MS = 2 * 60 * 1e3;
 function lastSeenByServer(journal) {
   return journal.lastSeenPerServer();
@@ -1979,7 +1299,7 @@ function commandMissing(command) {
   if (command === void 0) {
     return false;
   }
-  return (command.includes("/") || command.includes("\\")) && !existsSync5(command);
+  return (command.includes("/") || command.includes("\\")) && !existsSync2(command);
 }
 function scan(journal, cwd) {
   const seen = journal === void 0 ? /* @__PURE__ */ new Map() : lastSeenByServer(journal);
@@ -2000,7 +1320,9 @@ function scan(journal, cwd) {
     }
     const connections = Object.entries(servers).map(([server, entry]) => {
       const covered = isWrapped(entry);
-      const lastSeen = seen.get(server);
+      const args = entry.args ?? [];
+      const named = covered && args.includes("--server") ? args[args.indexOf("--server") + 1] : void 0;
+      const lastSeen = seen.get(named ?? server);
       return {
         client: site.client,
         scope: site.scope,
@@ -2036,6 +1358,7 @@ function needsConnecting(groups) {
 }
 
 // src/console.ts
+var HOUR_MS2 = 60 * 60 * 1e3;
 var FRAMES2 = [
   "\u280B",
   "\u2819",
@@ -2208,7 +1531,7 @@ function connectionsView(screen, options) {
     return [
       `  ${style.quiet("No MCP client config was found on this machine.")}`,
       "",
-      `  ${style.quiet("Looked for Claude Code, Claude Desktop, Cursor and Codex.")}`
+      `  ${style.quiet(LOOKED_FOR)}`
     ];
   }
   const rows = connectionRows(screen);
@@ -2263,7 +1586,7 @@ function footer(screen, options) {
     const what = screen.confirmingForce ? `undo ${screen.confirmingLabel ?? "this session"} anyway, losing that change?` : `undo ${screen.confirmingLabel ?? "this session"}?`;
     return ["", `  ${style.accent(what)}  ${keyHint2("y", "yes")}   ${keyHint2("n", "no")}`];
   }
-  const keys = screen.mode === "connections" ? [keyHint2("enter", "connect"), keyHint2("a", "connect all"), keyHint2("r", "rescan"), keyHint2("j/k", "move"), keyHint2("h", "back")] : screen.mode === "gates" ? [keyHint2("a", "approve"), keyHint2("d", "deny"), keyHint2("j/k", "move"), keyHint2("r", "runs")] : screen.mode === "run" ? [
+  const keys = screen.mode === "connections" ? [keyHint2("enter", "connect"), keyHint2("a", "connect all"), keyHint2("r", "rescan"), keyHint2("j/k", "move"), keyHint2("h", "back")] : screen.mode === "gates" ? [keyHint2("a", "approve"), keyHint2("A", "and for an hour"), keyHint2("d", "deny"), keyHint2("j/k", "move"), keyHint2("r", "runs")] : screen.mode === "run" ? [
     keyHint2("l", "check now"),
     keyHint2("p", "preview undo"),
     keyHint2("u", "undo"),
@@ -2314,7 +1637,7 @@ async function* terminalKeys2() {
 async function openConsole(options) {
   let journal;
   const open = () => {
-    if (journal === void 0 && existsSync6(options.journalPath)) {
+    if (journal === void 0 && existsSync3(options.journalPath)) {
       journal = openJournal(options.journalPath, { mustExist: true });
     }
     return journal;
@@ -2401,7 +1724,7 @@ async function openConsole(options) {
     }
     return ["", `  ${style.quiet("nothing to undo in this session")}`];
   };
-  const decide = (approve) => {
+  const decide = (approve, forAnHour = false) => {
     const ready = open();
     if (ready === void 0) {
       return;
@@ -2411,9 +1734,12 @@ async function openConsole(options) {
     if (action === void 0) {
       return;
     }
-    const changed = approve ? ready.approve(action.id, options.decideAs) : ready.deny(action.id, options.decideAs, "denied from the console");
+    const changed = approve ? ready.approve(action.id, options.decideAs) : ready.denyByPerson(action.id, options.decideAs, "denied from the console");
+    if (changed && approve && forAnHour) {
+      ready.allow(action.server, action.tool, options.decideAs, new Date(Date.now() + HOUR_MS2).toISOString());
+    }
     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`
+      !changed ? `${action.server}.${action.tool} was already settled` : approve ? forAnHour ? `approved ${action.server}.${action.tool} ${DOT} not asked again for an hour ${DOT} tell the agent to try again` : `approved ${action.server}.${action.tool} ${DOT} now tell the agent to try again` : `denied ${action.server}.${action.tool} ${DOT} the agent is told if it asks again`
     );
     screen.cursor = 0;
   };
@@ -2566,6 +1892,11 @@ async function openConsole(options) {
         }
         return;
       }
+      case "A":
+        if (screen.mode === "gates") {
+          decide(true, true);
+        }
+        return;
       case "a":
         if (screen.mode === "gates") {
           decide(true);
@@ -2690,7 +2021,7 @@ async function openConsole(options) {
       if (options.maxTicks !== void 0 && tick + 1 >= options.maxTicks) {
         break;
       }
-      await new Promise((resolve4) => setTimeout(resolve4, interval));
+      await new Promise((resolve2) => setTimeout(resolve2, interval));
     }
     return 0;
   } finally {
@@ -2706,40 +2037,40 @@ async function openConsole(options) {
         await reader?.return?.(void 0);
         await reading;
       })(),
-      new Promise((resolve4) => setTimeout(resolve4, 50).unref())
+      new Promise((resolve2) => setTimeout(resolve2, 50).unref())
     ]);
     journal?.close();
   }
 }
 
 // src/desktop.ts
-import { existsSync as existsSync7 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2 } from "path";
+import { existsSync as existsSync4 } from "fs";
+import { homedir } from "os";
+import { join } from "path";
 var RELEASES = "https://github.com/ArhaanDev24/Synartesis/releases";
 function candidates(platform2 = process.platform) {
-  const home = homedir2();
+  const home = homedir();
   if (platform2 === "darwin") {
     return [
       "/Applications/Synartesis.app",
-      join2(home, "Applications/Synartesis.app")
+      join(home, "Applications/Synartesis.app")
     ];
   }
   if (platform2 === "win32") {
-    const local = process.env["LOCALAPPDATA"] ?? join2(home, "AppData/Local");
+    const local = process.env["LOCALAPPDATA"] ?? join(home, "AppData/Local");
     return [
-      join2(local, "Programs/Synartesis/Synartesis.exe"),
-      join2(process.env["PROGRAMFILES"] ?? "C:/Program Files", "Synartesis/Synartesis.exe")
+      join(local, "Programs/Synartesis/Synartesis.exe"),
+      join(process.env["PROGRAMFILES"] ?? "C:/Program Files", "Synartesis/Synartesis.exe")
     ];
   }
   return [
     "/opt/Synartesis/synartesis-desktop",
     "/usr/bin/synartesis-desktop",
-    join2(home, ".local/bin/synartesis-desktop"),
-    join2(home, "Applications/Synartesis.AppImage")
+    join(home, ".local/bin/synartesis-desktop"),
+    join(home, "Applications/Synartesis.AppImage")
   ];
 }
-function findDesktop(platform2 = process.platform, here = existsSync7) {
+function findDesktop(platform2 = process.platform, here = existsSync4) {
   for (const path of candidates(platform2)) {
     if (!here(path)) {
       continue;
@@ -2782,7 +2113,7 @@ var COMMANDS = `
                                                   undo -- all in one place, with
                                                   the arrow keys. Everything
                                                   below can be done from it.
-  synartesis install [--client <name>] [--dry-run] [--print]
+  synartesis install [--client <name>] [--remote] [--dry-run] [--print]
   synartesis uninstall [--client <name>]
   synartesis status
   synartesis init <server> -- <command> [args...]  [--manifest <path>]
@@ -2801,14 +2132,19 @@ var COMMANDS = `
   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 allow [<server.tool> --for <30m|2h> | --always | --stop]
   synartesis resolve [actionId] --applied|--failed [--by <name>] [--reason <text>]
+  synartesis notify --test
   synartesis undo [runId] [--to <seq>] [--dry-run] [--replan] [--force [--yes]]
                           [--manifest <path>] [--journal <path>]
 
 install is the short way in: it finds what Claude Code, Claude Desktop,
-Cursor or Codex already list, writes a policy covering all of it -- using the ones that
-ship where they fit -- and points each entry at the proxy. The original config
+Cursor, Codex, Gemini CLI, Copilot CLI, Antigravity and Devin Desktop (or
+Windsurf) already list, writes a policy covering all of it -- using the ones
+that ship where they fit -- and points each entry at the proxy. The original config
 is copied aside first, and uninstall puts it back. status says what is covered.
+A hosted server (a url rather than a command) is covered only with --remote,
+through mcp-remote, which opens your browser to sign in.
 
 desktop opens the window, if it is installed. It is a separate download --
 shipping it through npm would put a browser engine inside every install of
@@ -2840,7 +2176,8 @@ undo stops when somebody has changed the resource since, rather than writing
 over them. Three ways past that, and it prints all three: leave it, put the
 resource back as the run left it and --replan, or --force to overwrite.
 
-  --client    claude-code, claude-desktop, cursor or codex; all by default
+  --client    claude-code, claude-desktop, cursor, codex, gemini-cli,
+              copilot-cli, antigravity, devin or windsurf; all by default
   --print     show the entries install would write, and write nothing
   --full      show every argument, snapshot and inverse in full, nothing elided
   --live      read each resource as it is now and say what has changed since
@@ -2853,6 +2190,8 @@ resource back as the run left it and --replan, or --force to overwrite.
   --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
+  --unattended  approve with no terminal, from a script. Recorded as unattended,
+              so it can be told apart from a yes a person typed
   --applied   resolve: the call did land, though nothing recorded it
   --failed    resolve: the call never landed
   --replan    rebuild each undo from the current manifest, for a run recorded
@@ -2912,7 +2251,9 @@ var TAKES_VALUE = /* @__PURE__ */ new Set([
   "--by",
   "--reason",
   "--older-than",
-  "--client"
+  "--client",
+  "--for",
+  "--confirm"
 ]);
 function positional(argv) {
   const values = [];
@@ -2929,23 +2270,44 @@ function positional(argv) {
   }
   return values;
 }
+async function startAsTheClientWould(manifestPath, name, spec, session) {
+  const client = clientEnvFor(manifestPath, name);
+  const source = client === void 0 ? { kind: "manifest" } : { kind: "client", env: client.env };
+  const recorded = session?.journal.runServer(session.runId, name);
+  if (session !== void 0 && recorded !== void 0) {
+    const now = fingerprint2(
+      session.journal.fingerprintKey(),
+      upstreamEnv(name, spec, source),
+      Object.keys(recorded.fingerprints)
+    );
+    const changed = differing(recorded.fingerprints, now);
+    if (changed.length > 0) {
+      const one = changed.length === 1;
+      throw new ConfigError(
+        `${changed.join(", ")} ${one ? "is" : "are"} not what this session's ${name} server was started with, so undoing through it now could act on a different store from the one the session wrote to. Set ${one ? "it" : "them"} back as ${one ? "it was" : "they were"} in ${client?.from ?? "the client config"} to undo this session.`
+      );
+    }
+  }
+  const cwd = recorded?.cwd ?? client?.cwd;
+  return await connectUpstream(name, spec, {
+    env: source,
+    stderr: "capture",
+    ...cwd === void 0 ? {} : { cwd }
+  });
+}
 async function runPin(argv) {
   const path = findManifest(flag(argv, "--manifest"));
   const manifest = loadManifest(path);
-  const shapes = /* @__PURE__ */ new Map();
+  let shapes = /* @__PURE__ */ new Map();
   const upstreams = [];
   try {
-    for (const [name, spec] of Object.entries(manifest.servers)) {
-      const upstream = await connectStdioUpstream({
-        name,
-        command: spec.command,
-        args: spec.args,
-        stderr: "capture",
-        ...spec.env === void 0 ? {} : { env: spec.env }
-      });
-      upstreams.push(upstream);
-      shapes.set(name, await toolShapes(upstream));
-    }
+    upstreams.push(
+      ...await startAll(
+        Object.entries(manifest.servers),
+        ([name, spec]) => startAsTheClientWould(path, name, spec)
+      )
+    );
+    shapes = await listAll(upstreams);
   } finally {
     for (const upstream of upstreams) {
       await upstream.close();
@@ -2988,23 +2350,44 @@ async function runCheck(argv) {
       out(`  ${style.accent(line2)}`);
     }
   }
+  for (const [name, spec] of Object.entries(manifest.servers)) {
+    for (const [header2, value] of Object.entries(spec.url === void 0 ? {} : spec.headers ?? {})) {
+      if (!value.includes("${")) {
+        out("");
+        for (const line2 of wrapped(
+          `${name}'s ${header2} header is written into the policy itself. If it is a token, move it to the client entry's env and write "\${NAME}" here instead.`,
+          74
+        )) {
+          out(`  ${style.accent(line2)}`);
+        }
+      }
+    }
+  }
   const upstreams = [];
   const offered = /* @__PURE__ */ new Map();
+  const trustedReads = /* @__PURE__ */ new Map();
   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);
+    upstreams.push(
+      ...await startAll(
+        Object.entries(manifest.servers),
+        ([name, spec]) => startAsTheClientWould(path, name, spec)
+      )
+    );
+    const listed = await listAll(upstreams);
+    await verifyAgainstServers(upstreams, manifest, listed);
+    const resolver = createPolicyResolver(manifest);
     for (const upstream of upstreams) {
-      offered.set(upstream.name, (await toolShapes(upstream)).map((tool) => tool.name));
+      const shapes = listed.get(upstream.name) ?? [];
+      const trusted = shapes.filter(
+        (tool) => tool.readOnly === true && trustsMarks(manifest, upstream.name) && !resolver.resolve(`${upstream.name}.${tool.name}`).matched
+      ).map((tool) => tool.name);
+      offered.set(
+        upstream.name,
+        shapes.map((tool) => tool.name).filter((tool) => !trusted.includes(tool))
+      );
+      if (trusted.length > 0) {
+        trustedReads.set(upstream.name, trusted);
+      }
     }
   } finally {
     for (const upstream of upstreams) {
@@ -3051,8 +2434,8 @@ async function runCheck(argv) {
         `${String(total)} tool${total === 1 ? "" : "s"} here ${total === 1 ? "has" : "have"} no policy, so ${total === 1 ? "it is" : "they are"} treated as`
       )}`
     );
-    out(`  ${style.quiet("irreversible and held for a person the first time an agent calls")}`);
-    out(`  ${style.quiet(`${total === 1 ? "it" : "one"}. Write a policy for any you would rather it got on with.`)}`);
+    out(`  ${style.quiet("irreversible and held for a person every time an agent calls")}`);
+    out(`  ${style.quiet(`${total === 1 ? "it" : "one"}. Write a policy, or allow it, for any you would rather it got on with.`)}`);
     out("");
     for (const entry of uncovered) {
       for (const line2 of wrapped(entry.tools.join(", "), 60)) {
@@ -3060,10 +2443,23 @@ async function runCheck(argv) {
       }
     }
   }
+  if (trustedReads.size > 0) {
+    out("");
+    out(
+      `  ${style.label("read as reads")} ${style.quiet("no rule, but the server marks these read-only, so they are not held:")}`
+    );
+    for (const [server, tools] of trustedReads) {
+      for (const line2 of wrapped(tools.join(", "), 60)) {
+        out(`  ${style.quiet(server.padEnd(8))} ${line2}`);
+      }
+    }
+    out(`  ${style.quiet("trust_annotations: false on a server turns this off for it.")}`);
+  }
   out("");
+  const used = existsSync5(findJournal(flag(argv, "--journal"), path));
   hint(
     firstOf(
-      () => notPinned(manifest),
+      () => used ? notPinned(manifest) : void 0,
       () => ({
         why: "this is sound; to see which clients it covers",
         run: "status",
@@ -3084,12 +2480,19 @@ async function runInstall(argv) {
   if (sites.length === 0) {
     out("");
     out(`  ${style.quiet("No MCP client config was found on this machine.")}`);
-    out(`  ${style.quiet("Looked for Claude Code, Claude Desktop, Cursor and Codex.")}`);
+    out(`  ${style.quiet(LOOKED_FOR)}`);
     out("");
     return 0;
   }
-  const invoker = invokerFor(version(), fileURLToPath2(import.meta.url));
-  const { plans, yaml } = await planInstall(sites, manifestPath, invoker);
+  const invoker = invokerFor(version(), fileURLToPath(import.meta.url));
+  const { plans, yaml } = await planInstall(sites, manifestPath, invoker, void 0, {
+    remote: argv.includes("--remote"),
+    start: !printOnly,
+    starting: (name) => {
+      process.stderr.write(`  ${style.quiet(`starting ${name} to see what it offers...`)}
+`);
+    }
+  });
   const total = plans.reduce((sum, plan) => sum + plan.servers.length, 0);
   out("");
   if (invoker.note !== void 0 && total > 0) {
@@ -3102,16 +2505,38 @@ async function runInstall(argv) {
     out(`  ${style.strong(plan.site.label)} ${style.quiet(plan.site.scope)}`);
     out(`  ${style.quiet(plan.site.path)}`);
     for (const server of plan.servers) {
-      const note = server.adopted === void 0 ? style.accent("drafted, every tool held until you say how to undo it") : style.quiet(`the policy that ships for ${server.adopted} (${String(server.tools ?? 0)} tools)`);
+      const note = server.again === true ? style.quiet("already in your policy from an earlier install; covered again") : server.unstarted === true ? style.quiet(
+        server.adopted === void 0 ? "not started here; a policy is drafted when you install" : `not started here; the policy that ships for ${server.adopted} would be used`
+      ) : server.adopted === void 0 ? style.accent("drafted, every tool held until you say how to undo it") : style.quiet(`the policy that ships for ${server.adopted} (${String(server.tools ?? 0)} tools)`);
       out(`    ${style.strong(server.name.padEnd(18))} ${note}`);
       if (server.provenance === "documented") {
         out(
           `    ${" ".repeat(18)} ${style.accent("never run against the real server -- check it before trusting undo")}`
         );
       }
+      if (server.direct !== void 0) {
+        for (const line2 of [
+          `hosted at ${server.direct}, reached directly with the headers your`,
+          "client gave it. They now sit in this entry's env; the policy names them."
+        ]) {
+          out(`    ${" ".repeat(18)} ${style.quiet(line2)}`);
+        }
+      }
+      if (server.bridged !== void 0) {
+        for (const line2 of [
+          `hosted at ${server.bridged}, reached through mcp-remote,`,
+          "which signs you in and keeps that sign-in itself; synartesis never sees it.",
+          "Hosted tools are named differently from local packages, so no shipped",
+          "policy applies: its writes are held until you write rules for them."
+        ]) {
+          out(`    ${" ".repeat(18)} ${style.quiet(line2)}`);
+        }
+      }
     }
     for (const skip of plan.skipped) {
-      out(`    ${style.quiet(skip.name.padEnd(18))} ${style.quiet(skip.why)}`);
+      for (const [at, line2] of wrapped(skip.why, 58).entries()) {
+        out(`    ${style.quiet((at === 0 ? skip.name : "").padEnd(18))} ${style.quiet(line2)}`);
+      }
     }
     if (plan.servers.length === 0 && plan.skipped.length === 0) {
       out(`    ${style.quiet("no servers listed")}`);
@@ -3195,13 +2620,13 @@ async function runUninstall(argv) {
 }
 function openIfPresent(journalPath) {
   try {
-    return existsSync8(journalPath) ? openJournal(journalPath, { mustExist: true }) : void 0;
+    return existsSync5(journalPath) ? openJournal(journalPath, { mustExist: true }) : void 0;
   } catch {
     return void 0;
   }
 }
 async function connectThese(targets, manifestPath) {
-  const invoker = invokerFor(version(), fileURLToPath2(import.meta.url));
+  const invoker = invokerFor(version(), fileURLToPath(import.meta.url));
   const wanted = /* @__PURE__ */ new Map();
   const sites = /* @__PURE__ */ new Map();
   for (const target of targets) {
@@ -3209,14 +2634,15 @@ async function connectThese(targets, manifestPath) {
     sites.set(key, target.site);
     (wanted.get(key) ?? wanted.set(key, /* @__PURE__ */ new Set()).get(key))?.add(target.server);
   }
-  const { plans, yaml } = await planInstall([...sites.values()], manifestPath, invoker);
-  const narrowed = plans.map((plan) => ({
-    ...plan,
-    servers: plan.servers.filter(
-      (server) => wanted.get(`${plan.site.path}${plan.site.scope}`)?.has(server.name) === true
-    )
-  }));
-  const applied = applyInstall(narrowed, manifestPath, yaml);
+  const { plans, yaml } = await planInstall(
+    [...sites.values()],
+    manifestPath,
+    invoker,
+    (site, name) => wanted.get(`${site.path}${site.scope}`)?.has(name) === true,
+    // Picked by name from the list, which is the asking.
+    { remote: true }
+  );
+  const applied = applyInstall(plans, manifestPath, yaml);
   const count = applied.reduce((sum, entry) => sum + entry.servers.length, 0);
   if (count === 0) {
     return "nothing was connected; see the reasons above";
@@ -3228,7 +2654,7 @@ function runStatus(argv) {
   const journalPath = findJournal(flag(argv, "--journal"), manifestPath);
   out("");
   out(
-    `  ${style.label("policy")}   ${existsSync8(manifestPath) ? style.strong(manifestPath) : style.quiet(`${manifestPath} (none yet)`)}`
+    `  ${style.label("policy")}   ${existsSync5(manifestPath) ? style.strong(manifestPath) : style.quiet(`${manifestPath} (none yet)`)}`
   );
   out(
     `  ${style.label("journal")}  ${bytesOf(journalPath) === void 0 ? style.quiet(`${journalPath} (none yet)`) : `${style.strong(journalPath)} ${style.quiet(sizeOf(journalPath))}`}`
@@ -3239,7 +2665,7 @@ function runStatus(argv) {
     const groups = scan(journal, process.cwd());
     if (groups.length === 0) {
       out(`  ${style.quiet("No MCP client config found.")}`);
-      out(`  ${style.quiet("Looked for Claude Code, Claude Desktop, Cursor and Codex.")}`);
+      out(`  ${style.quiet(LOOKED_FOR)}`);
       out("");
       return 0;
     }
@@ -3284,7 +2710,7 @@ async function runInit(argv) {
   }
   const path = findManifest(flag(argv, "--manifest"));
   const force = argv.includes("--force");
-  const present = existsSync8(path);
+  const present = existsSync5(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.`
@@ -3294,11 +2720,11 @@ async function runInit(argv) {
     name,
     command,
     args: argv.slice(separator + 2),
-    ...present ? { existing: readFileSync4(path, "utf8") } : {}
+    ...present ? { existing: readFileSync(path, "utf8") } : {}
   });
   parseManifest(draft.yaml, path);
-  mkdirSync2(dirname3(resolve3(path)), { recursive: true, mode: 448 });
-  writeFileSync3(path, draft.yaml);
+  mkdirSync(dirname(resolve(path)), { recursive: true, mode: 448 });
+  writeFileSync(path, draft.yaml);
   out("");
   out(`  ${style.label(present ? "extended" : "wrote")}  ${style.strong(path)}`);
   out(`  ${rule(54)}`);
@@ -3313,7 +2739,7 @@ async function runInit(argv) {
     out(`  ${style.quiet("Read it before you trust it, then point your MCP client at:")}`);
   }
   out("");
-  out(`  ${style.accent(`${proxyCommand()} --manifest ${resolve3(path)}`)}`);
+  out(`  ${style.accent(`${proxyCommand()} --manifest ${resolve(path)}`)}`);
   out("");
   return 0;
 }
@@ -3459,8 +2885,36 @@ function runList(journal, asJson, journalPath) {
       `  ${"session".padEnd(width)}  ${"started".padEnd(13)}  ${"did".padEnd(26)}  ${"state".padEnd(26)}  agent`
     )
   );
+  let quiet = [];
+  const flushQuiet = () => {
+    if (quiet.length === 1) {
+      const [only] = quiet;
+      if (only !== void 0) {
+        const did = didWhat(journal, only, 0);
+        out(
+          `  ${style.strong(only.id.slice(0, width))}  ${style.quiet(shortTime(only.startedAt).trimEnd().padEnd(13))}  ${laid(did.what, 26)}  ${laid(did.state, 26)}  ${style.quiet(only.label ?? "-")}`
+        );
+      }
+    } else if (quiet.length > 1) {
+      const newest = quiet[0];
+      const oldest = quiet[quiet.length - 1];
+      if (newest !== void 0 && oldest !== void 0) {
+        out(
+          `  ${style.quiet(
+            `${"".padEnd(width)}  ${String(quiet.length)} sessions with nothing in them, ${shortTime(oldest.startedAt).trim()} to ${shortTime(newest.startedAt).trim()}`
+          )}`
+        );
+      }
+    }
+    quiet = [];
+  };
   for (const run of runs) {
     const actions = counted2(run.id);
+    if (actions.actions === 0) {
+      quiet.push(run);
+      continue;
+    }
+    flushQuiet();
     const { unknown, waiting } = actions;
     const notes = [
       unknown === 0 ? "" : `${String(unknown)} of unknown outcome`,
@@ -3472,6 +2926,7 @@ function runList(journal, asJson, journalPath) {
       `  ${style.strong(run.id.slice(0, width))}  ${style.quiet(shortTime(run.startedAt).trimEnd().padEnd(13))}  ${laid(did.what, 26)}  ${laid(did.state, 26)}  ${style.quiet(run.label ?? "-")}${note}`
     );
   }
+  flushQuiet();
   out("");
   if ((bytesOf(journalPath) ?? 0) > PRUNE_NAG_BYTES) {
     out(`  ${style.quiet(`This journal is ${sizeOf(journalPath)}; synartesis prune reclaims what is old enough to lose.`)}`);
@@ -3486,12 +2941,15 @@ function runList(journal, asJson, journalPath) {
 async function runShow(argv, journal, asJson) {
   const full = argv.includes("--full");
   const runs = [...journal.listRuns()].reverse();
-  const run = pick(runs, positional(argv)[1], RUN, true);
+  const given = positional(argv)[1];
+  const tally2 = journal.tallyRuns();
+  const run = (given === void 0 ? runs.find((one) => (tally2.get(one.id)?.actions ?? 0) > 0) : void 0) ?? pick(runs, given, RUN, true);
   const runId = run.id;
   const inspection = argv.includes("--live") && journal.getActions(runId).length > 0 ? await withUpstreams(
     findManifest(flag(argv, "--manifest")),
     async (router) => await inspect({ journal, router, runId }),
-    serversUsedBy(journal, runId)
+    serversUsedBy(journal, runId),
+    { journal, runId }
   ) : void 0;
   if (asJson) {
     out(
@@ -3514,7 +2972,7 @@ async function runShow(argv, journal, asJson) {
   out(`  ${style.quiet("agent  ")} ${run.label ?? "-"}`);
   out(`  ${style.quiet("started")} ${fullTime(run.startedAt)}  ${style.quiet(ago(run.startedAt))}`);
   out(
-    `  ${style.quiet("status ")} ${run.status}` + (run.endedAt === void 0 ? "" : style.quiet(`  ended ${fullTime(run.endedAt)}`))
+    `  ${style.quiet("status ")} ${RUN_STATUS[run.status]}` + (run.endedAt === void 0 ? "" : style.quiet(`  ended ${fullTime(run.endedAt)}`))
   );
   const actions = journal.getActions(runId);
   if (actions.length === 0) {
@@ -3576,7 +3034,7 @@ async function runShow(argv, journal, asJson) {
     }
     out("");
   }
-  out(`  ${summarise2(actions)}`);
+  out(`  ${summarise(actions)}`);
   if (inspection !== void 0) {
     out("");
     const spoiled = inspection.resources.some((found) => found.condition === "changed");
@@ -3629,14 +3087,20 @@ var CLASS_MARK = {
   unclassified: "?"
 };
 var BADGE_WIDTH = "irreversible".length + 2;
+var RUN_STATUS = {
+  active: "still running",
+  complete: "finished",
+  rolled_back: "undone",
+  partial: "partly undone"
+};
 function badgeOf(action, pad2) {
   const name = `${CLASS_MARK[action.class]} ${action.class}`;
   const plain = pad2 ? name.padEnd(BADGE_WIDTH) : name;
   return action.class === "irreversible" ? style.accent(plain) : style.quiet(plain);
 }
 function statusOf(action, pad2) {
-  const label = labelFor(action);
-  const text = pad2 ? label.padEnd(13) : label;
+  const label = plainly(action).text;
+  const text = pad2 ? label.padEnd(22) : label;
   if (wasRefused(action)) {
     return style.accent(text);
   }
@@ -3675,7 +3139,7 @@ function inverseArgs(inverse) {
 function truncate3(text, limit) {
   return text.length <= limit ? text : `${text.slice(0, limit - 3)}...`;
 }
-function summarise2(actions) {
+function summarise(actions) {
   const counts = /* @__PURE__ */ new Map();
   for (const action of actions) {
     const label = labelFor(action);
@@ -3869,12 +3333,28 @@ function runGates(journal, asJson) {
   return 0;
 }
 function runDecision(argv, journal, approving) {
+  const unattended = argv.includes("--unattended");
+  if (approving && !process.stdin.isTTY && !unattended) {
+    throw new UsageError(
+      "approve needs a person at a terminal, so that an agent with a shell cannot approve its own calls. Run it in your terminal, or answer it in synartesis watch. For approving from a script, see synartesis --help.",
+      false
+    );
+  }
   const waiting = journal.listGated();
   const given = positional(argv)[1];
-  const by = flag(argv, "--by") ?? process.env["USER"] ?? process.env["LOGNAME"] ?? "unknown";
+  const named = flag(argv, "--by") ?? process.env["USER"] ?? process.env["LOGNAME"] ?? "unknown";
+  const by = approving && unattended ? `${named} (unattended)` : named;
   const reason = flag(argv, "--reason") ?? "denied by operator";
   if (given !== void 0) {
     const settled2 = journal.getAction(given);
+    if (approving && settled2?.status === "denied" && journal.reverseDenial(settled2.id, by)) {
+      out(
+        `  ${style.accent("approved")} ${style.strong(`${settled2.server}.${settled2.tool}`)} ${style.quiet(settled2.id)} ${style.quiet("(was denied)")}`
+      );
+      out("");
+      hint({ why: "the agent can make that call again now, and it will go through" });
+      return 0;
+    }
     if (settled2 !== void 0 && settled2.status !== "gated") {
       process.stderr.write(
         `synartesis: ${given} is no longer awaiting approval (it is ${labelFor(settled2)})
@@ -3891,7 +3371,7 @@ function runDecision(argv, journal, approving) {
   let failed = 0;
   let settled = 0;
   for (const action of targets) {
-    const changed = approving ? journal.approve(action.id, by) : journal.deny(action.id, by, reason);
+    const changed = approving ? journal.approve(action.id, by) : journal.denyByPerson(action.id, by, reason);
     if (!changed) {
       const now = journal.getAction(action.id);
       process.stderr.write(
@@ -3911,26 +3391,249 @@ function runDecision(argv, journal, approving) {
     hint(
       firstOf(
         () => heldCalls(journal),
-        () => approving ? { why: "the agent can make that call again now, and it will go through" } : { why: "the call was refused; the agent is told, and decides what to do next" }
+        () => approving ? { why: "the agent can make that call again now, and it will go through" } : settled === 1 ? {
+          why: "refused; if the agent asks again it is told you said no. Changed your mind?",
+          run: `approve ${targets[0]?.id.slice(0, 8) ?? ""}`,
+          needs: ["journal"]
+        } : { why: "refused; if the agent asks again it is told you said no" }
       )
     );
   }
   return failed === 0 ? 0 : 1;
 }
+var ALLOW_MAX_MINUTES = 24 * 60;
+function allowFor(given) {
+  const found = /^(\d+)(m|h)$/.exec(given.trim());
+  const minutes = found === null ? NaN : Number(found[1]) * (found[2] === "h" ? 60 : 1);
+  if (!Number.isFinite(minutes) || minutes < 1 || minutes > ALLOW_MAX_MINUTES) {
+    throw new UsageError(
+      `--for takes minutes or hours up to a day, like 30m or 2h, not ${given}. For good, use --always.`
+    );
+  }
+  return minutes;
+}
+async function runAllow(argv, journalPath) {
+  const given = positional(argv)[1];
+  const forFlag = flag(argv, "--for");
+  const always = argv.includes("--always");
+  const stop = argv.includes("--stop");
+  const now = /* @__PURE__ */ new Date();
+  if (given === void 0) {
+    if (forFlag !== void 0 || always || stop) {
+      throw new UsageError("allow needs the tool, as server.tool -- for example crm.send_email");
+    }
+    const journal = openJournalOrExplain(journalPath);
+    try {
+      const current = journal.listAllowances(now.toISOString());
+      out("");
+      if (current.length === 0) {
+        out(`  ${style.quiet("Nothing is being let through without asking.")}`);
+      }
+      for (const one of current) {
+        out(
+          `  ${style.strong(`${one.server}.${one.tool}`)}  ${style.quiet(`until ${shortTime(one.until, now)}, allowed by ${one.by}`)}`
+        );
+      }
+      out("");
+      return 0;
+    } finally {
+      journal.close();
+    }
+  }
+  const named = splitQualified(given);
+  if (named === void 0) {
+    throw new UsageError(`${given} is not a tool name; write it as server.tool, for example crm.send_email`);
+  }
+  if ([forFlag !== void 0, always, stop].filter(Boolean).length !== 1) {
+    throw new UsageError(
+      `say how long: allow ${given} --for 1h, allow ${given} --always, or allow ${given} --stop`
+    );
+  }
+  const who = flag(argv, "--by") ?? process.env["USER"] ?? process.env["LOGNAME"] ?? "unknown";
+  if (stop) {
+    const journal = openJournalOrExplain(journalPath);
+    try {
+      const stopped = journal.stopAllowance(named.server, named.tool, who, now.toISOString());
+      out(
+        stopped ? `  ${style.accent("stopped")} ${style.strong(given)} ${style.quiet("is held again from its next call")}` : `  ${style.quiet(`${given} was not being let through`)}`
+      );
+      if (stopped) {
+        out(`  ${style.quiet("A rule written with --always stays in the policy; edit it there.")}`);
+      }
+      return 0;
+    } finally {
+      journal.close();
+    }
+  }
+  const unattended = argv.includes("--unattended");
+  const interactive = process.stdin.isTTY;
+  if (!interactive && !unattended) {
+    throw new UsageError(
+      "allow needs a person at a terminal, so that an agent with a shell cannot allow its own calls. Run it in your terminal. For allowing from a script, see synartesis --help.",
+      false
+    );
+  }
+  const by = unattended ? `${who} (unattended)` : who;
+  const manifestPath = findManifest(flag(argv, "--manifest"));
+  const manifest = loadManifest(manifestPath);
+  const spec = manifest.servers[named.server];
+  if (spec === void 0) {
+    const near = didYouMean(named.server, Object.keys(manifest.servers));
+    throw new UsageError(
+      `${manifestPath} has no server called ${named.server}${near === void 0 ? "" : `; did you mean ${near}?`}`
+    );
+  }
+  const { policy } = createPolicyResolver(manifest).resolve(given);
+  if (forFlag !== void 0) {
+    const minutes = allowFor(forFlag);
+    const until = new Date(now.getTime() + minutes * 6e4).toISOString();
+    const journal = openJournalOrExplain(journalPath);
+    try {
+      journal.allow(named.server, named.tool, by, until);
+    } finally {
+      journal.close();
+    }
+    out("");
+    out(
+      `  ${style.accent("allowed")} ${style.strong(given)} ${style.quiet(`until ${shortTime(until, now)} -- its calls go out without asking, and are still recorded`)}`
+    );
+    if (policy.gate !== "always" && policy.gate !== "on_write") {
+      out(`  ${style.quiet("(the policy was not holding it anyway)")}`);
+    } else if (policy.class === "irreversible") {
+      out(`  ${style.quiet("These cannot be undone. Nothing will ask before each one goes out.")}`);
+    }
+    out(`  ${style.quiet(`Takes effect on its next call. To end it sooner: synartesis allow ${given} --stop`)}`);
+    out("");
+    return 0;
+  }
+  const text = readFileSync(manifestPath, "utf8");
+  const pins = manifest.pins?.[named.server];
+  let pin;
+  if (pins !== void 0 && pins[named.tool] === void 0) {
+    const upstream = await startAsTheClientWould(manifestPath, named.server, spec);
+    try {
+      const shape = (await toolShapes(upstream)).find((tool) => tool.name === named.tool);
+      if (shape === void 0) {
+        throw new UsageError(`${named.server} has no tool called ${named.tool}`);
+      }
+      pin = fingerprint(shape.inputSchema);
+    } finally {
+      await upstream.close();
+    }
+  }
+  let edit;
+  try {
+    edit = allowAlways({
+      text,
+      file: manifestPath,
+      server: named.server,
+      tool: named.tool,
+      by,
+      date: now.toISOString().slice(0, 10),
+      ...pin === void 0 ? {} : { pin }
+    });
+  } catch (error) {
+    if (error instanceof PolicyEditError) {
+      process.stderr.write(`synartesis: ${error.message}
+`);
+      return 1;
+    }
+    throw error;
+  }
+  if (edit.how === "already") {
+    out(`  ${style.quiet(`${given} is already let through by ${manifestPath}`)}`);
+    return 0;
+  }
+  if (edit.policy.class === "irreversible") {
+    const confirmed = unattended ? flag(argv, "--confirm") : await ask(`  ${given} cannot be undone. Type its name to stop holding it for good: `);
+    if (confirmed?.trim() !== given) {
+      process.stderr.write(`synartesis: not confirmed, so ${manifestPath} was not changed
+`);
+      return 1;
+    }
+  }
+  if (readFileSync(manifestPath, "utf8") !== text) {
+    process.stderr.write(`synartesis: ${manifestPath} changed while this was running; nothing was written
+`);
+    return 1;
+  }
+  const beside = `${manifestPath}.${String(process.pid)}.tmp`;
+  writeFileSync(beside, edit.text, { mode: statSync(manifestPath).mode });
+  renameSync(beside, manifestPath);
+  out("");
+  out(
+    `  ${style.accent("allowed")} ${style.strong(given)} ${style.quiet(`for good -- ${edit.how === "added" ? "a rule was added to" : "its rule was changed in"} ${manifestPath}`)}`
+  );
+  if (edit.policy.class === "irreversible") {
+    out(`  ${style.quiet("It still cannot be undone: each call is recorded, and none is held.")}`);
+  }
+  if (pin !== void 0) {
+    out(`  ${style.quiet("Pinned at the shape it has now, as the rest of the server is.")}`);
+  }
+  out(`  ${style.quiet("Takes effect when your client next starts the server. Until then:")}`);
+  out(`  ${style.quiet(`synartesis allow ${given} --for 1h`)}`);
+  out("");
+  return 0;
+}
+async function ask(question) {
+  const reader = createInterface({ input: process.stdin, output: process.stdout });
+  try {
+    return await reader.question(question);
+  } finally {
+    reader.close();
+  }
+}
+function stepWords(kind, dryRun) {
+  switch (kind) {
+    case "revert":
+      return dryRun ? "would put back" : "put back";
+    case "skip":
+      return "nothing to undo";
+    case "already-reverted":
+      return "already undone";
+    case "permanent":
+      return "cannot undo";
+    case "kept":
+      return "left alone";
+    case "halt":
+      return "stopped";
+  }
+}
+function resultWords(status, dryRun) {
+  switch (status) {
+    case "rolled_back":
+      return dryRun ? "would all be undone (nothing was written)" : "all undone";
+    case "partial":
+      return dryRun ? "would be partly undone (nothing was written)" : "partly undone";
+  }
+}
 function report(result, alreadyForcing = false, as = "") {
   out("");
   out(`  ${style.label(result.dryRun ? "dry run" : "undo")}  ${style.strong(result.runId)}`);
   out(`  ${rule(72)}`);
   out("");
   let separated = false;
+  let reads = 0;
+  const flushReads = () => {
+    if (reads > 0) {
+      out(`       ${style.quiet(`${String(reads)} read${reads === 1 ? "" : "s"}, nothing to undo`)}`);
+      reads = 0;
+    }
+  };
   for (const step of result.steps) {
+    if (step.kind === "skip" && step.reason === "readonly") {
+      reads += 1;
+      continue;
+    }
+    flushReads();
     if (step.kind === "kept" && !separated) {
       separated = true;
       out("");
       out(`  ${style.quiet("left alone")}`);
     }
     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);
+    const said = stepWords(step.kind, result.dryRun);
+    const kind = step.kind === "halt" || step.kind === "permanent" ? style.accent(said.padEnd(16)) : said.padEnd(16);
     out(
       `  ${style.quiet(String(step.seq).padStart(3))}  ${kind} ${style.strong(`${step.server}.${step.tool}`)}  ${style.quiet(step.reason)}${unverified}`
     );
@@ -3950,6 +3653,7 @@ function report(result, alreadyForcing = false, as = "") {
       );
     }
   }
+  flushReads();
   if (result.halted !== void 0) {
     const halt = result.halted;
     out("");
@@ -3993,8 +3697,9 @@ function report(result, alreadyForcing = false, as = "") {
     );
   }
   out("");
+  const outcome = resultWords(result.status, result.dryRun);
   out(
-    `  ${style.label("result")}  ${result.status === "rolled_back" ? result.status : style.accent(result.status)}`
+    `  ${style.label("result")}  ${result.status === "rolled_back" ? outcome : style.accent(outcome)}`
   );
   out("");
   if (result.dryRun && result.status === "rolled_back") {
@@ -4006,29 +3711,16 @@ function report(result, alreadyForcing = false, as = "") {
   }
   return result.halted === void 0 && permanent.length === 0 ? 0 : 1;
 }
-async function withUpstreams(manifestPath, use, only) {
+async function withUpstreams(manifestPath, use, only, session) {
   const manifest = loadManifest(manifestPath);
-  const upstreams = [];
-  const missing = [];
+  const wanted = Object.entries(manifest.servers).filter(([name]) => only === void 0 || only.has(name));
+  const { started, failed } = await startTogether(
+    wanted,
+    ([name, spec]) => startAsTheClientWould(manifestPath, name, spec, session)
+  );
+  const upstreams = [...started];
+  const missing = failed.map(({ item: [name], error }) => `${name}: ${describe(error)}`);
   try {
-    for (const [name, spec] of Object.entries(manifest.servers)) {
-      if (only !== void 0 && !only.has(name)) {
-        continue;
-      }
-      try {
-        upstreams.push(
-          await connectStdioUpstream({
-            name,
-            command: spec.command,
-            args: spec.args,
-            stderr: "capture",
-            ...spec.env === void 0 ? {} : { env: spec.env }
-          })
-        );
-      } catch (error) {
-        missing.push(`${name}: ${describe(error)}`);
-      }
-    }
     if (upstreams.length === 0 && missing.length > 0) {
       throw new ManifestError(`no server could be started. ${missing.join("; ")}`);
     }
@@ -4077,7 +3769,8 @@ async function performUndo(manifestPath, journal, runId, options) {
     }),
     // A replan re-resolves inverses from the current policy, which may name a
     // server this run never used; everything else needs only what it touched.
-    options.replan === true ? void 0 : serversUsedBy(journal, runId)
+    options.replan === true ? void 0 : serversUsedBy(journal, runId),
+    { journal, runId }
   );
 }
 async function runUndo(argv, journal) {
@@ -4087,9 +3780,16 @@ async function runUndo(argv, journal) {
     throw new UsageError("--to needs a positive whole number", false);
   }
   const given = positional(argv)[1];
-  const chosen = pick([...journal.listRuns()].reverse(), given, RUN, true);
+  const runs = [...journal.listRuns()].reverse();
+  const standing3 = journal.standingPerRun();
+  const hasWork = (id) => {
+    const here = standing3.get(id);
+    return here !== void 0 && (here.undoable > 0 || here.conflicted > 0);
+  };
+  const newestWithWork = given === void 0 ? runs.find((run) => hasWork(run.id)) : void 0;
+  const chosen = newestWithWork ?? pick(runs, given, RUN, true);
   const runId = chosen.id;
-  if (journal.getRun(runId)?.status === "active" && !argv.includes("--yes") && !argv.includes("--dry-run")) {
+  if (journal.getRun(runId)?.status === "active" && hasWork(runId) && !argv.includes("--yes") && !argv.includes("--dry-run")) {
     throw new UsageError(
       `${runId.slice(0, 8)} has not ended, so an agent may still be writing to it.
   See what an undo would do:  ${cliCommand()} undo ${runId.slice(0, 8)} --dry-run
@@ -4105,7 +3805,9 @@ async function runUndo(argv, journal) {
     ).length;
     out("");
     out(
-      `  ${style.quiet("no session named, so the most recent:")} ${style.strong(runId.slice(0, 8))} ` + style.quiet(`${chosen.label ?? "an agent"}, ${shortTime(chosen.startedAt).trim()}`)
+      `  ${style.quiet(
+        newestWithWork === void 0 ? "no session named, so the most recent:" : "no session named, so the most recent with something to undo:"
+      )} ${style.strong(runId.slice(0, 8))} ` + style.quiet(`${chosen.label ?? "an agent"}, ${shortTime(chosen.startedAt).trim()}`)
     );
     if (left === 0) {
       out("");
@@ -4155,7 +3857,8 @@ async function runUndo(argv, journal) {
     const over = (await withUpstreams(
       manifestPath,
       async (router) => await inspect({ journal, router, runId }),
-      serversUsedBy(journal, runId)
+      serversUsedBy(journal, runId),
+      { journal, runId }
     )).resources.filter(
       // Below --to nothing is undone, so a change down there is not something
       // this command would write over and must not stand in its way.
@@ -4217,7 +3920,9 @@ var KNOWN_COMMANDS = [
   "watch",
   "approve",
   "deny",
+  "allow",
   "resolve",
+  "notify",
   "undo",
   "help",
   "version"
@@ -4247,6 +3952,18 @@ var FLAGS = /* @__PURE__ */ new Set([
   "--force",
   "--yes",
   "--older-than",
+  // install: cover hosted servers too, through mcp-remote.
+  "--remote",
+  // notify: send one to see whether they reach you.
+  "--test",
+  // approve without a terminal, from a script; recorded as unattended.
+  "--unattended",
+  // allow: for a while, for good, or no longer; and the typed confirmation
+  // for a tool that cannot be undone, given without a terminal.
+  "--for",
+  "--always",
+  "--stop",
+  "--confirm",
   "--help",
   "-h",
   "--version",
@@ -4255,8 +3972,8 @@ var FLAGS = /* @__PURE__ */ new Set([
 ]);
 function version() {
   try {
-    const root = dirname3(fileURLToPath2(import.meta.url));
-    const parsed = JSON.parse(readFileSync4(join3(root, "..", "package.json"), "utf8"));
+    const root = dirname(fileURLToPath(import.meta.url));
+    const parsed = JSON.parse(readFileSync(join2(root, "..", "package.json"), "utf8"));
     const found = typeof parsed === "object" && parsed !== null ? parsed.version : void 0;
     return typeof found === "string" ? found : "unknown";
   } catch {
@@ -4287,7 +4004,7 @@ function rejectUnknownFlags(argv) {
   }
 }
 function openJournalOrExplain(journalPath) {
-  if (!existsSync8(journalPath)) {
+  if (!existsSync5(journalPath)) {
     throw new UsageError(
       `nothing has been recorded yet: there is no journal at ${journalPath}. One appears the first time an agent calls a tool through synartesis proxy.`
     );
@@ -4317,8 +4034,8 @@ ${COMMANDS}`);
   }
   const givenJournal = flag(argv, "--journal");
   const givenManifest = flag(argv, "--manifest");
-  journalArg = givenJournal === void 0 ? "" : ` --journal ${resolve3(givenJournal)}`;
-  manifestArg = givenManifest === void 0 ? "" : ` --manifest ${resolve3(givenManifest)}`;
+  journalArg = givenJournal === void 0 ? "" : ` --journal ${resolve(givenJournal)}`;
+  manifestArg = givenManifest === void 0 ? "" : ` --manifest ${resolve(givenManifest)}`;
   if (command === void 0) {
     const manifestPath = findManifest(flag(argv, "--manifest"));
     const journalPath2 = findJournal(flag(argv, "--journal"), manifestPath);
@@ -4335,7 +4052,8 @@ ${COMMANDS}`);
           return await withUpstreams(
             manifestPath,
             async (router) => await inspect({ journal: journal2, router, runId }),
-            serversUsedBy(journal2, runId)
+            serversUsedBy(journal2, runId),
+            { journal: journal2, runId }
           );
         } finally {
           journal2.close();
@@ -4387,7 +4105,7 @@ ${COMMANDS}`);
       decideAs: flag(argv, "--by") ?? process.env["USER"] ?? process.env["LOGNAME"] ?? "unknown"
     });
   }
-  if (!existsSync8(journalPath) && (command === "list" || command === "show" || command === "gates")) {
+  if (!existsSync5(journalPath) && (command === "list" || command === "show" || command === "gates")) {
     if (asJson) {
       out(JSON.stringify(command === "show" ? { run: null, actions: [] } : []));
       return 0;
@@ -4401,6 +4119,12 @@ ${COMMANDS}`);
     out("");
     return 0;
   }
+  if (command === "notify") {
+    return runNotifyTest(argv);
+  }
+  if (command === "allow") {
+    return await runAllow(argv, journalPath);
+  }
   if (command === "desktop") {
     return runDesktop();
   }
@@ -4432,6 +4156,32 @@ ${COMMANDS}`);
     journal.close();
   }
 }
+function runNotifyTest(argv) {
+  if (!argv.includes("--test")) {
+    throw new UsageError("notify takes --test, which sends one to see whether they reach you");
+  }
+  const why = canNotify();
+  if (why !== void 0) {
+    out(`  ${style.quiet(`No notification sent: ${why}.`)}`);
+    return 1;
+  }
+  desktopNotifier()({
+    server: "synartesis",
+    tool: "test",
+    actionId: "00000000",
+    approve: "this is only a test"
+  });
+  out("");
+  out(`  ${style.quiet("Sent one. If nothing appeared, notifications for it are switched off:")}`);
+  out(
+    `  ${style.quiet(
+      platform() === "darwin" ? "macOS lists the ones osascript sends under Script Editor, in System Settings > Notifications." : "check that a notification daemon is running and notify-send is installed."
+    )}`
+  );
+  out(`  ${style.quiet("Either way, synartesis watch shows every held call as it happens.")}`);
+  out("");
+  return 0;
+}
 function runDesktop() {
   const found = findDesktop();
   if (found === void 0) {