@mrciphersmith/keryx 0.3.66 → 0.3.68

package/dist/cli.js

@@ -20107,7 +20107,7 @@ var package_default;
 var init_package = __esm(() => {
   package_default = {
     name: "@mrciphersmith/keryx",
-    version: "0.3.66",
+    version: "0.3.68",
     description: "Version-controlled project context for AI coding agents: code graph, architecture wiki, project memory, relevant tests, quality signals, and task flows.",
     private: false,
     publishConfig: {
@@ -81424,7 +81424,7 @@ ${shown.join(`
         result = precomputedResult;
       } else {
         try {
-          result = await executeCall(call, toolByName, io.requestApproval, io.permissionMode, io.readOnly, io.onAutoApproved, hasInvocationCapacity, reserveInvocation, invocationBudget.maxCalls, signal, deps.busLeases, deps.hardDeny === undefined ? undefined : { check: deps.hardDeny, onDenied: io.onUnattendedDenial }, deps.hooks, untrustedOrigin, io.trustedMcpTools, io.mcpToolFingerprint, io.mcpToolDestructive, deps.unattended === true ? undefined : io.beforeMutation);
+          result = await executeCall(call, toolByName, io.requestApproval, io.permissionMode, io.readOnly, io.onAutoApproved, hasInvocationCapacity, reserveInvocation, invocationBudget.maxCalls, signal, deps.busLeases, deps.hardDeny === undefined ? undefined : { check: deps.hardDeny, onDenied: io.onUnattendedDenial }, deps.hooks, untrustedOrigin, io.mcpGrantsApply?.() === false ? undefined : io.trustedMcpTools, io.mcpToolFingerprint, io.mcpToolDestructive, deps.unattended === true ? undefined : io.beforeMutation);
         } catch (err) {
           const message = err instanceof Error ? err.message : String(err);
           result = { output: `${call.name} failed: ${message}`, isError: true };
@@ -91621,6 +91621,34 @@ function allowShellPattern(pattern, dir) {
   }
   return trimmed;
 }
+function removeShellPattern(pattern, dir) {
+  const wanted = pattern.trim();
+  if (wanted.length === 0)
+    return false;
+  try {
+    const file = shellPermissionsPath(dir);
+    if (!existsSync36(file))
+      return false;
+    const read = readConfigFile(file);
+    if (!read.ok)
+      return false;
+    const raw = JSON.parse(read.text);
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw))
+      return false;
+    const allowRaw = raw.allow;
+    if (!Array.isArray(allowRaw))
+      return false;
+    const kept = allowRaw.filter((entry) => !(typeof entry === "string" && entry.trim() === wanted));
+    if (kept.length === allowRaw.length)
+      return false;
+    ensureKeryxConfigDir(path212.dirname(file));
+    writeOwnerOnlyFile(file, `${JSON.stringify({ ...raw, allow: kept }, null, 2)}
+`);
+    return true;
+  } catch {
+    return false;
+  }
+}
 function matchShellPattern(pattern, command) {
   const p = pattern.trim();
   const c = command.trim();
@@ -91844,7 +91872,16 @@ function evaluateShellApproval(input) {
   const hookAsk = input.meta?.hookAsk === true;
   const untrustedOrigin = input.meta?.untrustedOrigin === true;
   const audit = io.loadAudit();
-  for (const pattern of audit.permissions.allow) {
+  const current = new Set(audit.permissions.allow);
+  const loadedBefore = loadedFromDisk.get(input.sessionAllow);
+  if (loadedBefore !== undefined) {
+    for (const pattern of loadedBefore) {
+      if (!current.has(pattern))
+        input.sessionAllow.delete(pattern);
+    }
+  }
+  loadedFromDisk.set(input.sessionAllow, current);
+  for (const pattern of current) {
     input.sessionAllow.add(pattern);
   }
   const tampered = io.fingerprint() !== input.fingerprintAtStart;
@@ -91899,7 +91936,7 @@ function formatShellApprovalHints(evaled) {
   }
   return lines;
 }
-var defaultApprovalIO;
+var defaultApprovalIO, loadedFromDisk;
 var init_shell_approval = __esm(() => {
   init_command_risk();
   init_shell_permissions();
@@ -91907,6 +91944,7 @@ var init_shell_approval = __esm(() => {
     loadAudit: () => loadShellPermissionsWithAudit(),
     fingerprint: () => shellPermissionsFingerprint()
   };
+  loadedFromDisk = new WeakMap;
 });
 
 // src/mcp-servers/json-utils.ts
@@ -101030,9 +101068,34 @@ function parseRemoteConfig(value) {
   if (!orphan.ok) {
     return orphan;
   }
-  const run = timeout("runTimeoutMs", DEFAULT_RUN_TIMEOUT_MS);
-  if (!run.ok) {
-    return run;
+  let runTimeoutMs = DEFAULT_RUN_TIMEOUT_MS;
+  if (doc.runTimeoutMs !== undefined) {
+    if (doc.runTimeoutMs === 0) {
+      runTimeoutMs = 0;
+    } else {
+      const run = timeout("runTimeoutMs", DEFAULT_RUN_TIMEOUT_MS);
+      if (!run.ok) {
+        return { ok: false, reason: `remote config runTimeoutMs must be 0 (no limit) or an integer from 1 to ${MAX_TIMEOUT_MS3} (milliseconds)` };
+      }
+      runTimeoutMs = run.value;
+    }
+  }
+  let permissionMode = DEFAULT_REMOTE_PERMISSION_MODE;
+  if (doc.permissionMode !== undefined) {
+    if (doc.permissionMode !== "ask" && doc.permissionMode !== "trust") {
+      return { ok: false, reason: 'remote config permissionMode must be "ask" or "trust" (auto is not available here)' };
+    }
+    permissionMode = doc.permissionMode;
+  }
+  let approvalTimeoutMs = DEFAULT_APPROVAL_WAIT_MS;
+  if (doc.approvalTimeoutMs !== undefined) {
+    if (!isSafeInt(doc.approvalTimeoutMs) || doc.approvalTimeoutMs < MIN_APPROVAL_WAIT_MS || doc.approvalTimeoutMs > MAX_APPROVAL_WAIT_MS) {
+      return {
+        ok: false,
+        reason: `remote config approvalTimeoutMs must be an integer from ${MIN_APPROVAL_WAIT_MS} to ${MAX_APPROVAL_WAIT_MS} (milliseconds)`
+      };
+    }
+    approvalTimeoutMs = doc.approvalTimeoutMs;
   }
   if (doc.rendering !== undefined && !isRenderMode(doc.rendering)) {
     return { ok: false, reason: `remote config rendering must be ${RENDER_MODE_CHOICES}` };
@@ -101044,7 +101107,9 @@ function parseRemoteConfig(value) {
       chatId: doc.chatId,
       allowedUserIds: [...new Set(ids)],
       orphanMs: orphan.value,
-      runTimeoutMs: run.value,
+      runTimeoutMs,
+      permissionMode,
+      approvalTimeoutMs,
       ...doc.rendering === undefined ? {} : { rendering: doc.rendering }
     }
   };
@@ -101072,7 +101137,46 @@ function saveRemoteConfig(config, dir) {
     return checked;
   }
   ensureRemoteDir(dir);
-  writeOwnerOnlyFileAtomic(remoteConfigPath(dir), `${JSON.stringify(checked.value, null, 2)}
+  const { permissionMode, approvalTimeoutMs, ...base } = checked.value;
+  const onDisk = {
+    ...base,
+    ...config.permissionMode === undefined ? {} : { permissionMode },
+    ...config.approvalTimeoutMs === undefined ? {} : { approvalTimeoutMs }
+  };
+  writeOwnerOnlyFileAtomic(remoteConfigPath(dir), `${JSON.stringify(onDisk, null, 2)}
+`);
+  return checked;
+}
+function updateRemotePolicy(patch, dir) {
+  const file = remoteConfigPath(dir);
+  const read = readConfigFile(file);
+  if (!read.ok) {
+    return {
+      ok: false,
+      reason: read.reason === "absent" ? `no remote-control config at ${file}; connect Telegram first` : `remote-control config at ${file} cannot be read (${read.reason})`
+    };
+  }
+  let doc;
+  try {
+    doc = JSON.parse(read.text);
+  } catch {
+    return { ok: false, reason: `remote-control config at ${file} is not valid JSON` };
+  }
+  if (typeof doc !== "object" || doc === null || Array.isArray(doc)) {
+    return { ok: false, reason: "remote config must be a JSON object" };
+  }
+  const next = { ...doc };
+  if (patch.permissionMode !== undefined)
+    next.permissionMode = patch.permissionMode;
+  if (patch.runTimeoutMs !== undefined)
+    next.runTimeoutMs = patch.runTimeoutMs;
+  if (patch.approvalTimeoutMs !== undefined)
+    next.approvalTimeoutMs = patch.approvalTimeoutMs;
+  const checked = parseRemoteConfig(next);
+  if (!checked.ok) {
+    return checked;
+  }
+  writeOwnerOnlyFileAtomic(file, `${JSON.stringify(next, null, 2)}
 `);
   return checked;
 }
@@ -101139,15 +101243,27 @@ function removeBotToken(dir) {
 function removeRemoteConfig(dir) {
   return removeFile2(remoteConfigPath(dir));
 }
-var REMOTE_CONFIG_SCHEMA_VERSION = 1, DEFAULT_ORPHAN_MS, DEFAULT_RUN_TIMEOUT_MS, MAX_TIMEOUT_MS3, CONFIG_KEYS, TOKEN_SHAPE;
+var REMOTE_CONFIG_SCHEMA_VERSION = 1, DEFAULT_ORPHAN_MS, DEFAULT_RUN_TIMEOUT_MS = 0, LEGACY_RUN_TIMEOUT_MS, DEFAULT_APPROVAL_WAIT_MS, LEGACY_APPROVAL_WAIT_MS, MIN_APPROVAL_WAIT_MS = 30000, MAX_APPROVAL_WAIT_MS, DEFAULT_REMOTE_PERMISSION_MODE = "trust", MAX_TIMEOUT_MS3, CONFIG_KEYS, TOKEN_SHAPE;
 var init_config11 = __esm(() => {
   init_config_dir();
   init_paths4();
   init_rendering_mode();
   DEFAULT_ORPHAN_MS = 10 * 60000;
-  DEFAULT_RUN_TIMEOUT_MS = 30 * 60000;
+  LEGACY_RUN_TIMEOUT_MS = 30 * 60000;
+  DEFAULT_APPROVAL_WAIT_MS = 15 * 60000;
+  LEGACY_APPROVAL_WAIT_MS = 5 * 60000;
+  MAX_APPROVAL_WAIT_MS = 60 * 60000;
   MAX_TIMEOUT_MS3 = 7 * 24 * 60 * 60000;
-  CONFIG_KEYS = new Set(["schemaVersion", "chatId", "allowedUserIds", "orphanMs", "runTimeoutMs", "rendering"]);
+  CONFIG_KEYS = new Set([
+    "schemaVersion",
+    "chatId",
+    "allowedUserIds",
+    "orphanMs",
+    "runTimeoutMs",
+    "permissionMode",
+    "approvalTimeoutMs",
+    "rendering"
+  ]);
   TOKEN_SHAPE = /^\d{5,}:[A-Za-z0-9_-]{20,}$/;
 });
 
@@ -101219,6 +101335,308 @@ var init_rendering_command = __esm(() => {
   };
 });
 
+// src/commands/permissions-command.ts
+function loadPermissionsView(options = {}) {
+  const audit = loadShellPermissionsWithAudit(options.dir);
+  const stored = new Set([...audit.permissions.allow, ...audit.rejected.map((entry) => entry.pattern)]);
+  const rows = [];
+  const push = (pattern, kind, reason) => {
+    rows.push({ n: rows.length + 1, pattern, kind, ...reason !== undefined ? { reason } : {} });
+  };
+  for (const pattern of audit.permissions.allow)
+    push(pattern, "active");
+  audit.rejected.forEach((entry) => push(entry.pattern, "inactive", entry.reason));
+  for (const pattern of options.sessionAllow ?? []) {
+    if (!stored.has(pattern))
+      push(pattern, "session");
+  }
+  return { path: shellPermissionsPath(options.dir), rows };
+}
+function patternOnOneLine(pattern) {
+  return pattern.replace(/\r?\n/g, "\\n").replace(CONTROL, " ");
+}
+function permissionsLines(view) {
+  const of = (kind) => view.rows.filter((row) => row.kind === kind);
+  const active = of("active");
+  const inactive = of("inactive");
+  const session = of("session");
+  const lines = [];
+  lines.push(active.length === 0 ? "No saved shell rules: every command that is not read-only asks first." : `Saved shell rules (${active.length}): commands that run without asking.`);
+  for (const row of active)
+    lines.push(`  ${row.n}. ${patternOnOneLine(row.pattern)}`);
+  if (inactive.length > 0) {
+    lines.push("", `Not honoured (${inactive.length}): kept in the file, they approve nothing.`);
+    for (const row of inactive) {
+      lines.push(`  ${row.n}. ${patternOnOneLine(row.pattern)}`);
+      lines.push(`     ${row.reason ?? "refused by the validators"}`);
+    }
+  }
+  if (session.length > 0) {
+    lines.push("", `Granted for this session only (${session.length}):`);
+    for (const row of session)
+      lines.push(`  ${row.n}. ${patternOnOneLine(row.pattern)}`);
+  }
+  lines.push("", `File: ${view.path}`);
+  if (view.rows.length > 0)
+    lines.push("Remove one with /permissions remove <number>, or keryx permissions remove <number>.");
+  return lines;
+}
+function resolvePermissionTarget(view, target) {
+  const wanted = target.trim();
+  if (wanted.length === 0)
+    return;
+  const byText = view.rows.find((row) => row.pattern === wanted);
+  if (byText !== undefined)
+    return byText;
+  if (/^\d+$/.test(wanted))
+    return view.rows.find((row) => row.n === Number(wanted));
+  return;
+}
+function removePermission(target, options = {}) {
+  const view = loadPermissionsView({
+    ...options.dir !== undefined ? { dir: options.dir } : {},
+    ...options.sessionAllow !== undefined ? { sessionAllow: options.sessionAllow } : {}
+  });
+  const row = resolvePermissionTarget(view, target);
+  if (row === undefined) {
+    return { ok: false, text: `No saved rule matches ${JSON.stringify(target.trim())}. Run list to see the numbers.` };
+  }
+  if (row.kind === "session") {
+    options.sessionAllow?.delete(row.pattern);
+    return { ok: true, pattern: row.pattern, text: `Removed the session grant: ${patternOnOneLine(row.pattern)}` };
+  }
+  if (!removeShellPattern(row.pattern, options.dir)) {
+    return { ok: false, pattern: row.pattern, text: `Could not remove ${patternOnOneLine(row.pattern)} from ${view.path}.` };
+  }
+  options.sessionAllow?.delete(row.pattern);
+  options.onChanged?.();
+  return { ok: true, pattern: row.pattern, text: `Removed: ${patternOnOneLine(row.pattern)}. It asks again from now on.` };
+}
+function permissionsSlashText(rest, options = {}) {
+  const trimmed = rest.trim();
+  const [sub] = trimmed.split(/\s+/);
+  if (sub === "remove" || sub === "rm") {
+    const target = trimmed.slice(sub.length).trim();
+    if (target.length === 0)
+      return `Usage: /permissions remove <number | pattern>
+`;
+    return `${removePermission(target, options).text}
+`;
+  }
+  if (trimmed.length > 0 && sub !== "list")
+    return `Usage: /permissions [list | remove <number | pattern>]
+`;
+  return `${permissionsLines(loadPermissionsView({
+    ...options.dir !== undefined ? { dir: options.dir } : {},
+    ...options.sessionAllow !== undefined ? { sessionAllow: options.sessionAllow } : {}
+  })).join(`
+`)}
+`;
+}
+function printPermissionsHelp() {
+  console.log([
+    "Usage: keryx permissions <subcommand>",
+    "",
+    "  keryx permissions list [--json]        The saved shell rules: honoured, and not honoured with the reason.",
+    "  keryx permissions remove <number|pattern>",
+    "                                         Take one rule back. The number is the one `list` prints.",
+    "",
+    "A rule is saved when an approval is answered with Always, in the shell or from Telegram. It",
+    "is removed here, never from a chat. A running shell stops using a removed rule on its next",
+    "approval and warns that the file changed."
+  ].join(`
+`));
+}
+async function permissionsCommand(args) {
+  const [sub, ...rest] = args;
+  if (sub === "--help" || sub === "-h" || sub === "help") {
+    printPermissionsHelp();
+    return;
+  }
+  if (sub === undefined || sub === "list" || sub === "--json") {
+    const flags = sub === "--json" ? [sub, ...rest] : rest;
+    const unknown = flags.filter((arg) => arg !== "--json");
+    if (unknown.length > 0) {
+      throw new Error(`Unknown option${unknown.length > 1 ? "s" : ""} for \`keryx permissions list\`: ${unknown.join(", ")}. Accepted: --json.`);
+    }
+    const view = loadPermissionsView();
+    if (flags.includes("--json")) {
+      console.log(JSON.stringify({
+        path: view.path,
+        rules: view.rows.map((row) => ({
+          n: row.n,
+          pattern: row.pattern,
+          honoured: row.kind === "active",
+          ...row.reason !== undefined ? { reason: row.reason } : {}
+        }))
+      }, null, 2));
+      return;
+    }
+    console.log(permissionsLines(view).join(`
+`));
+    return;
+  }
+  if (sub === "remove" || sub === "rm") {
+    const target = rest.join(" ").trim();
+    if (target.length === 0 || target.startsWith("--")) {
+      throw new Error("Usage: keryx permissions remove <number | pattern>");
+    }
+    const result = removePermission(target);
+    if (!result.ok)
+      throw new Error(result.text);
+    console.log(result.text);
+    return;
+  }
+  throw new Error(`Unknown permissions subcommand: ${sub}. Run \`keryx permissions --help\`.`);
+}
+var CONTROL;
+var init_permissions_command = __esm(() => {
+  init_shell_permissions();
+  CONTROL = /[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g;
+});
+
+// src/commands/remote-policy-command.ts
+function formatPolicyDuration(ms) {
+  if (ms <= 0)
+    return "none";
+  const seconds = Math.round(ms / 1000);
+  if (seconds < 60)
+    return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const rest = seconds % 60;
+  if (rest !== 0)
+    return `${minutes}m ${rest}s`;
+  if (minutes >= 60 && minutes % 60 === 0)
+    return `${minutes / 60}h`;
+  return `${minutes}m`;
+}
+function countSavedRules(dir) {
+  try {
+    return loadPermissionsView(dir !== undefined ? { dir } : {}).rows.filter((row) => row.kind === "active").length;
+  } catch {
+    return 0;
+  }
+}
+function postureLines(posture) {
+  const lines = [
+    `Mode: ${posture.defaultMode} - a Telegram turn starts with it until /mode changes the shell's mode`,
+    `Run limit: ${formatPolicyDuration(posture.runTimeoutMs)}${posture.runTimeoutMs === 0 ? " (/stop ends a run)" : ""}`,
+    `Approval wait: ${formatPolicyDuration(posture.approvalTimeoutMs)}`,
+    `Saved shell rules: ${posture.savedRules} (${"/permissions"} lists and removes them)`
+  ];
+  if (posture.inForce !== undefined)
+    lines.unshift(`In force now: ${posture.inForce}`);
+  return lines;
+}
+function postureSidebarText(posture) {
+  const limit = posture.runTimeoutMs > 0 ? `limit ${formatPolicyDuration(posture.runTimeoutMs)}` : "no limit";
+  const first = `${posture.defaultMode} \xB7 ${limit} \xB7 wait ${formatPolicyDuration(posture.approvalTimeoutMs)}`;
+  return posture.savedRules > 0 ? `${first}
+${posture.savedRules} saved shell rule${posture.savedRules === 1 ? "" : "s"}` : first;
+}
+function wholeMinutes(word) {
+  if (word === undefined || !/^\d{1,6}$/.test(word))
+    return;
+  return Number(word);
+}
+function parseRemotePolicyArgs(rest) {
+  const words = rest.trim().split(/\s+/).filter((word) => word.length > 0);
+  if (words.length === 0)
+    return { action: "show" };
+  const patch = {};
+  let index = 0;
+  while (index < words.length) {
+    const key = (words[index] ?? "").toLowerCase();
+    const value = words[index + 1];
+    if (value === undefined)
+      return { action: "invalid", message: REMOTE_POLICY_USAGE };
+    const lower = value.toLowerCase();
+    if (key === "mode") {
+      if (patch.permissionMode !== undefined)
+        return { action: "invalid", message: REMOTE_POLICY_USAGE };
+      if (lower === "auto") {
+        return { action: "invalid", message: "auto is not available as a Telegram default: it skips every confirmation. Use /mode auto in the shell if you mean it." };
+      }
+      if (lower !== "ask" && lower !== "trust")
+        return { action: "invalid", message: `Unknown mode '${value}'. Choose ask or trust.` };
+      patch.permissionMode = lower;
+    } else if (key === "limit") {
+      if (patch.runTimeoutMs !== undefined)
+        return { action: "invalid", message: REMOTE_POLICY_USAGE };
+      if (lower === "none" || lower === "off" || lower === "0") {
+        patch.runTimeoutMs = 0;
+      } else {
+        const minutes = wholeMinutes(value);
+        if (minutes === undefined || minutes < 1 || minutes > MAX_LIMIT_MINUTES) {
+          return { action: "invalid", message: `limit must be none or a whole number of minutes from 1 to ${MAX_LIMIT_MINUTES}.` };
+        }
+        patch.runTimeoutMs = minutes * 60000;
+      }
+    } else if (key === "wait") {
+      if (patch.approvalTimeoutMs !== undefined)
+        return { action: "invalid", message: REMOTE_POLICY_USAGE };
+      const minutes = wholeMinutes(value);
+      if (minutes === undefined || minutes < 1 || minutes > MAX_WAIT_MINUTES) {
+        return { action: "invalid", message: `wait must be a whole number of minutes from 1 to ${MAX_WAIT_MINUTES}.` };
+      }
+      patch.approvalTimeoutMs = minutes * 60000;
+    } else {
+      return { action: "invalid", message: REMOTE_POLICY_USAGE };
+    }
+    index += 2;
+  }
+  return { action: "set", patch };
+}
+function loadPosture(deps = {}) {
+  const base = deps.running?.() ?? (() => {
+    const loaded = loadRemoteConfig(deps.dir);
+    return loaded.ok ? { defaultMode: loaded.value.permissionMode, runTimeoutMs: loaded.value.runTimeoutMs, approvalTimeoutMs: loaded.value.approvalTimeoutMs } : undefined;
+  })();
+  if (base === undefined)
+    return;
+  const inForce = deps.inForce?.();
+  return { ...base, ...inForce !== undefined ? { inForce } : {}, savedRules: countSavedRules(deps.dir) };
+}
+function remotePolicyText(rest, deps = {}) {
+  const request = parseRemotePolicyArgs(rest);
+  if (request.action === "invalid")
+    return `${request.message}
+`;
+  if (request.action === "set") {
+    const saved = updateRemotePolicy(request.patch, deps.dir);
+    if (!saved.ok)
+      return `Not changed: ${saved.reason}
+`;
+    deps.applyPolicy?.(request.patch);
+    const posture = loadPosture(deps);
+    const lines = [
+      "Saved. Telegram defaults:",
+      ...posture !== undefined ? postureLines(posture) : [],
+      deps.applyPolicy !== undefined ? "This shell uses them from the next Telegram turn; a shell that registers later gets them when keryx serve restarts." : "Open shells keep their values until they are restarted; keryx serve delivers these to a shell that registers after it restarts.",
+      SHELL_MODE_NOTE
+    ];
+    return `${lines.join(`
+`)}
+`;
+  }
+  const posture = loadPosture(deps);
+  if (posture === undefined) {
+    return `Telegram is not connected, so there is nothing to change yet. Connect it with /channels.
+${REMOTE_POLICY_USAGE}
+`;
+  }
+  return `${["Telegram permissions:", ...postureLines(posture), SHELL_MODE_NOTE, REMOTE_POLICY_USAGE].join(`
+`)}
+`;
+}
+var REMOTE_POLICY_COMMAND = "/remote-policy", REMOTE_POLICY_USAGE, MAX_LIMIT_MINUTES, MAX_WAIT_MINUTES = 60, SHELL_MODE_NOTE = "A /mode in the shell (or typed in the topic) changes the shell's mode and wins for every turn after that; /remote-policy never changes it.";
+var init_remote_policy_command = __esm(() => {
+  init_config11();
+  init_permissions_command();
+  REMOTE_POLICY_USAGE = `Usage: ${REMOTE_POLICY_COMMAND} [mode ask|trust] [limit none|<minutes>] [wait <minutes>]`;
+  MAX_LIMIT_MINUTES = 7 * 24 * 60;
+});
+
 // src/tui/reasoning-display.ts
 function parseThinkDisplayMode(raw) {
   if (raw === undefined) {
@@ -101798,6 +102216,63 @@ function reasoningScope(reasoning) {
       return { scope: "saved" };
   }
 }
+function telegramRows(state) {
+  if (state.telegram === undefined)
+    return [];
+  const posture = state.telegram.posture;
+  const notConnected = "not connected (/channels)";
+  const modeDetail = posture === undefined ? "connect Telegram first" : `${posture.inForce !== undefined ? `in force: ${posture.inForce}; ` : ""}a /mode in the shell wins once used`;
+  const minutes = (ms) => Math.round(ms / 60000);
+  return [
+    {
+      id: "tg-mode",
+      group: "Telegram",
+      label: "Telegram mode",
+      value: posture?.defaultMode ?? notConnected,
+      scope: "saved",
+      detail: modeDetail,
+      command: "/remote-policy",
+      usage: "/remote-policy mode ask|trust",
+      actions: posture === undefined ? [] : ["ask", "trust"].map((mode) => action(mode, `/remote-policy mode ${mode}`, mode === posture.defaultMode))
+    },
+    {
+      id: "tg-limit",
+      group: "Telegram",
+      label: "Telegram run limit",
+      value: posture === undefined ? notConnected : formatPolicyDuration(posture.runTimeoutMs),
+      scope: "saved",
+      detail: "/stop in the topic always ends a run",
+      command: "/remote-policy",
+      usage: "/remote-policy limit none|<minutes>",
+      actions: posture === undefined ? [] : [
+        action("None", "/remote-policy limit none", posture.runTimeoutMs === 0),
+        ...LIMIT_CHOICES_MIN.map((m) => action(`${m} min`, `/remote-policy limit ${m}`, minutes(posture.runTimeoutMs) === m && posture.runTimeoutMs > 0))
+      ]
+    },
+    {
+      id: "tg-wait",
+      group: "Telegram",
+      label: "Telegram approval wait",
+      value: posture === undefined ? notConnected : formatPolicyDuration(posture.approvalTimeoutMs),
+      scope: "saved",
+      detail: "a prompt nobody answers in this time is denied",
+      command: "/remote-policy",
+      usage: "/remote-policy wait <minutes>",
+      actions: posture === undefined ? [] : WAIT_CHOICES_MIN.map((m) => action(`${m} min`, `/remote-policy wait ${m}`, posture.approvalTimeoutMs === m * 60000))
+    },
+    {
+      id: "tg-rules",
+      group: "Telegram",
+      label: "Saved shell rules",
+      value: posture === undefined ? "none" : String(posture.savedRules),
+      scope: "saved",
+      detail: "what Always remembered, from the shell or Telegram",
+      command: "/permissions",
+      usage: "/permissions [list | remove <number | pattern>]",
+      actions: []
+    }
+  ];
+}
 function buildSettingsRows(state) {
   const reasoning = reasoningScope(state.reasoning);
   return [
@@ -101931,7 +102406,8 @@ function buildSettingsRows(state) {
       command: "/jevprofile",
       usage: "/jevprofile",
       actions: []
-    }
+    },
+    ...telegramRows(state)
   ];
 }
 function formatSettingsTable(rows, options = {}) {
@@ -101955,19 +102431,22 @@ function formatSettingsTable(rows, options = {}) {
 `)}
 `;
 }
-var SETTING_GROUPS, onOff = (value) => value ? "on" : "off", EXTERNAL_PRIVACY_DETAIL;
+var SETTING_GROUPS, onOff = (value) => value ? "on" : "off", EXTERNAL_PRIVACY_DETAIL, LIMIT_CHOICES_MIN, WAIT_CHOICES_MIN;
 var init_settings_model = __esm(() => {
   init_agent();
   init_permission_mode();
   init_rendering_mode();
+  init_remote_policy_command();
   init_reasoning_display();
   init_theme();
-  SETTING_GROUPS = ["Safety", "Routing", "Display", "External"];
+  SETTING_GROUPS = ["Safety", "Routing", "Display", "External", "Telegram"];
   EXTERNAL_PRIVACY_DETAIL = {
     project: "this project overrides the per-user setting",
     user: undefined,
     default: "default"
   };
+  LIMIT_CHOICES_MIN = [30, 60];
+  WAIT_CHOICES_MIN = [5, 15, 30];
 });
 
 // src/review/jev-profile.ts
@@ -102630,6 +103109,25 @@ async function orElse(read, fallback) {
     return fallback;
   }
 }
+function readTelegram(live, configDir) {
+  try {
+    const running = live.telegram;
+    const posture = loadPosture({
+      ...configDir !== undefined ? { dir: configDir } : {},
+      ...running !== undefined ? {
+        running: () => ({
+          defaultMode: running.defaultMode,
+          runTimeoutMs: running.runTimeoutMs,
+          approvalTimeoutMs: running.approvalTimeoutMs
+        }),
+        ...running.inForce !== undefined ? { inForce: () => running.inForce } : {}
+      } : {}
+    });
+    return posture === undefined ? {} : { posture };
+  } catch {
+    return {};
+  }
+}
 async function loadSettingsSnapshot(cwd, live, configDir) {
   const saved = loadShellConfig(configDir);
   const projectMode = getProjectPermissionMode(cwd, configDir);
@@ -102655,12 +103153,14 @@ async function loadSettingsSnapshot(cwd, live, configDir) {
       total: RECOMMENDED_JEV_PROFILE.length
     },
     externalAgents: agents.ok ? { on: true } : { on: false, reason: agents.reason },
-    rendering: readRendering(configDir)
+    rendering: readRendering(configDir),
+    telegram: readTelegram(live, configDir)
   };
 }
 var init_settings_state = __esm(() => {
   init_external_agents();
   init_agent();
+  init_remote_policy_command();
   init_review_jev_profile();
   init_external_switch();
   init_permission_mode_config();
@@ -104124,6 +104624,12 @@ var init_help_groups = __esm(() => {
       group: "Automation",
       summary: "Pending remote approvals: list them, allow or deny one call, once (the local answer path of keryx serve)."
     },
+    {
+      kind: "cli",
+      name: "permissions",
+      group: "Automation",
+      summary: "The saved shell rules an Always answer leaves behind: list them (honoured or not, with the reason) and remove one."
+    },
     {
       kind: "cli",
       name: "governance",
@@ -104178,6 +104684,12 @@ var init_help_groups = __esm(() => {
       group: "Automation",
       summary: "Pending remote approvals with scope, consequence and expiry \u2014 allow or deny one call, once."
     },
+    {
+      kind: "slash",
+      name: "/permissions",
+      group: "Automation",
+      summary: "The saved shell rules (what Always remembered): honoured or not, session grants \u2014 remove one."
+    },
     {
       kind: "slash",
       name: "/external-diff",
@@ -104226,6 +104738,12 @@ var init_help_groups = __esm(() => {
       group: "Automation",
       summary: "How Telegram replies are written: tables and lists as rich messages or HTML, with a fallback. [auto|rich|html|plain]."
     },
+    {
+      kind: "slash",
+      name: "/remote-policy",
+      group: "Automation",
+      summary: "Telegram defaults for a turn started there: mode ask|trust, run limit, approval wait. Never changes the shell's /mode."
+    },
     {
       kind: "cli",
       name: "acp",
@@ -114453,6 +114971,155 @@ var init_reviews_inspector = __esm(() => {
   ];
 });
 
+// src/tui/permissions-inspector.ts
+function formatPermissionsModal(view, selected, notice) {
+  const lines = [];
+  const rowStart = [];
+  const active = view.rows.filter((row) => row.kind === "active").length;
+  lines.push(view.rows.length === 0 ? "No saved shell rules: every command that is not read-only asks first." : `Saved shell rules (${active}) - d removes the selected one, it asks again from then on`);
+  if (notice !== undefined && notice.length > 0)
+    lines.push(notice);
+  lines.push("");
+  let section;
+  view.rows.forEach((row, index) => {
+    if (row.kind !== section) {
+      section = row.kind;
+      if (row.kind === "inactive")
+        lines.push("Not honoured: kept in the file, they approve nothing", "");
+      if (row.kind === "session")
+        lines.push("Granted for this session only", "");
+    }
+    rowStart.push(lines.length);
+    lines.push(`${index === selected ? ">" : " "} ${row.n}. ${patternOnOneLine(row.pattern)}`);
+    if (row.reason !== undefined)
+      lines.push(`     ${row.reason}`);
+    lines.push("");
+  });
+  lines.push(`File: ${view.path}`);
+  return { rows: view.rows, lines, rowStart };
+}
+function openPermissions(otui, chrome, options) {
+  const core = otui;
+  const r = chrome?.renderer;
+  const rendererHint = options.renderer ?? chrome?.renderer;
+  const panelRows = typeof rendererHint?.width === "number" && typeof rendererHint.height === "number" ? modalBodyRows(resolveModalPanelSize(rendererHint.width, rendererHint.height).height) : 13;
+  const bodyRows = Math.max(1, options.visibleRows ?? panelRows);
+  const load = options.load ?? (() => loadPermissionsView(options.sessionAllow !== undefined ? { sessionAllow: options.sessionAllow } : {}));
+  const remove = options.remove ?? ((target) => removePermission(target, {
+    ...options.sessionAllow !== undefined ? { sessionAllow: options.sessionAllow } : {},
+    ...options.onChanged !== undefined ? { onChanged: options.onChanged } : {}
+  }));
+  let selected = 0;
+  let scroll = 0;
+  let width;
+  let bodyNode;
+  let closed = false;
+  let notice;
+  let armed;
+  const keys = {};
+  const model = () => formatPermissionsModal(load(), selected, armed !== undefined ? `Remove ${patternOnOneLine(armed)}? press y to confirm, any other key cancels` : notice);
+  const clampSelected = (rows) => {
+    selected = Math.min(Math.max(0, rows - 1), Math.max(0, selected));
+  };
+  const visible = () => {
+    const view = model();
+    clampSelected(view.rows.length);
+    return windowLines(wrapLines(view.lines.join(`
+`), width).split(`
+`), scroll, bodyRows);
+  };
+  const paint = () => {
+    if (closed)
+      return;
+    const view = model();
+    clampSelected(view.rows.length);
+    const wrapped = wrapLines(view.lines.join(`
+`), width).split(`
+`);
+    const start = view.rowStart[selected] ?? 0;
+    scroll = clampScroll(scrollToReveal(start, scroll, bodyRows), wrapped.length, bodyRows);
+    if (bodyNode !== undefined)
+      bodyNode.content = core.t`${dimChunk(core, windowLines(wrapped, scroll, bodyRows).join(`
+`))}`;
+  };
+  let unsubscribeTheme = () => {};
+  const handle = openModal(core, chrome, {
+    title: PERMISSIONS_COMMAND,
+    tabs: [{ id: "rules", label: "Shell rules" }],
+    footer: PERMISSIONS_FOOTER,
+    renderTab: (_tabId, body, ctx) => {
+      width = ctx.width;
+      const parent = body;
+      bodyNode = new core.TextRenderable(r, { id: "permissions-body", content: "" });
+      parent.add(bodyNode);
+      paint();
+    },
+    onClose: () => {
+      closed = true;
+      keys.off?.();
+      unsubscribeTheme();
+    }
+  });
+  if (handle === undefined)
+    return;
+  const modal = handle;
+  unsubscribeTheme = onThemeChange(guardedThemeRepaint("permissions-modal", paint, () => closed || isRenderableGone(bodyNode) || r?.isDestroyed === true));
+  const selectedRow = () => model().rows[selected];
+  keys.off = options.onKeypress((key) => {
+    if (closed || options.inputBlocked?.() === true)
+      return;
+    const token = key.name || key.sequence;
+    if (armed !== undefined) {
+      const pattern = armed;
+      armed = undefined;
+      if (token === "y") {
+        notice = remove(pattern).text;
+      }
+      paint();
+      return;
+    }
+    if (token === "up" || token === "k") {
+      selected = Math.max(0, selected - 1);
+      notice = undefined;
+    } else if (token === "down" || token === "j") {
+      selected += 1;
+      notice = undefined;
+    } else if (token === "d") {
+      const row = selectedRow();
+      if (row === undefined)
+        notice = "Nothing to remove.";
+      else
+        armed = row.pattern;
+    } else {
+      return;
+    }
+    paint();
+  });
+  return {
+    ...modal,
+    visibleLines: visible,
+    selected: selectedRow,
+    reload: () => {
+      paint();
+    }
+  };
+}
+var PERMISSIONS_COMMAND = "/permissions", PERMISSIONS_FOOTER;
+var init_permissions_inspector = __esm(() => {
+  init_permissions_command();
+  init_flow_inspector();
+  init_modal_host();
+  init_theme();
+  init_theme_repaint();
+  init_theme_text();
+  PERMISSIONS_FOOTER = [
+    { key: "\u2191/\u2193", label: "move" },
+    { key: "d", label: "remove" },
+    { key: "y", label: "confirm" },
+    { key: "esc", label: "close" }
+  ];
+});
+
 // src/lib/serve-config.ts
 import { existsSync as existsSync42 } from "fs";
 import path249 from "path";
@@ -114789,6 +115456,9 @@ function channelsRoutePath(route) {
 function isSessionId(value) {
   return typeof value === "string" && SESSION_ID_PATTERN.test(value);
 }
+function isApprovalId(value) {
+  return typeof value === "string" && APPROVAL_ID_PATTERN.test(value);
+}
 function approvalCallbackData(approvalId, decision) {
   return `ap:${approvalId}:${decision}`;
 }
@@ -114861,7 +115531,7 @@ class SseParser {
     return frames;
   }
 }
-var REMOTE_API_PREFIX = "/v1/remote", REMOTE_SCHEMA_VERSION = "1.0.0", REMOTE_ROUTE_METHODS, CHANNELS_ROUTE_METHODS, MAX_REMOTE_BODY_BYTES, MAX_PROJECT_CHARS = 256, MAX_APPROVAL_PROMPT_CHARS = 3000, MAX_KEYBOARD_ROWS = 8, MAX_KEYBOARD_BUTTONS_PER_ROW = 8, MAX_BUTTON_TEXT_CHARS = 64, MAX_CALLBACK_DATA_BYTES = 64, DEFAULT_APPROVAL_TIMEOUT_MS, MAX_APPROVAL_TIMEOUT_MS, MIN_APPROVAL_TIMEOUT_MS = 100, DEFAULT_KEEPALIVE_MS = 15000, DEFAULT_ACK_TIMEOUT_MS = 30000, SESSION_ID_PATTERN, APPROVAL_CALLBACK_PATTERN, RESERVED_CALLBACK_PREFIX = "ap:", CHOICE_CALLBACK_PATTERN, RESERVED_CHOICE_PREFIX = "pk:", MAX_PROMPT_BUTTONS = 24, MESSAGE_STATES, SSE_KEEPALIVE_FRAME = `: keepalive
+var REMOTE_API_PREFIX = "/v1/remote", REMOTE_SCHEMA_VERSION = "1.0.0", REMOTE_ROUTE_METHODS, CHANNELS_ROUTE_METHODS, MAX_REMOTE_BODY_BYTES, MAX_PROJECT_CHARS = 256, MAX_APPROVAL_PROMPT_CHARS = 3000, MAX_KEYBOARD_ROWS = 8, MAX_KEYBOARD_BUTTONS_PER_ROW = 8, MAX_BUTTON_TEXT_CHARS = 64, MAX_CALLBACK_DATA_BYTES = 64, DEFAULT_APPROVAL_TIMEOUT_MS, MAX_APPROVAL_TIMEOUT_MS, MIN_APPROVAL_TIMEOUT_MS = 100, DEFAULT_APPROVAL_ACK_MS = 5000, DEFAULT_KEEPALIVE_MS = 15000, DEFAULT_ACK_TIMEOUT_MS = 30000, SESSION_ID_PATTERN, APPROVAL_ID_PATTERN, APPROVAL_CALLBACK_PATTERN, RESERVED_CALLBACK_PREFIX = "ap:", CHOICE_CALLBACK_PATTERN, RESERVED_CHOICE_PREFIX = "pk:", MAX_PROMPT_BUTTONS = 24, MAX_REMEMBER_PATTERN_CHARS = 300, APPROVAL_INPUT_PREVIEW_CHARS = 1500, MESSAGE_STATES, SSE_KEEPALIVE_FRAME = `: keepalive
 
 `;
 var init_protocol2 = __esm(() => {
@@ -114871,9 +115541,11 @@ var init_protocol2 = __esm(() => {
     heartbeat: "POST",
     reply: "POST",
     approval: "POST",
+    "approval-result": "POST",
     prompt: "POST",
     state: "POST",
     ack: "POST",
+    "approval-ack": "POST",
     stream: "GET"
   };
   CHANNELS_ROUTE_METHODS = {
@@ -114889,7 +115561,8 @@ var init_protocol2 = __esm(() => {
   DEFAULT_APPROVAL_TIMEOUT_MS = 5 * 60000;
   MAX_APPROVAL_TIMEOUT_MS = 60 * 60000;
   SESSION_ID_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$/;
-  APPROVAL_CALLBACK_PATTERN = /^ap:(ap[0-9a-f]{12}):(allow|deny)$/;
+  APPROVAL_ID_PATTERN = /^ap[0-9a-f]{12}$/;
+  APPROVAL_CALLBACK_PATTERN = /^ap:(ap[0-9a-f]{12}):(allow|deny|always)$/;
   CHOICE_CALLBACK_PATTERN = /^pk:(pk[0-9a-f]{12}):(\d{1,3})$/;
   MESSAGE_STATES = ["reading", "working", "done", "failed"];
 });
@@ -115197,6 +115870,16 @@ var init_shell_token = __esm(() => {
 });
 
 // src/remote/client.ts
+function readApprovalEvent(parsed) {
+  if (parsed === null || typeof parsed !== "object")
+    return;
+  const o = parsed;
+  if (typeof o.approvalId !== "string" || o.approvalId.length === 0)
+    return;
+  const decision = o.decision === "allow" || o.decision === "always" ? o.decision : "deny";
+  const fromId = typeof o.fromId === "number" && Number.isSafeInteger(o.fromId) ? o.fromId : undefined;
+  return { approvalId: o.approvalId, pressed: { decision, ...fromId === undefined ? {} : { fromId } } };
+}
 function ownProcessIsAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0) {
     return false;
@@ -115253,12 +115936,18 @@ class RemoteClient {
   inboundChain = Promise.resolve();
   waiters = new Map;
   earlyDecisions = new Map;
+  seenApprovals = new Map;
+  earlyDecisionMs;
+  unackedApprovals = new Map;
+  lingerTimers = new Set;
   choiceWaiters = new Map;
   earlyChoices = new Map;
   firstResult;
   name;
   threadId;
   runTimeoutMs;
+  permissionMode;
+  approvalTimeoutMs;
   lastHeartbeatAt;
   constructor(options) {
     this.options = options;
@@ -115269,10 +115958,20 @@ class RemoteClient {
     this.sleep = options.sleep ?? abortableSleep2;
     this.requestTimeoutMs = options.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
     this.isAlive = options.isAlive ?? ownProcessIsAlive;
+    this.earlyDecisionMs = options.earlyDecisionMs ?? DEFAULT_EARLY_DECISION_MS;
   }
   get connected() {
     return this.streamOpen && !this.stopped;
   }
+  get unconfirmedApprovals() {
+    const cutoff = Date.now() - UNCONFIRMED_APPROVAL_LINGER_MS;
+    for (const [id, at] of [...this.unackedApprovals.entries()]) {
+      if (at < cutoff) {
+        this.unackedApprovals.delete(id);
+      }
+    }
+    return this.unackedApprovals.size;
+  }
   start() {
     if (this.started) {
       return Promise.resolve({ ok: false, code: "already-started", message: "this client was already started", retrying: false });
@@ -115323,6 +116022,10 @@ class RemoteClient {
     }
     this.lifetime.abort();
     this.streamAbort?.abort();
+    for (const timer of this.lingerTimers) {
+      clearTimeout(timer);
+    }
+    this.lingerTimers.clear();
     this.failApprovals();
     this.firstResult?.({ ok: false, code: "stopped", message: "the client was stopped before it connected", retrying: false });
     this.firstResult = undefined;
@@ -115340,36 +116043,71 @@ class RemoteClient {
     }
   }
   async requestApproval(prompt, timeoutMs) {
-    if (!this.connected) {
-      return "deny";
+    return (await this.askApproval(prompt, timeoutMs)).decision;
+  }
+  async askApproval(prompt, timeoutMs, options = {}) {
+    if (!this.connected || options.signal?.aborted === true) {
+      return { decision: "deny" };
     }
-    const body = { sessionId: this.options.sessionId, prompt, timeoutMs };
+    const body = {
+      sessionId: this.options.sessionId,
+      prompt,
+      timeoutMs,
+      ...options.remember === undefined ? {} : { remember: options.remember }
+    };
     let approvalId;
     try {
       const response = await this.post("approval", body);
       if (!response.ok) {
-        return "deny";
+        return { decision: "deny" };
+      }
+      const id = (await response.json())?.approvalId;
+      if (typeof id !== "string" || id.length === 0) {
+        return { decision: "deny" };
       }
-      approvalId = (await response.json()).approvalId;
+      approvalId = id;
     } catch {
-      return "deny";
+      return { decision: "deny" };
     }
     const early = this.earlyDecisions.get(approvalId);
     if (early !== undefined) {
+      clearTimeout(early.timer);
       this.earlyDecisions.delete(approvalId);
-      return early;
+      this.settleApproval(approvalId, early.pressed.decision, true);
+      return { ...early.pressed, approvalId };
     }
     if (!this.connected) {
-      return "deny";
+      return { decision: "deny" };
     }
     return new Promise((resolve) => {
+      const signal = options.signal;
+      const onAbort = () => {
+        const waiter = this.waiters.get(approvalId);
+        if (waiter !== undefined)
+          clearTimeout(waiter.timer);
+        this.waiters.delete(approvalId);
+        resolve({ decision: "deny", approvalId });
+      };
       const timer = setTimeout(() => {
+        signal?.removeEventListener("abort", onAbort);
         this.waiters.delete(approvalId);
-        resolve("deny");
+        resolve({ decision: "deny" });
       }, timeoutMs);
-      this.waiters.set(approvalId, { resolve, timer });
+      this.waiters.set(approvalId, {
+        resolve: (pressed) => {
+          signal?.removeEventListener("abort", onAbort);
+          resolve({ ...pressed, approvalId });
+        },
+        timer
+      });
+      signal?.addEventListener("abort", onAbort, { once: true });
     });
   }
+  async reportApprovalResult(approvalId, remembered) {
+    try {
+      await this.post("approval-result", { sessionId: this.options.sessionId, approvalId, remembered });
+    } catch {}
+  }
   async requestChoice(text, rows, timeoutMs, forUserId) {
     if (!this.connected) {
       return;
@@ -115540,7 +116278,14 @@ class RemoteClient {
               this.lastHeartbeatAt = Date.now();
               this.options.onStatus?.({ state: "connected" });
               if (this.name !== undefined && this.threadId !== undefined && this.runTimeoutMs !== undefined) {
-                this.settleFirst({ ok: true, name: this.name, threadId: this.threadId, runTimeoutMs: this.runTimeoutMs });
+                this.settleFirst({
+                  ok: true,
+                  name: this.name,
+                  threadId: this.threadId,
+                  runTimeoutMs: this.runTimeoutMs,
+                  ...this.permissionMode === undefined ? {} : { permissionMode: this.permissionMode },
+                  ...this.approvalTimeoutMs === undefined ? {} : { approvalTimeoutMs: this.approvalTimeoutMs }
+                });
               }
             } else if (status.kind === "superseded") {
               throw new FatalClientError("superseded", "another connection for this session replaced this one");
@@ -115576,6 +116321,8 @@ class RemoteClient {
       this.name = result.name;
       this.threadId = result.threadId;
       this.runTimeoutMs = result.runTimeoutMs;
+      this.permissionMode = result.permissionMode;
+      this.approvalTimeoutMs = result.approvalTimeoutMs;
       return;
     }
     const error = await response.json().catch(() => ({}));
@@ -115599,8 +116346,7 @@ class RemoteClient {
         return;
       });
     } else if (event === "approval") {
-      const approval = parsed;
-      this.resolveApproval(approval.approvalId, approval.decision);
+      this.handleApprovalFrame(parsed);
     } else if (event === "choice") {
       const choice = parsed;
       this.resolveChoice(choice.promptId, choice.index);
@@ -115645,16 +116391,115 @@ class RemoteClient {
       await this.post("ack", { sessionId: this.options.sessionId, updateId });
     } catch {}
   }
+  handleApprovalFrame(parsed) {
+    const read = readApprovalEvent(parsed);
+    if (read === undefined || !isApprovalId(read.approvalId)) {
+      return;
+    }
+    const { approvalId, pressed } = read;
+    const seen = this.seenApprovals.get(approvalId);
+    if (seen === "pending") {
+      return;
+    }
+    this.countUnconfirmed(approvalId);
+    if (seen !== undefined) {
+      this.ackApproval(approvalId, seen === "applied");
+      return;
+    }
+    if (this.waiters.has(approvalId)) {
+      this.settleApproval(approvalId, pressed.decision, true, () => this.resolveApproval(approvalId, pressed));
+      return;
+    }
+    this.rememberSeen(approvalId, "pending");
+    this.parkEarlyDecision(approvalId, pressed);
+  }
+  rememberSeen(approvalId, outcome) {
+    this.seenApprovals.delete(approvalId);
+    this.seenApprovals.set(approvalId, outcome);
+    if (this.seenApprovals.size > MAX_SEEN_APPROVALS) {
+      const oldest = this.seenApprovals.keys().next().value;
+      if (oldest !== undefined) {
+        this.seenApprovals.delete(oldest);
+      }
+    }
+  }
+  countUnconfirmed(approvalId) {
+    this.unackedApprovals.delete(approvalId);
+    this.unackedApprovals.set(approvalId, Date.now());
+    this.notifyUnconfirmed();
+    while (this.unackedApprovals.size > MAX_UNCONFIRMED_APPROVALS) {
+      const oldest = this.unackedApprovals.keys().next().value;
+      if (oldest === undefined) {
+        break;
+      }
+      this.unackedApprovals.delete(oldest);
+    }
+  }
+  settleApproval(approvalId, decision, applied, apply) {
+    this.rememberSeen(approvalId, applied ? "applied" : "not-applied");
+    try {
+      this.options.onApprovalFrame?.({ approvalId, decision, applied });
+    } catch {}
+    apply?.();
+    this.ackApproval(approvalId, applied);
+  }
+  parkEarlyDecision(approvalId, pressed) {
+    while (this.earlyDecisions.size >= MAX_EARLY_DECISIONS) {
+      const oldest = this.earlyDecisions.keys().next().value;
+      if (oldest === undefined) {
+        break;
+      }
+      this.dropEarlyDecision(oldest);
+    }
+    const timer = setTimeout(() => this.dropEarlyDecision(approvalId), this.earlyDecisionMs);
+    timer.unref?.();
+    this.earlyDecisions.set(approvalId, { pressed, timer });
+  }
+  dropEarlyDecision(approvalId) {
+    const early = this.earlyDecisions.get(approvalId);
+    if (early === undefined) {
+      return;
+    }
+    clearTimeout(early.timer);
+    this.earlyDecisions.delete(approvalId);
+    if (!this.stopped) {
+      this.settleApproval(approvalId, early.pressed.decision, false);
+    }
+  }
+  async ackApproval(approvalId, applied) {
+    let confirmed = false;
+    try {
+      const response = await this.post("approval-ack", { sessionId: this.options.sessionId, approvalId, applied });
+      confirmed = response.ok;
+    } catch {}
+    if (this.stopped) {
+      return;
+    }
+    if (confirmed) {
+      this.unackedApprovals.delete(approvalId);
+      this.notifyUnconfirmed();
+      return;
+    }
+    this.lingerTimers.add(this.scheduleUnref(() => {
+      this.notifyUnconfirmed();
+    }, UNCONFIRMED_APPROVAL_LINGER_MS + 50));
+  }
+  notifyUnconfirmed() {
+    try {
+      this.options.onUnconfirmedChange?.();
+    } catch {}
+  }
+  scheduleUnref(fn, ms) {
+    const timer = setTimeout(() => {
+      this.lingerTimers.delete(timer);
+      fn();
+    }, ms);
+    timer.unref?.();
+    return timer;
+  }
   resolveApproval(approvalId, decision) {
     const waiter = this.waiters.get(approvalId);
     if (waiter === undefined) {
-      if (this.earlyDecisions.size >= MAX_EARLY_DECISIONS) {
-        const oldest = this.earlyDecisions.keys().next().value;
-        if (oldest !== undefined) {
-          this.earlyDecisions.delete(oldest);
-        }
-      }
-      this.earlyDecisions.set(approvalId, decision);
       return;
     }
     clearTimeout(waiter.timer);
@@ -115689,13 +116534,15 @@ class RemoteClient {
     for (const [id, waiter] of [...this.waiters.entries()]) {
       clearTimeout(waiter.timer);
       this.waiters.delete(id);
-      waiter.resolve("deny");
+      waiter.resolve({ decision: "deny" });
+    }
+    for (const id of [...this.earlyDecisions.keys()]) {
+      this.dropEarlyDecision(id);
     }
-    this.earlyDecisions.clear();
     this.failChoices();
   }
 }
-var UNVERIFIED_SERVE_MESSAGE = "the program answering on keryx serve's port did not prove it is the keryx serve this shell trusts; its answer was ignored. Restart `keryx serve` (an older serve cannot prove itself; update keryx on both sides)", FatalClientError, TransientClientError, DEFAULT_BACKOFF_INITIAL_MS = 250, DEFAULT_BACKOFF_MAX_MS = 15000, DEFAULT_REQUEST_TIMEOUT_MS = 1e4, MAX_EARLY_DECISIONS = 32, MAX_COMPLETED_IDS = 256;
+var UNVERIFIED_SERVE_MESSAGE = "the program answering on keryx serve's port did not prove it is the keryx serve this shell trusts; its answer was ignored. Restart `keryx serve` (an older serve cannot prove itself; update keryx on both sides)", FatalClientError, TransientClientError, DEFAULT_BACKOFF_INITIAL_MS = 250, DEFAULT_BACKOFF_MAX_MS = 15000, DEFAULT_REQUEST_TIMEOUT_MS = 1e4, MAX_EARLY_DECISIONS = 32, DEFAULT_EARLY_DECISION_MS = 2000, MAX_SEEN_APPROVALS = 256, UNCONFIRMED_APPROVAL_LINGER_MS = 60000, MAX_UNCONFIRMED_APPROVALS = 64, MAX_COMPLETED_IDS = 256;
 var init_client3 = __esm(() => {
   init_serve_config();
   init_lease();
@@ -115851,6 +116698,7 @@ var init_command_gateway = __esm(() => {
     { name: "connect", kind: "picker", description: "Switch to a connected provider with buttons" },
     { name: "resume", kind: "picker", description: "Return to an earlier session with buttons" },
     { name: "sessions", kind: "builtin", description: "List recent sessions" },
+    { name: "stop", kind: "builtin", description: "Stop the run you started from Telegram" },
     { name: "new", kind: "text", description: "Start a new session; this topic stays bound to it" },
     { name: "clear", kind: "text", description: "Same as /new" },
     { name: "compact", kind: "text", description: "Compact the conversation: /compact [focus]" },
@@ -115896,7 +116744,9 @@ var init_command_gateway = __esm(() => {
     governance: "it needs the shell's screen",
     decisions: "it opens a panel in the shell",
     expand: "it needs the shell's screen",
-    interrupt: "use the Stop button on a message, or stop it in the shell",
+    interrupt: "use /stop here to end a run you started from Telegram, or stop it in the shell",
+    permissions: "it opens a panel in the shell; saved rules are changed there, never from a chat",
+    "remote-policy": "it changes what Telegram may do without asking; use the shell",
     demote: "it works on the shell's own tasks",
     models: "use /model",
     "external-diff": "listing and applying external patches stays in the shell, where the patch hash is typed",
@@ -115947,6 +116797,8 @@ class RemoteCommandRouter {
             await this.listSessionsText();
             ended(end, "done");
           });
+        } else if (decision.command === "stop") {
+          this.stop(end);
         } else {
           this.ctx.reply(this.ctx.compose(remoteHelpText())).catch(() => false);
           ended(end, "done");
@@ -115973,6 +116825,17 @@ class RemoteCommandRouter {
         return;
     }
   }
+  stop(end) {
+    const result = this.ctx.host.stopTelegramTurn?.() ?? "idle";
+    if (result === "stopped") {
+      ended(end, "done");
+      return;
+    }
+    const text = result === "operator" ? "/stop did nothing: the running turn was started in the shell, so only the shell can stop it." : "/stop did nothing: no run started from Telegram is going on.";
+    this.ctx.record(`/stop: ${result === "operator" ? "turn belongs to the shell" : "nothing to stop"}`);
+    this.ctx.reply(text).catch(() => false);
+    ended(end, "failed");
+  }
   async idle() {
     await this.chain;
     if (this.detached > 0) {
@@ -116259,9 +117122,27 @@ function composeReply(text) {
   return `${safe.slice(0, REMOTE_REPLY_MAX_CHARS)}
 [cut: the full reply is in the shell]`;
 }
+function mapApprovalAnswer(got, offered) {
+  if (got === null || typeof got !== "object")
+    return { decision: "deny", always: false };
+  const o = got;
+  const yes = o.decision === "allow" || o.decision === "always";
+  const approvalId = typeof o.approvalId === "string" && o.approvalId.length > 0 ? o.approvalId : undefined;
+  const fromId = typeof o.fromId === "number" && Number.isSafeInteger(o.fromId) ? o.fromId : undefined;
+  return {
+    decision: yes ? "allow" : "deny",
+    always: o.decision === "always" && offered,
+    ...approvalId === undefined ? {} : { approvalId },
+    ...fromId === undefined ? {} : { fromId }
+  };
+}
 function composeApprovalPrompt(prompt) {
   const safe = redactSensitiveText(prompt).trim();
-  return safe.length <= MAX_APPROVAL_PROMPT_CHARS ? safe : `${safe.slice(0, MAX_APPROVAL_PROMPT_CHARS - 1)}\u2026`;
+  if (safe.length <= MAX_APPROVAL_PROMPT_CHARS)
+    return safe;
+  const note = `
+[cut: the rest of this prompt is in the shell]`;
+  return `${safe.slice(0, MAX_APPROVAL_PROMPT_CHARS - note.length - 1)}\u2026${note}`;
 }
 function describeApprovalForTopic(tool, inputJson, meta) {
   const lines = [];
@@ -116281,8 +117162,12 @@ function describeApprovalForTopic(tool, inputJson, meta) {
           shown = o.patch;
       }
     } catch {}
-    shown = shown.length > APPROVAL_INPUT_PREVIEW_CHARS ? `${shown.slice(0, APPROVAL_INPUT_PREVIEW_CHARS)}\u2026` : shown;
+    const total = shown.length;
+    shown = total > APPROVAL_INPUT_PREVIEW_CHARS ? `${shown.slice(0, APPROVAL_INPUT_PREVIEW_CHARS)}\u2026` : shown;
     lines.push(`Approve ${tool}?`, shown);
+    if (total > APPROVAL_INPUT_PREVIEW_CHARS) {
+      lines.push(`[cut: only the first ${APPROVAL_INPUT_PREVIEW_CHARS} of ${total} characters are shown; the rest is in the shell]`);
+    }
   }
   if (meta?.destructive === true)
     lines.push("Warning: this can delete or overwrite files.");
@@ -116300,28 +117185,33 @@ class RemoteBridge {
   events = [];
   host;
   now;
-  approvalTimeoutMs;
+  approvalOverrideMs;
+  policyOverride = {};
   connectedOnce = false;
   clientConnected = false;
   tgTurn = false;
   lastAssistantText = "";
   runTimer;
   timedOut = false;
+  stoppedByUser = false;
+  turnAbort;
   closing;
   router;
   keepTopic = false;
   switched = false;
   waiting = [];
   currentUpdate;
+  currentFromId;
   constructor(options) {
     this.options = options;
     this.host = options.host;
     this.now = options.now ?? Date.now;
-    this.approvalTimeoutMs = options.approvalTimeoutMs ?? DEFAULT_APPROVAL_TIMEOUT_MS;
+    this.approvalOverrideMs = options.approvalTimeoutMs;
     this.router = new RemoteCommandRouter({
       host: {
         isBusy: () => this.host.isBusy(),
         cancelTurn: () => this.host.cancelTurn(),
+        stopTelegramTurn: () => this.stopTelegramTurn(),
         ...this.host.runCommand !== undefined ? { runCommand: (line) => this.host.runCommand(line) } : {},
         ...this.host.busyRefusal !== undefined ? { busyRefusal: (line) => this.host.busyRefusal(line) } : {},
         ...this.host.listModels !== undefined ? { listModels: (id) => this.host.listModels(id) } : {},
@@ -116368,6 +117258,25 @@ class RemoteBridge {
   get telegramTurnActive() {
     return this.tgTurn;
   }
+  get telegramTurnUserId() {
+    return this.tgTurn ? this.currentFromId : undefined;
+  }
+  get configuredPermissionMode() {
+    return this.policyOverride.permissionMode ?? this.client?.permissionMode ?? "ask";
+  }
+  get approvalTimeoutMs() {
+    return this.policyOverride.approvalTimeoutMs ?? this.approvalOverrideMs ?? this.client?.approvalTimeoutMs ?? DEFAULT_APPROVAL_TIMEOUT_MS;
+  }
+  get runTimeoutMs() {
+    return this.policyOverride.runTimeoutMs ?? this.client?.runTimeoutMs ?? 0;
+  }
+  applyPolicy(next) {
+    this.policyOverride = { ...this.policyOverride, ...next };
+    this.host.onChange?.();
+  }
+  recordApproval(text) {
+    this.push("approval", preview2(text));
+  }
   status() {
     const client = this.client;
     if (client === undefined) {
@@ -116375,10 +117284,12 @@ class RemoteBridge {
     }
     const online = this.clientConnected && client.connected;
     const heartbeat = client.lastHeartbeatAt;
+    const unconfirmed = client.unconfirmedApprovals ?? 0;
     return {
       state: online ? "on" : "offline",
       ...client.name !== undefined ? { name: client.name } : {},
       ...heartbeat !== undefined ? { heartbeatAgeMs: Math.max(0, this.now() - heartbeat) } : {},
+      ...unconfirmed > 0 ? { unconfirmedApprovals: unconfirmed } : {},
       events: [...this.events]
     };
   }
@@ -116405,7 +117316,9 @@ class RemoteBridge {
       ...name !== undefined ? { name } : {},
       ...this.options.dir !== undefined ? { dir: this.options.dir } : {},
       onLine: (text, meta) => this.accept(text, meta),
-      onStatus: (status) => this.onStatus(status)
+      onStatus: (status) => this.onStatus(status),
+      onApprovalFrame: (frame) => this.host.notice(frame.applied ? `\u25C7 approval ${frame.approvalId} ${frame.decision === "allow" ? "allowed" : "denied"} from Telegram` : `\u25C7 approval ${frame.approvalId}: ${frame.decision === "allow" ? "an allow" : "a deny"} from Telegram arrived but nothing here was waiting for it; not applied`),
+      onUnconfirmedChange: () => this.host.onChange?.()
     };
     const client = this.options.makeClient !== undefined ? this.options.makeClient(clientOptions) : new RemoteClient(clientOptions);
     this.client = client;
@@ -116486,7 +117399,7 @@ class RemoteBridge {
       return;
     }
     this.push("line", `Telegram: ${preview2(line)}`);
-    this.waiting.push({ updateId: meta.updateId, line });
+    this.waiting.push({ updateId: meta.updateId, line, ...meta.fromId === undefined ? {} : { fromId: meta.fromId } });
     if (this.host.isBusy()) {
       this.host.enqueue(line);
     } else {
@@ -116541,20 +117454,37 @@ class RemoteBridge {
       return;
     const next = this.waiting.shift();
     this.currentUpdate = next?.updateId;
+    this.currentFromId = next?.fromId;
     if (next !== undefined)
       this.report(next.updateId, "working");
     this.tgTurn = true;
     this.lastAssistantText = "";
     this.timedOut = false;
-    const limit = this.client.runTimeoutMs;
-    if (limit !== undefined && limit > 0) {
+    this.stoppedByUser = false;
+    this.turnAbort = new AbortController;
+    const limit = this.runTimeoutMs;
+    if (limit > 0) {
       this.runTimer = setTimeout(() => {
         this.timedOut = true;
         this.push("error", "run time limit reached; stopping the turn");
+        this.turnAbort?.abort();
         this.host.cancelTurn();
       }, limit);
     }
   }
+  stopTelegramTurn() {
+    if (this.client === undefined)
+      return "idle";
+    if (!this.tgTurn)
+      return this.host.isBusy() ? "operator" : "idle";
+    if (this.stoppedByUser)
+      return "stopped";
+    this.stoppedByUser = true;
+    this.push("command", "/stop: stopping the turn");
+    this.turnAbort?.abort();
+    this.host.cancelTurn();
+    return "stopped";
+  }
   assistantText(text) {
     if (!this.tgTurn)
       return;
@@ -116585,15 +117515,18 @@ class RemoteBridge {
     const client = this.client;
     const text = this.lastAssistantText;
     const timedOut = this.timedOut;
+    const stopped = this.stoppedByUser && !timedOut;
     const updateId = this.currentUpdate;
     this.endTurnState();
     if (client === undefined)
       return;
     if (updateId !== undefined)
-      this.report(updateId, outcome.failed || timedOut ? "failed" : "done");
+      this.report(updateId, outcome.failed || timedOut || stopped ? "failed" : "done");
     let body;
-    if (timedOut) {
-      body = "Stopped: this run went over the time limit for runs started from Telegram.";
+    if (stopped) {
+      body = "Stopped by you.";
+    } else if (timedOut) {
+      body = "Stopped: this run went over the time limit you set for runs started from Telegram (runTimeoutMs).";
     } else if (outcome.failed && text.trim().length === 0) {
       body = "The run failed. The details are in the shell.";
     } else if (text.trim().length === 0) {
@@ -116607,31 +117540,56 @@ class RemoteBridge {
   endTurnState() {
     this.tgTurn = false;
     this.currentUpdate = undefined;
+    this.currentFromId = undefined;
     this.lastAssistantText = "";
     this.timedOut = false;
+    this.stoppedByUser = false;
+    this.turnAbort?.abort();
+    this.turnAbort = undefined;
     if (this.runTimer !== undefined) {
       clearTimeout(this.runTimer);
       this.runTimer = undefined;
     }
   }
   async requestApproval(prompt) {
+    return (await this.askApproval(prompt)).decision;
+  }
+  async askApproval(prompt, options = {}) {
     const client = this.client;
     if (client === undefined || !client.connected) {
       this.push("approval", "denied: not connected");
-      return "deny";
+      return { decision: "deny", always: false };
     }
     this.push("approval", "asked in the topic");
-    let decision;
+    let answer;
     try {
-      decision = await client.requestApproval(composeApprovalPrompt(prompt), this.approvalTimeoutMs);
+      const text = composeApprovalPrompt(prompt);
+      const timeoutMs = this.approvalTimeoutMs;
+      if (client.askApproval !== undefined) {
+        const signal = this.turnAbort?.signal;
+        const got = await client.askApproval(text, timeoutMs, {
+          ...options.remember === undefined ? {} : { remember: options.remember },
+          ...signal === undefined ? {} : { signal }
+        });
+        answer = mapApprovalAnswer(got, options.remember !== undefined);
+      } else {
+        const decision = await client.requestApproval(text, timeoutMs);
+        answer = { decision: decision === "allow" || decision === "always" ? "allow" : "deny", always: false };
+      }
     } catch {
-      decision = "deny";
+      answer = { decision: "deny", always: false };
     }
-    this.push("approval", decision === "allow" ? "allowed in the topic" : "denied (or no answer)");
-    return decision;
+    const by = answer.fromId === undefined ? "" : ` by user ${answer.fromId}`;
+    this.push("approval", answer.decision === "allow" ? `${answer.always ? "allowed (always)" : "allowed"} in the topic${by}` : `denied${by === "" ? " (or no answer)" : by}`);
+    return answer;
+  }
+  async reportRemembered(approvalId, remembered) {
+    if (approvalId === undefined)
+      return;
+    await this.client?.reportApprovalResult?.(approvalId, remembered);
   }
 }
-var TG_SOURCE = "tg", REMOTE_EVENT_LIMIT = 20, REMOTE_REPLY_MAX_CHARS = 16000, EVENT_PREVIEW_CHARS = 80, APPROVAL_INPUT_PREVIEW_CHARS = 1500;
+var TG_SOURCE = "tg", REMOTE_EVENT_LIMIT = 20, REMOTE_REPLY_MAX_CHARS = 16000, EVENT_PREVIEW_CHARS = 80;
 var init_shell_bridge = __esm(() => {
   init_service2();
   init_client3();
@@ -118023,7 +118981,7 @@ function formatAge(ms) {
     return `${minutes}m`;
   return `${Math.round(minutes / 60)}h`;
 }
-function formatRemoteStatusLines(status) {
+function formatRemoteStatusLines(status, posture) {
   const lines = [`Remote control: ${STATE_WORDS[status.state]}`];
   if (status.state === "off") {
     lines.push("Topic: none");
@@ -118034,7 +118992,14 @@ function formatRemoteStatusLines(status) {
   lines.push(`Last heartbeat: ${status.heartbeatAgeMs === undefined ? "none yet" : `${formatAge(status.heartbeatAgeMs)} ago`}`);
   if (status.state === "offline")
     lines.push("Serve is not reachable. The shell keeps retrying; nothing is lost from Telegram.");
+  if (status.unconfirmedApprovals !== undefined && status.unconfirmedApprovals > 0) {
+    const n = status.unconfirmedApprovals;
+    lines.push(`Approvals not confirmed: ${n}. The topic shows ${n === 1 ? "it" : "them"} as "not confirmed" until serve takes the shell's ack.`);
+  }
   lines.push(`Turn it off with ${REMOTE_CONTROL_COMMAND} off, or press o here. Rename: ${REMOTE_CONTROL_COMMAND} off, then ${REMOTE_CONTROL_COMMAND} <name>.`);
+  if (posture !== undefined && posture.length > 0) {
+    lines.push("", "Telegram permissions (change with /remote-policy):", ...posture.map((line) => `  ${line}`));
+  }
   return lines;
 }
 function clock2(at) {
@@ -118091,7 +119056,7 @@ function presentRemoteControl(open, otui, chrome, options) {
       return formatRemoteEventLines(status);
     if (tab === "commands")
       return formatRemoteCommandLines(status);
-    return formatRemoteStatusLines(status);
+    return formatRemoteStatusLines(status, options.getPostureLines?.());
   };
   const content = (tab) => {
     const lines = linesFor(tab);
@@ -118154,7 +119119,18 @@ function projectRemoteRow(status, width) {
     return { text: fit3("off", width), role: "muted", action: "open" };
   if (status.state === "offline")
     return { text: fit3("offline", width), role: "attention", action: "open" };
-  return { text: fit3(status.name ?? "connecting", width), role: "ok", action: "open" };
+  const topic = status.name ?? "connecting";
+  const unconfirmed = status.unconfirmedApprovals ?? 0;
+  if (unconfirmed > 0)
+    return { text: fit3(`${topic} \xB7 ${unconfirmed} unconfirmed`, width), role: "attention", action: "open" };
+  return { text: fit3(topic, width), role: "ok", action: "open" };
+}
+function projectPostureLine(status, posture, width) {
+  if (status === undefined || status.state === "off" || posture === undefined || posture.length === 0)
+    return;
+  return posture.split(`
+`).map((line) => fit3(line, width)).join(`
+`);
 }
 function mountRemotePanel(otui, renderer, parent, options) {
   const core = otui;
@@ -118169,6 +119145,8 @@ function mountRemotePanel(otui, renderer, parent, options) {
   const value = new core.TextRenderable(renderer, { id: "sb-remote-v", content: "" });
   box.add(label);
   box.add(value);
+  const posture = new core.TextRenderable(renderer, { id: "sb-remote-p", content: "" });
+  box.add(posture);
   const currentRow = () => projectRemoteRow(options.getStatus(), options.width);
   const draw = () => {
     if (disposed)
@@ -118176,6 +119154,9 @@ function mountRemotePanel(otui, renderer, parent, options) {
     const row = currentRow();
     label.content = core.t`${dimChunk(core, "Remote")}`;
     value.content = core.t`${roleChunk(core, row.role, row.text)}`;
+    const line = projectPostureLine(options.getStatus(), options.getPosture?.(), options.width);
+    posture.content = line === undefined ? "" : core.t`${dimChunk(core, line)}`;
+    posture.visible = line !== undefined;
   };
   const activate = () => {
     options.onOpen();
@@ -118187,6 +119168,9 @@ function mountRemotePanel(otui, renderer, parent, options) {
   value.onMouseDown = () => {
     activate();
   };
+  posture.onMouseDown = () => {
+    options.onOpenPermissions?.();
+  };
   const unsubscribeTheme = onThemeChange(guardedThemeRepaint("remote-panel", draw, () => disposed || isRenderableGone(box)));
   draw();
   return {
@@ -118450,6 +119434,11 @@ var init_agent_commands = __esm(() => {
       description: "How Telegram replies are written: /rendering [auto|rich|html|plain]",
       modes: AGENT_ONLY
     },
+    {
+      name: "/remote-policy",
+      description: "Telegram defaults: /remote-policy [mode ask|trust] [limit none|<minutes>] [wait <minutes>]. Never changes the shell's /mode",
+      modes: AGENT_ONLY
+    },
     {
       name: "/product",
       description: "Intents closed in code that nobody looked back at, with their outcome criteria",
@@ -118485,6 +119474,11 @@ var init_agent_commands = __esm(() => {
       description: "Pending remote approvals: summary, scope, consequence, expiry \u2014 allow or deny one call, once",
       modes: AGENT_ONLY
     },
+    {
+      name: "/permissions",
+      description: "The saved shell rules (what Always remembered): honoured or not, session grants; remove one",
+      modes: AGENT_ONLY
+    },
     {
       name: "/decisions",
       description: "Recommendation journal: how often you follow the agent's recommendation, by mode and stage, and the deviations; /decisions reason <why> and /decisions change <option> follow up on the last answer",
@@ -118695,10 +119689,14 @@ function classifyBusyDispatch(params) {
     return "remote-control";
   if (commandName === "/channels")
     return "channels";
+  if (commandName === "/remote-policy")
+    return "remote-policy";
   if (commandName === "/schedules")
     return "schedules";
   if (commandName === "/approvals")
     return "approvals";
+  if (commandName === "/permissions")
+    return "permissions";
   if (commandName === "/decisions")
     return "decisions";
   if (commandName === "/external-diff")
@@ -121375,7 +122373,7 @@ var init_serve_turn_store = __esm(() => {
 import { randomUUID as randomUUID34 } from "crypto";
 import { existsSync as existsSync45, readdirSync as readdirSync10 } from "fs";
 import path261 from "path";
-function isApprovalId(value) {
+function isApprovalId2(value) {
   return ID_PATTERN2.test(value);
 }
 function root(dir) {
@@ -121401,7 +122399,7 @@ function appendEvidence(event, dir) {
   appendOwnerOnlyLine(ledgerFile(dir), JSON.stringify(event));
 }
 function createApproval(input, dir, now = new Date) {
-  if (!isApprovalId(input.approvalId)) {
+  if (!isApprovalId2(input.approvalId)) {
     throw new Error("approvalId is not an approval id");
   }
   ensureKeryxSubdir(["approvals"], dir);
@@ -121468,7 +122466,7 @@ function parseResolution(text) {
   }
 }
 function readRaw(id, dir) {
-  if (!isApprovalId(id)) {
+  if (!isApprovalId2(id)) {
     return { ok: false, reason: "not-an-approval-id" };
   }
   const read = readConfigFile(requestFile(id, dir));
@@ -121572,7 +122570,7 @@ function approvalIds(dir) {
   if (!existsSync45(base)) {
     return [];
   }
-  return readdirSync10(base).filter((name) => name.endsWith(".json") && !name.endsWith(".resolution.json")).map((name) => name.slice(0, -".json".length)).filter(isApprovalId);
+  return readdirSync10(base).filter((name) => name.endsWith(".json") && !name.endsWith(".resolution.json")).map((name) => name.slice(0, -".json".length)).filter(isApprovalId2);
 }
 function listApprovals(dir, options = {}) {
   const views = [];
@@ -138527,6 +139525,10 @@ async function runSettingsCommand(command, handlers) {
       case "/theme":
         handlers.theme(arg);
         return;
+      case "/remote-policy":
+        if (handlers.remotePolicy !== undefined)
+          handlers.onSystem(handlers.remotePolicy(arg));
+        return;
     }
   } catch (error) {
     handlers.onSystem(`${name}: ${error instanceof Error ? error.message : String(error)}
@@ -139601,6 +140603,58 @@ var init_games = __esm(() => {
   init_tic_tac_toe();
 });
 
+// src/remote/telegram-permission.ts
+function modeInForce(input) {
+  if (input.changedThisSession)
+    return { mode: input.shellMode, source: "shell-mode" };
+  if (input.telegramTurn)
+    return { mode: input.telegramDefault, source: "telegram-default" };
+  return { mode: input.shellMode, source: "shell-default" };
+}
+function formatModeInForce(value) {
+  const source = value.source === "telegram-default" ? "Telegram default" : value.source === "shell-mode" ? "shell /mode" : "shell default";
+  return `${value.mode} (${source})`;
+}
+function telegramRememberOffer(ev) {
+  if (ev.destructive || ev.credentials || ev.sacReviewConfirmation || ev.publishLease || ev.hookAsk || ev.untrustedOrigin) {
+    return;
+  }
+  if (ev.command.length > APPROVAL_INPUT_PREVIEW_CHARS)
+    return;
+  const { exact, prefix, offerExact, offerPrefix } = suggestShellPatterns(ev.command);
+  const shownAsStored = (pattern) => redactSensitiveText(pattern) === pattern;
+  if (offerExact) {
+    return exact.length <= MAX_REMEMBER_PATTERN_CHARS && shownAsStored(exact) ? { pattern: exact, kind: "exact" } : undefined;
+  }
+  if (offerPrefix && prefix.length <= MAX_REMEMBER_PATTERN_CHARS && shownAsStored(prefix))
+    return { pattern: prefix, kind: "prefix" };
+  return;
+}
+function evaluateTelegramShellApproval(input) {
+  const evaluation = evaluateShellApproval(input);
+  return {
+    evaluation,
+    autoApprove: evaluation.autoApprove,
+    offer: evaluation.autoApprove ? undefined : telegramRememberOffer(evaluation)
+  };
+}
+function userSuffix(userId) {
+  return userId === undefined ? "" : `, user ${userId}`;
+}
+function modeAutoApprovalAudit(input) {
+  return `auto-approved (${input.mode}${userSuffix(input.userId)}): ${input.preview}`;
+}
+function savedRuleAutoApprovalAudit(input) {
+  const shown = input.command.length > 200 ? `${input.command.slice(0, 199)}\u2026` : input.command;
+  return `auto-approved by a saved rule${input.userId === undefined ? "" : ` (user ${input.userId})`}: ${shown}`;
+}
+var init_telegram_permission = __esm(() => {
+  init_shell_approval();
+  init_shell_permissions();
+  init_service2();
+  init_protocol2();
+});
+
 // src/mcp-client/elicitation.ts
 function extractCodexCommand(vendor) {
   const raw = vendor.codex_command;
@@ -141246,8 +142300,12 @@ async function forceForegroundQueueItem(owner, handoff, item, deps) {
     }
   });
 }
-function createForegroundAgentIoFacade(owner, token, io) {
+function createForegroundAgentIoFacade(owner, token, io, turn = {}) {
   const accepts = () => owner.accepts(token);
+  const approve = () => turn.requestApproval ?? io.requestApproval;
+  const autoApproved = () => turn.onAutoApproved ?? io.onAutoApproved;
+  const modeOf = () => turn.permissionMode ?? io.permissionMode;
+  const mcpGrantsApply = turn.mcpGrantsApply ?? io.mcpGrantsApply;
   return {
     write: (text) => {
       if (accepts())
@@ -141296,15 +142354,16 @@ function createForegroundAgentIoFacade(owner, token, io) {
     requestApproval: async (tool, input, meta) => {
       if (!accepts())
         return false;
-      const response = await io.requestApproval?.(tool, input, meta);
+      const response = await approve()?.(tool, input, meta);
       return accepts() ? response ?? false : false;
     },
     onAutoApproved: (tool, input, meta) => {
       if (accepts())
-        io.onAutoApproved?.(tool, input, meta);
+        autoApproved()?.(tool, input, meta);
     },
-    permissionMode: () => accepts() ? io.permissionMode?.() ?? "ask" : "ask",
+    permissionMode: () => accepts() ? modeOf()?.() ?? "ask" : "ask",
     ...io.trustedMcpTools === undefined ? {} : { trustedMcpTools: io.trustedMcpTools },
+    ...mcpGrantsApply === undefined ? {} : { mcpGrantsApply },
     ...io.mcpToolFingerprint === undefined ? {} : { mcpToolFingerprint: io.mcpToolFingerprint },
     ...io.mcpToolDestructive === undefined ? {} : { mcpToolDestructive: io.mcpToolDestructive },
     ...io.beforeMutation === undefined ? {} : {
@@ -141950,6 +143009,98 @@ function drainIdleMainQueue(items, options) {
   return true;
 }
 
+// src/tui/remote-queue-wiring.ts
+function createRemoteQueueWiring(deps) {
+  let pendingEdit;
+  return {
+    removeMainQueue(index) {
+      const queue = deps.getQueue();
+      if (index < 0 || index >= queue.length)
+        return;
+      const removed = queue[index];
+      if (removed?.source === TG_SOURCE) {
+        deps.getBridge()?.queuedLineRemoved(removed.question);
+      }
+      deps.setQueue(removeMainQueueItem(queue, index));
+      deps.paint();
+    },
+    editMainQueue(index) {
+      const edited = editMainQueueItem(deps.getQueue(), index);
+      if (edited === undefined)
+        return;
+      deps.setQueue(edited.rest);
+      pendingEdit = pendingQueueEditFor(edited.removed, index);
+      deps.composer.setText(edited.text);
+      deps.composer.focus();
+      deps.paint();
+    },
+    requeuePendingEdit(line, displayLine) {
+      if (pendingEdit === undefined)
+        return false;
+      const edit = pendingEdit;
+      pendingEdit = undefined;
+      deps.setQueue(reinsertEditedMainQueueItem(deps.getQueue(), edit, line, displayLine));
+      deps.paint();
+      return true;
+    },
+    hasPendingEdit: () => pendingEdit !== undefined,
+    stopRemoteForSessionSwitch() {
+      const bridge = deps.getBridge();
+      if (bridge?.keepingTopic === true) {
+        bridge.sessionLeaving();
+        return;
+      }
+      if (bridge?.active !== true)
+        return;
+      const closing = bridge.disable();
+      deps.say(`\u25C7 remote control is turning off: the session changed, and its Telegram topic is being deleted. Turn it on again with /remote-control <name>.
+`);
+      closing.then(() => deps.say(`\u25C7 remote control off: the topic is deleted.
+`));
+    },
+    dropQueuedTelegramLines() {
+      const { kept, dropped } = dropQueuedBySource(deps.getQueue(), TG_SOURCE);
+      if (dropped.length === 0)
+        return [];
+      deps.setQueue(kept);
+      deps.paint();
+      return dropped.map((item) => item.question);
+    },
+    enqueueTelegramLine(text) {
+      const queue = deps.getQueue();
+      queue.push({ id: deps.nextId(), question: text, displayQuestion: deps.summarize(text), source: TG_SOURCE });
+      deps.paint();
+      deps.say(`\u25C7 a line from Telegram is queued as q${queue.length}.
+`);
+    },
+    runTelegramLine(text) {
+      deps.runLine(text, "operator", TG_SOURCE);
+    },
+    runQueued(item) {
+      deps.runLine(item.question, "operator", item.source);
+    },
+    turnStarted(source) {
+      deps.getBridge()?.turnStarted(source);
+    },
+    assistantText(text) {
+      deps.getBridge()?.assistantText(text);
+    },
+    wrapOnToolCall(base) {
+      return (...args) => {
+        deps.getBridge()?.toolCall();
+        base?.(...args);
+      };
+    },
+    turnSettled(outcome) {
+      const bridge = deps.getBridge();
+      return bridge === undefined ? Promise.resolve() : bridge.turnSettled({ failed: outcome.failed || outcome.aborted });
+    }
+  };
+}
+var init_remote_queue_wiring = __esm(() => {
+  init_shell_bridge();
+});
+
 // src/tui/worker-fleet.ts
 function clip4(s, max) {
   if (s.length <= max) {
@@ -151120,7 +152271,7 @@ async function launchTuiAgentShell(opts) {
   });
   let uid = 0;
   const herdr = createHerdrReporter();
-  const sessionShellAllow = new Set(loadShellPermissions().allow);
+  const sessionShellAllow = new Set;
   let permissionMigrationShown = false;
   let permissionsFingerprintAtStart = shellPermissionsFingerprint();
   let permissionTamperShown = false;
@@ -151465,7 +152616,12 @@ async function launchTuiAgentShell(opts) {
     liveRemotePanel = mountRemotePanel(otui, r, sidebar, {
       width: SIDEBAR_TEXT_WIDTH,
       getStatus: remoteStatus,
-      onOpen: () => showRemoteControl()
+      onOpen: () => showRemoteControl(),
+      onOpenPermissions: () => showPermissions(),
+      getPosture: () => {
+        const posture = remoteBridge?.active === true ? telegramPosture() : undefined;
+        return posture === undefined ? undefined : postureSidebarText(posture);
+      }
     });
     liveChannelsPanel = mountChannelsPanel(otui, r, sidebar, {
       width: SIDEBAR_TEXT_WIDTH,
@@ -151763,17 +152919,31 @@ async function launchTuiAgentShell(opts) {
       guardCollector.onToolResult(name, toolResult);
       baseOnToolResultForGuard?.(name, toolResult);
     };
+    const remoteQueue = createRemoteQueueWiring({
+      getBridge: () => remoteBridge,
+      getQueue: () => mainQueue,
+      setQueue: (next) => {
+        mainQueue = next;
+      },
+      nextId: () => `mq${mainQueueSeq++}`,
+      summarize: summarizeSubmittedLine,
+      paint: () => paintMainQueue(),
+      composer: {
+        setText: (text) => {
+          input.value = text;
+        },
+        focus: () => input.focus()
+      },
+      say: (text) => io.onSystem?.(text),
+      runLine: (line, origin, source) => runLine(line, origin, source)
+    });
     const baseOnAssistantTextForGuard = io.onAssistantText?.bind(io);
     io.onAssistantText = (text) => {
       guardCollector.onAssistantText(text);
-      remoteBridge?.assistantText(text);
+      remoteQueue.assistantText(text);
       baseOnAssistantTextForGuard?.(text);
     };
-    const baseOnToolCallForRemote = io.onToolCall?.bind(io);
-    io.onToolCall = (name, toolInput) => {
-      remoteBridge?.toolCall();
-      baseOnToolCallForRemote?.(name, toolInput);
-    };
+    io.onToolCall = remoteQueue.wrapOnToolCall(io.onToolCall?.bind(io));
     const refreshGuardSidebar = () => {
       clearTranscriptChildren(sbGuard);
       if (!guardEnabled)
@@ -152266,24 +153436,60 @@ async function launchTuiAgentShell(opts) {
       setBusyPhase("running approved shell");
       return true;
     };
-    io.requestApproval = async (tool, inputJson, meta) => {
+    const requestApprovalForTelegramTurn = async (tool, inputJson, meta) => {
       const bridge = remoteBridge;
       if (bridge === undefined || !bridge.telegramTurnActive) {
         return requestApprovalLocally(tool, inputJson, meta);
       }
       const brief = tool.length > 60 ? `${tool.slice(0, 59)}\u2026` : tool;
+      const approvedAnswer = () => meta?.fingerprint !== undefined ? { approved: true, fingerprint: meta.fingerprint } : true;
+      let offer;
+      if (tool === "shell_exec") {
+        const judged = evaluateTelegramShellApproval({
+          inputJson,
+          ...meta !== undefined ? { meta } : {},
+          sessionAllow: sessionShellAllow,
+          fingerprintAtStart: permissionsFingerprintAtStart
+        });
+        if (!permissionTamperShown && judged.evaluation.tampered) {
+          permissionTamperShown = true;
+          io.onSystem?.(`\u26A0 the saved shell permissions changed outside this approval UI \u2014 review them before trusting an auto-approve
+`);
+        }
+        if (judged.autoApprove) {
+          const shown = judged.evaluation.command.length > 200 ? `${judged.evaluation.command.slice(0, 199)}\u2026` : judged.evaluation.command;
+          io.onSystem?.(`\u2713 auto-approved shell (saved rule): ${shown}
+`);
+          bridge.recordApproval(savedRuleAutoApprovalAudit({ userId: bridge.telegramTurnUserId, command: judged.evaluation.command }));
+          return approvedAnswer();
+        }
+        offer = judged.offer;
+      }
       io.onSystem?.(`\u25C7 approval for ${brief} sent to the Telegram topic; waiting for the answer there.
 `);
       setMainAgent("blocked", "approval (telegram)");
-      const decision = await bridge.requestApproval(describeApprovalForTopic(tool, inputJson, meta));
+      const answer = await bridge.askApproval(describeApprovalForTopic(tool, inputJson, meta), offer === undefined ? {} : { remember: offer.pattern });
+      const decision = answer.decision;
+      let rememberedNote = "";
+      if (decision === "allow" && answer.always && offer !== undefined) {
+        const stored = allowShellPattern(offer.pattern);
+        if (stored.length > 0) {
+          sessionShellAllow.add(stored);
+          permissionsFingerprintAtStart = shellPermissionsFingerprint();
+        }
+        rememberedNote = stored.length > 0 ? ` and remembered \u201C${stored}\u201D` : ` once; \u201C${offer.pattern}\u201D cannot be remembered`;
+        bridge.recordApproval(stored.length > 0 ? `saved a rule: ${stored}` : "a rule was asked for and refused by the store");
+        await bridge.reportRemembered(answer.approvalId, stored.length > 0);
+      }
       setMainAgent("running", decision === "allow" ? "approved (telegram)" : "denied");
-      io.onSystem?.(decision === "allow" ? `\u25C7 ${brief} approved in Telegram.
+      io.onSystem?.(decision === "allow" ? `\u25C7 ${brief} approved in Telegram${rememberedNote}.
 ` : `\u25C7 ${brief} denied (Telegram answer, timeout or no connection).
 `);
       if (decision !== "allow")
         return false;
-      return meta?.fingerprint !== undefined ? { approved: true, fingerprint: meta.fingerprint } : true;
+      return approvedAnswer();
     };
+    io.requestApproval = requestApprovalLocally;
     const askUserInteractive = async (req) => {
       chrome.hideMenu();
       setMainAgent("blocked", "ask");
@@ -152364,7 +153570,15 @@ async function launchTuiAgentShell(opts) {
     });
     const sessionCwd = opts.session?.cwd ?? process.cwd();
     let permissionMode = opts.initialPermissionMode ?? getProjectPermissionMode(sessionCwd) ?? DEFAULT_PERMISSION_MODE;
-    io.permissionMode = () => permissionMode;
+    let modeChangedThisSession = false;
+    const modeForTurn = (telegramTurn) => modeInForce({
+      shellMode: permissionMode,
+      changedThisSession: modeChangedThisSession,
+      telegramTurn,
+      telegramDefault: remoteBridge?.configuredPermissionMode ?? "ask"
+    });
+    const modeNow = () => modeForTurn(remoteBridge?.telegramTurnActive === true);
+    io.permissionMode = () => modeForTurn(false).mode;
     io.trustedMcpTools = new Map;
     io.mcpToolFingerprint = (fqn) => catalogFingerprintResolver(deps.mcpRuntime?.()?.catalog())(fqn);
     io.mcpToolDestructive = (fqn) => catalogDestructiveResolver(deps.mcpRuntime?.()?.catalog())(fqn);
@@ -152372,18 +153586,30 @@ async function launchTuiAgentShell(opts) {
     io.readOnly = () => readOnly;
     const paintModeRow = () => {
       const row = describeModeRow(permissionMode, readOnly);
+      const inForce = remoteBridge?.active === true ? formatModeInForce(modeNow()) : undefined;
       const hint = settingsSidebarHint(row.readOnly !== undefined);
-      sbModeV.content = row.readOnly !== undefined ? otui.t`${dimChunk(otui, `mode ${row.mode}`)} ${roleChunk(otui, "attention", row.readOnly)}` : otui.t`${dimChunk(otui, `mode ${row.mode}${hint === undefined ? "" : ` ${hint}`}`)}`;
+      sbModeV.content = row.readOnly !== undefined ? otui.t`${dimChunk(otui, `mode ${inForce ?? row.mode}`)} ${roleChunk(otui, "attention", row.readOnly)}` : otui.t`${dimChunk(otui, `mode ${inForce ?? row.mode}${hint === undefined || inForce !== undefined ? "" : ` ${hint}`}`)}`;
     };
     paintModeRow();
-    io.onAutoApproved = (tool, input, meta) => {
+    const autoApprovedFor = (telegramTurn) => (tool, input, meta) => {
       const preview = tool === "shell_exec" ? parseShellExecCommand(input) : isMcpToolCall(tool) ? `${tool} ${describeUseToolApproval(input, catalogResolver(deps.mcpRuntime?.()?.catalog())).fqn}` : tool;
-      const label = `\u25C7 auto-approved (${permissionMode})` + (meta.destructive ? " [destructive]" : "") + (meta.mcpTrusted === true ? ` ${TRUSTED_MARKER}` : "");
+      const inForce = modeForTurn(telegramTurn);
+      const label = `\u25C7 auto-approved (${inForce.mode})` + (meta.destructive ? " [destructive]" : "") + (meta.mcpTrusted === true ? ` ${TRUSTED_MARKER}` : "");
+      if (telegramTurn && remoteBridge !== undefined) {
+        remoteBridge.recordApproval(modeAutoApprovalAudit({ mode: inForce.mode, userId: remoteBridge.telegramTurnUserId, preview }));
+      }
       transcript.add(new otui.TextRenderable(r, {
         id: `ap${uid++}`,
         content: otui.t`${roleChunk(otui, "attention", label)} ${dimChunk(otui, preview)}`
       }));
     };
+    io.onAutoApproved = autoApprovedFor(false);
+    const telegramTurnIo = {
+      requestApproval: requestApprovalForTelegramTurn,
+      permissionMode: () => modeForTurn(true).mode,
+      onAutoApproved: autoApprovedFor(true),
+      mcpGrantsApply: () => false
+    };
     let liveSession;
     let history = [];
     let archive = [];
@@ -152419,19 +153645,7 @@ async function launchTuiAgentShell(opts) {
     deps = { ...deps, onContextCompaction };
     liveDeps = deps;
     let splash = undefined;
-    const stopRemoteForSessionSwitch = () => {
-      if (remoteBridge?.keepingTopic === true) {
-        remoteBridge.sessionLeaving();
-        return;
-      }
-      if (remoteBridge?.active !== true)
-        return;
-      const closing = remoteBridge.disable();
-      io.onSystem?.(`\u25C7 remote control is turning off: the session changed, and its Telegram topic is being deleted. Turn it on again with /remote-control <name>.
-`);
-      closing.then(() => io.onSystem?.(`\u25C7 remote control off: the topic is deleted.
-`));
-    };
+    const stopRemoteForSessionSwitch = () => remoteQueue.stopRemoteForSessionSwitch();
     const applyOpened = (opened, previewHistory) => {
       if (opened.history.length > 0) {
         splash?.removeIfShown();
@@ -152909,6 +154123,50 @@ Staying in the current session.
         io.onSystem?.("The product index could not be used. Run `keryx product index`.\n");
       });
     };
+    const permissionsChanged = () => {
+      permissionsFingerprintAtStart = shellPermissionsFingerprint();
+    };
+    const showPermissions = () => {
+      openPermissions(otui, chrome, {
+        sessionAllow: sessionShellAllow,
+        onChanged: permissionsChanged,
+        onKeypress: (handler) => onKeypress4(r, handler),
+        renderer: r,
+        inputBlocked: () => chrome.keyboardOwnedElsewhere()
+      });
+    };
+    const runPermissionsCommand = (line) => {
+      const rest = line.trim().slice(PERMISSIONS_COMMAND.length).trim();
+      if (rest.length === 0) {
+        showPermissions();
+        return;
+      }
+      io.onSystem?.(permissionsSlashText(rest, { sessionAllow: sessionShellAllow, onChanged: permissionsChanged }));
+    };
+    const runningTelegramPolicy = () => {
+      const bridge = remoteBridge;
+      if (bridge === undefined || !bridge.active)
+        return;
+      return {
+        defaultMode: bridge.configuredPermissionMode,
+        runTimeoutMs: bridge.runTimeoutMs,
+        approvalTimeoutMs: bridge.approvalTimeoutMs
+      };
+    };
+    const telegramModeInForce = () => remoteBridge?.active === true ? formatModeInForce(modeNow()) : undefined;
+    const remotePolicyDeps = () => ({
+      running: runningTelegramPolicy,
+      inForce: telegramModeInForce,
+      applyPolicy: (patch) => {
+        remoteBridge?.applyPolicy(patch);
+        paintModeRow();
+        liveRemotePanel?.refresh();
+      }
+    });
+    const telegramPosture = () => loadPosture({ running: runningTelegramPolicy, inForce: telegramModeInForce });
+    const runRemotePolicyCommand = (line) => {
+      io.onSystem?.(remotePolicyText(line.trim().slice(REMOTE_POLICY_COMMAND.length), remotePolicyDeps()));
+    };
     const showReviews = () => {
       openReviews(otui, chrome, { cwd: inspectorCwd(), renderer: r, ...inspectorKeys }).then(() => liveReviewsPanel?.refresh()).catch(() => {
         io.onSystem?.(`The managed reviews could not be read.
@@ -152939,6 +154197,10 @@ Staying in the current session.
     const showRemoteControl = () => {
       openRemoteControl(otui, chrome, {
         getStatus: remoteStatus,
+        getPostureLines: () => {
+          const posture = remoteBridge?.active === true ? telegramPosture() : undefined;
+          return posture === undefined ? undefined : postureLines(posture);
+        },
         onToggle: () => {
           remoteBridge?.active === true ? disableRemoteControl() : enableRemoteControl();
         },
@@ -153336,6 +154598,7 @@ Staying in the current session.
     };
     const commitPermissionMode = (next) => {
       permissionMode = next;
+      modeChangedThisSession = true;
       paintModeRow();
       chrome.showToast(`Permission mode: ${next}`);
     };
@@ -153506,7 +154769,12 @@ ${formatThemeList(getThemeId())}`);
       guard: guardEnabled,
       routing: routingEnabled,
       thinkDisplay: thinkDisplayMode,
-      reasoningOverride
+      reasoningOverride,
+      ...(() => {
+        const running = runningTelegramPolicy();
+        const inForce = telegramModeInForce();
+        return running === undefined ? {} : { telegram: { ...running, ...inForce !== undefined ? { inForce } : {} } };
+      })()
     }));
     const runSettingsAction = (command) => runSettingsCommand(command, {
       mode: runModeCommand,
@@ -153521,6 +154789,7 @@ ${formatThemeList(getThemeId())}`);
       reasoning: runReasoningCommand,
       think: runThinkCommand,
       theme: runThemeCommand,
+      remotePolicy: (arg) => remotePolicyText(arg, remotePolicyDeps()),
       onSystem: (text) => io.onSystem?.(text)
     });
     const showSettings = () => {
@@ -153567,7 +154836,6 @@ ${formatThemeList(getThemeId())}`);
     const sideQueue = [];
     let mainQueue = [];
     let mainQueueSeq = 0;
-    let pendingQueueEdit;
     const forceHandoff = createForegroundForceHandoff();
     let sideWorkerRunning = false;
     let sideClearTimeout;
@@ -153675,26 +154943,8 @@ ${formatThemeList(getThemeId())}`);
         fleet.remove("agent:queue");
       }
     };
-    const removeMainQueue = (index) => {
-      if (index < 0 || index >= mainQueue.length)
-        return;
-      const removedItem = mainQueue[index];
-      if (removedItem?.source === TG_SOURCE) {
-        remoteBridge?.queuedLineRemoved(removedItem.question);
-      }
-      mainQueue = removeMainQueueItem(mainQueue, index);
-      paintMainQueue();
-    };
-    const editMainQueue = (index) => {
-      const edited = editMainQueueItem(mainQueue, index);
-      if (edited === undefined)
-        return;
-      mainQueue = edited.rest;
-      pendingQueueEdit = pendingQueueEditFor(edited.removed, index);
-      input.value = edited.text;
-      input.focus();
-      paintMainQueue();
-    };
+    const removeMainQueue = (index) => remoteQueue.removeMainQueue(index);
+    const editMainQueue = (index) => remoteQueue.editMainQueue(index);
     const forceMainQueue = (index) => {
       const item = mainQueue[index];
       if (item === undefined)
@@ -153709,7 +154959,7 @@ ${formatThemeList(getThemeId())}`);
       forceForegroundQueueItem(foregroundOperation, forceHandoff, item, {
         announce: () => io.onSystem?.(`\u25C7 main turn interrupted \u2014 q${index + 1} will run next.
 `),
-        run: (next) => runLine(next.question, "operator", next.source)
+        run: (next) => remoteQueue.runQueued(next)
       });
     };
     const handleQueueNavKey = (key) => {
@@ -154082,6 +155332,14 @@ ${formatThemeList(getThemeId())}`);
             routeApprovalsCommand(line, true, approvals);
             return;
           }
+          case "permissions": {
+            runPermissionsCommand(line);
+            return;
+          }
+          case "remote-policy": {
+            runRemotePolicyCommand(line);
+            return;
+          }
           case "decisions": {
             routeDecisionsCommand(line, decisionsPanel);
             return;
@@ -154118,11 +155376,7 @@ ${formatThemeList(getThemeId())}`);
           case "not-a-command":
             break;
         }
-        if (pendingQueueEdit !== undefined) {
-          const edit = pendingQueueEdit;
-          pendingQueueEdit = undefined;
-          mainQueue = reinsertEditedMainQueueItem(mainQueue, edit, line, displayLine);
-          paintMainQueue();
+        if (remoteQueue.requeuePendingEdit(line, displayLine)) {
           return;
         }
         if (leaseView()?.held() === true) {
@@ -154163,7 +155417,7 @@ ${formatThemeList(getThemeId())}`);
               takeForced: () => forceHandoff.takeNext(),
               dispatch: (next) => {
                 paintMainQueue();
-                runLine(next.question, "operator", next.source);
+                remoteQueue.runQueued(next);
               }
             });
           } else {
@@ -154410,6 +155664,14 @@ ${formatThemeList(getThemeId())}`);
         if (routeApprovalsCommand(line, false, approvals)) {
           return;
         }
+        if (command.name === PERMISSIONS_COMMAND) {
+          runPermissionsCommand(line);
+          return;
+        }
+        if (command.name === REMOTE_POLICY_COMMAND) {
+          runRemotePolicyCommand(line);
+          return;
+        }
         if (routeDecisionsCommand(line, decisionsPanel)) {
           return;
         }
@@ -154939,7 +156201,7 @@ ${formatThemeList(getThemeId())}`);
                   const next = forceHandoff.takeNext() ?? mainQueue.shift();
                   paintMainQueue();
                   if (next !== undefined)
-                    runLine(next.question, "operator", next.source);
+                    remoteQueue.runQueued(next);
                 }
               }
             });
@@ -154951,7 +156213,8 @@ ${formatThemeList(getThemeId())}`);
       sessions.clear();
       deps.resetSubagentBudget?.();
       const operation = foregroundOperation.begin();
-      remoteBridge?.turnStarted(source);
+      remoteQueue.turnStarted(source);
+      const telegramTurn = source === TG_SOURCE && remoteBridge?.telegramTurnActive === true;
       blockIo.resetReasoningLiveState();
       setMainAgent("running", "waiting");
       startBusy("waiting for model");
@@ -155038,7 +156301,7 @@ ${formatThemeList(getThemeId())}`);
         guardCollector.reset(line);
         syncArchive();
         rewindRecorder.beginTurn({ archiveIndex: archive.length, prompt: line });
-        const foregroundIo = createForegroundAgentIoFacade(foregroundOperation, operation, io);
+        const foregroundIo = createForegroundAgentIoFacade(foregroundOperation, operation, io, telegramTurn ? telegramTurnIo : {});
         const turnSignal = foregroundOperation.signal;
         runAgentTurn(foregroundIo, deps, history, line, {
           signal: turnSignal,
@@ -155046,7 +156309,7 @@ ${formatThemeList(getThemeId())}`);
           ...slateSession !== undefined ? { slateSession, pruneArchive: true } : {}
         }).finally(() => {
           foregroundOperation.settle(operation);
-          remoteBridge?.turnSettled({ failed: turnFailed || turnSignal.aborted });
+          remoteQueue.turnSettled({ failed: turnFailed, aborted: turnSignal.aborted });
           if (foregroundOperation.isDisposed)
             return;
           refreshRewindSidebar();
@@ -155099,7 +156362,7 @@ ${formatThemeList(getThemeId())}`);
             const next = forceHandoff.takeNext() ?? mainQueue.shift();
             paintMainQueue();
             if (next !== undefined) {
-              runLine(next.question, "operator", next.source);
+              remoteQueue.runQueued(next);
             } else {
               busWakeController?.onSettle();
             }
@@ -155143,7 +156406,7 @@ ${formatThemeList(getThemeId())}`);
         const drained = forceHandoff.takeNext() ?? mainQueue.shift();
         paintMainQueue();
         if (drained !== undefined)
-          runLine(drained.question, "operator", drained.source);
+          remoteQueue.runQueued(drained);
       }
     });
     const captureShellOutput = async (run) => {
@@ -155226,7 +156489,7 @@ ${formatThemeList(getThemeId())}`);
       });
       return `${formatSessionInfoText(snapshot).trimEnd()}
 
-Mode: ${permissionMode}${readOnly ? " (read-only on)" : ""}
+Mode: ${formatModeInForce(modeForTurn(true))}${readOnly ? " (read-only on)" : ""}
 Turn: ${chrome.isBusy() ? "running" : "idle"} \xB7 queue: ${mainQueue.length} waiting`;
     };
     const runRemoteCommand = async (line) => {
@@ -155239,12 +156502,13 @@ Turn: ${chrome.isBusy() ? "running" : "idle"} \xB7 queue: ${mainQueue.length} wa
 `);
         });
       }
-      if (name === "/mode" && (first === "" || first === "auto")) {
+      const modeWords = line.trim().split(/\s+/).slice(1).filter((word) => word.length > 0);
+      if (name === "/mode" && (first === "" || (first === "ask" || first === "trust" || first === "auto") && modeWords.length === 1)) {
         echoRemoteCommand(line);
         return await captureShellOutput(() => {
-          if (first === "auto")
-            commitPermissionMode("auto");
-          io.onSystem?.(`Permission mode: ${permissionMode} (ask, trust or auto)
+          if (first === "ask" || first === "trust" || first === "auto")
+            commitPermissionMode(first);
+          io.onSystem?.(`Permission mode: ${formatModeInForce(modeForTurn(true))} (ask, trust or auto)
 `);
         });
       }
@@ -155255,14 +156519,8 @@ Turn: ${chrome.isBusy() ? "running" : "idle"} \xB7 queue: ${mainQueue.length} wa
         sessionId: () => liveSession.summary.id,
         project: () => sessionCwd,
         isBusy: () => chrome.isBusy() || foregroundOperation.isActive || forceHandoff.isAwaitingSettlement || mainQueue.length > 0 || leaseView()?.held() === true,
-        runLine: (text) => runLine(text, "operator", TG_SOURCE),
-        enqueue: (text) => {
-          const id = `mq${mainQueueSeq++}`;
-          mainQueue.push({ id, question: text, displayQuestion: summarizeSubmittedLine(text), source: TG_SOURCE });
-          paintMainQueue();
-          io.onSystem?.(`\u25C7 a line from Telegram is queued as q${mainQueue.length}.
-`);
-        },
+        runLine: (text) => remoteQueue.runTelegramLine(text),
+        enqueue: (text) => remoteQueue.enqueueTelegramLine(text),
         notice: (text) => io.onSystem?.(`${text}
 `),
         cancelTurn: () => foregroundOperation.cancel("remote run time limit"),
@@ -155280,14 +156538,7 @@ Turn: ${chrome.isBusy() ? "running" : "idle"} \xB7 queue: ${mainQueue.length} wa
             liveSession = recordRemoteOff(liveSession);
           } catch {}
         },
-        dropQueuedTelegramLines: () => {
-          const { kept, dropped } = dropQueuedBySource(mainQueue, TG_SOURCE);
-          if (dropped.length === 0)
-            return [];
-          mainQueue = kept;
-          paintMainQueue();
-          return dropped.map((item) => item.question);
-        },
+        dropQueuedTelegramLines: () => remoteQueue.dropQueuedTelegramLines(),
         runCommand: runRemoteCommand,
         busyRefusal: (line) => {
           const command = findAgentCommand(line, "agent");
@@ -155360,7 +156611,10 @@ Turn: ${chrome.isBusy() ? "running" : "idle"} \xB7 queue: ${mainQueue.length} wa
           pendingResumeTarget = undefined;
           return liveSession.summary.id === found.id ? { ...outcome, ok: true } : { ...outcome, ok: false };
         },
-        onChange: () => liveRemotePanel?.refresh()
+        onChange: () => {
+          liveRemotePanel?.refresh();
+          paintModeRow();
+        }
       }
     });
     onKeypress4(r, (key) => {
@@ -155412,6 +156666,9 @@ var init_tui_shell = __esm(() => {
   init_flow_inspector();
   init_product_open_surface();
   init_reviews_inspector();
+  init_permissions_command();
+  init_remote_policy_command();
+  init_permissions_inspector();
   init_shell_bridge();
   init_command_gateway();
   init_channels_client();
@@ -155501,6 +156758,7 @@ var init_tui_shell = __esm(() => {
   init_provider_config();
   init_shell_permissions();
   init_shell_approval();
+  init_telegram_permission();
   init_elicitation();
   init_permission_mode_config();
   init_permission_mode();
@@ -155514,6 +156772,7 @@ var init_tui_shell = __esm(() => {
   init_composer_choice();
   init_filter_list();
   init_shell_chrome();
+  init_remote_queue_wiring();
   init_queue_nav();
   init_subagent_inspector();
   init_subagent_session();
@@ -157340,7 +158599,7 @@ async function runAgentRepl(lines, rich, deps, metaprojectPort, sessionOpts, ini
     }
   };
   const searchProviderController = createDefaultSearchProviderController();
-  const sessionShellAllow = new Set(loadShellPermissions(configDir).allow);
+  const sessionShellAllow = new Set;
   let fingerprintAtStart = shellPermissionsFingerprint(configDir);
   let permissionMigrationShown = false;
   let permissionTamperShown = false;
@@ -158032,6 +159291,8 @@ ${GUTTER}${turnSeparator()}
           agentIo.onSystem?.(readlineChannelsText(line, await loadChannelsSnapshot(new ChannelsClient)));
         } else if (isRenderingCommand(command)) {
           agentIo.onSystem?.(runRenderingCommand(rest));
+        } else if (command === "/remote-policy") {
+          agentIo.onSystem?.(remotePolicyText(rest, { ...configDir !== undefined ? { dir: configDir } : {} }));
         } else if (isSessionInfoCommand(command)) {
           const cwd = sessionCwd;
           const [workspaces, flows] = await Promise.all([
@@ -158055,6 +159316,13 @@ ${GUTTER}${turnSeparator()}
           })));
         } else if (command === "/approvals") {
           agentIo.onSystem?.(approvalsSlashText(rest));
+        } else if (command === "/permissions") {
+          agentIo.onSystem?.(permissionsSlashText(rest, {
+            sessionAllow: sessionShellAllow,
+            onChanged: () => {
+              fingerprintAtStart = shellPermissionsFingerprint(configDir);
+            }
+          }));
         } else if (command === "/external-diff") {
           agentIo.onSystem?.(externalDiffSlashText(defaultExternalDiffDeps(sessionCwd)));
         } else if (isFlowsCommand(command)) {
@@ -159163,6 +160431,8 @@ var init_shell = __esm(() => {
   init_flow_inspector();
   init_inspector_sources();
   init_approvals();
+  init_permissions_command();
+  init_remote_policy_command();
   init_external_diff_modal();
   init_doctor2();
   init_setup_guide();
@@ -159229,6 +160499,7 @@ var init_shell = __esm(() => {
     "/status",
     "/flows",
     "/approvals",
+    "/permissions",
     "/external-diff",
     "/doctor",
     "/setup",
@@ -159236,6 +160507,7 @@ var init_shell = __esm(() => {
     "/remote-control",
     "/channels",
     "/rendering",
+    "/remote-policy",
     "/theme",
     "/settings",
     "/mode",
@@ -192911,7 +194183,7 @@ function listApprovalsRoute(request, ctx) {
   });
 }
 async function answerApprovalRoute(request, approvalId, ctx) {
-  if (!isApprovalId(approvalId)) {
+  if (!isApprovalId2(approvalId)) {
     return approvalNotFound();
   }
   const declared = Number(request.headers.get("content-length") ?? "0");
@@ -193175,9 +194447,11 @@ var init_serve_server = __esm(() => {
     ["heartbeat", "POST"],
     ["reply", "POST"],
     ["approval", "POST"],
+    ["approval-result", "POST"],
     ["prompt", "POST"],
     ["state", "POST"],
     ["ack", "POST"],
+    ["approval-ack", "POST"],
     ["stream", "GET"],
     ["channels-status", "GET"],
     ["channels-pair", "POST"],
@@ -195889,7 +197163,12 @@ class RemoteHub {
     }));
   }
   limits() {
-    return { runTimeoutMs: this.config.runTimeoutMs, orphanMs: this.config.orphanMs };
+    return {
+      runTimeoutMs: this.config.runTimeoutMs,
+      orphanMs: this.config.orphanMs,
+      permissionMode: this.config.permissionMode,
+      approvalTimeoutMs: this.config.approvalTimeoutMs
+    };
   }
   hasSession(sessionId) {
     return this.registry.bySession(sessionId) !== undefined;
@@ -196665,6 +197944,7 @@ class RemoteHttpSurface {
   timers;
   keepaliveMs;
   ackTimeoutMs;
+  approvalAckMs;
   newApprovalId;
   newPromptId;
   streams = new Map;
@@ -196673,6 +197953,8 @@ class RemoteHttpSurface {
   bound = new Map;
   pendingAcks = new Map;
   approvals = new Map;
+  awaiting = new Map;
+  decided = new Map;
   choices = new Map;
   finished = new Map;
   constructor(options) {
@@ -196681,6 +197963,7 @@ class RemoteHttpSurface {
     this.timers = options.timers ?? realTimers;
     this.keepaliveMs = options.keepaliveMs ?? DEFAULT_KEEPALIVE_MS;
     this.ackTimeoutMs = options.ackTimeoutMs ?? DEFAULT_ACK_TIMEOUT_MS;
+    this.approvalAckMs = options.approvalAckMs ?? DEFAULT_APPROVAL_ACK_MS;
     this.newApprovalId = options.approvalIds ?? (() => `ap${randomBytes15(6).toString("hex")}`);
     this.newPromptId = options.promptIds ?? (() => `pk${randomBytes15(6).toString("hex")}`);
     this.consumer = {
@@ -196741,12 +198024,16 @@ class RemoteHttpSurface {
         return this.reply(hub, request);
       case "approval":
         return this.requestApproval(hub, request);
+      case "approval-result":
+        return this.approvalResult(hub, request);
       case "prompt":
         return this.requestPrompt(hub, request);
       case "state":
         return this.messageState(hub, request);
       case "ack":
         return this.ack(hub, request);
+      case "approval-ack":
+        return this.approvalAck(hub, request);
       case "stream":
         return this.openStream(hub, request, io);
     }
@@ -196765,6 +198052,9 @@ class RemoteHttpSurface {
     for (const id of [...this.approvals.keys()]) {
       this.dropApproval(id);
     }
+    for (const id of [...this.awaiting.keys()]) {
+      this.dropAwaiting(id);
+    }
     for (const id of [...this.choices.keys()]) {
       this.dropChoice(id);
     }
@@ -196799,7 +198089,15 @@ class RemoteHttpSurface {
         this.sent.delete(checked.sessionId);
         this.bound.set(checked.sessionId, binding);
       }
-      return ok2({ name: result.name, threadId: result.threadId, reused: result.reused, runTimeoutMs: hub.limits().runTimeoutMs });
+      const limits = hub.limits();
+      return ok2({
+        name: result.name,
+        threadId: result.threadId,
+        reused: result.reused,
+        runTimeoutMs: limits.runTimeoutMs,
+        permissionMode: limits.permissionMode,
+        approvalTimeoutMs: limits.approvalTimeoutMs
+      });
     }
     const status = result.code === "name-taken" ? 409 : result.code === "invalid-name" ? 400 : 502;
     return fail4(status, result.code, result.message);
@@ -196926,6 +198224,13 @@ class RemoteHttpSurface {
     if (typeof timeoutMs !== "number" || !Number.isSafeInteger(timeoutMs) || timeoutMs < MIN_APPROVAL_TIMEOUT_MS || timeoutMs > MAX_APPROVAL_TIMEOUT_MS) {
       return invalid2(`timeoutMs must be an integer from ${MIN_APPROVAL_TIMEOUT_MS} to ${MAX_APPROVAL_TIMEOUT_MS}.`);
     }
+    let remember;
+    if (value.remember !== undefined) {
+      if (typeof value.remember !== "string" || value.remember.length === 0 || value.remember.length > MAX_REMEMBER_PATTERN_CHARS || CONTROL_CHARS2.test(value.remember)) {
+        return invalid2(`remember must be a string of 1 to ${MAX_REMEMBER_PATTERN_CHARS} characters without control characters.`);
+      }
+      remember = redactSensitiveText(value.remember);
+    }
     const sessionId = value.sessionId;
     if (!hub.hasSession(sessionId)) {
       return fail4(404, "unknown-session", "This session is not registered for remote control; register again.");
@@ -196947,15 +198252,20 @@ class RemoteHttpSurface {
     this.approvals.set(approvalId, {
       sessionId,
       expiresAt,
-      timer: this.timers.setTimeout(() => this.expireApproval(approvalId), timeoutMs)
+      timer: this.timers.setTimeout(() => this.expireApproval(approvalId), timeoutMs),
+      ...remember === undefined ? {} : { remember }
     });
+    const offer = remember === undefined ? "" : `
+Always would remember:
+${asCodeBlock(remember)}`;
     const sent = await hub.send(sessionId, `Approval needed:
-${asCodeBlock(redactSensitiveText(value.prompt))}`, {
+${asCodeBlock(redactSensitiveText(value.prompt))}${offer}`, {
       keyboard: [
         [
           { text: "Allow", callback_data: approvalCallbackData(approvalId, "allow") },
           { text: "Deny", callback_data: approvalCallbackData(approvalId, "deny") }
-        ]
+        ],
+        ...remember === undefined ? [] : [[{ text: alwaysButtonText(remember), callback_data: approvalCallbackData(approvalId, "always") }]]
       ],
       onSent: (info) => this.onApprovalSent(approvalId, sessionId, info.messageId, info.text)
     });
@@ -196965,6 +198275,45 @@ ${asCodeBlock(redactSensitiveText(value.prompt))}`, {
     }
     return ok2({ approvalId, expiresAt });
   }
+  async approvalResult(hub, request) {
+    const body = await readJsonBody(request);
+    if (!body.ok) {
+      return body.response;
+    }
+    const value = body.value;
+    if (!isSessionId(value.sessionId)) {
+      return invalid2("sessionId must be 1 to 64 characters of letters, digits, '-' and '_'.");
+    }
+    if (!isApprovalId(value.approvalId) || typeof value.remembered !== "boolean") {
+      return invalid2("approvalId must be an approval id and remembered a boolean.");
+    }
+    const waiting = this.awaiting.get(value.approvalId);
+    if (waiting !== undefined && waiting.sessionId === value.sessionId && waiting.remember !== undefined) {
+      waiting.reported ??= value.remembered;
+      return ok2({ settled: true });
+    }
+    const done = this.finished.get(value.approvalId);
+    if (done === undefined || done.sessionId !== value.sessionId || done.rememberOf === undefined) {
+      return fail4(404, "unknown-approval", "No approval of this session is waiting for that report.");
+    }
+    this.settleRemembered(hub, value.sessionId, done, value.remembered);
+    return ok2({ settled: true });
+  }
+  settleRemembered(hub, sessionId, done, remembered) {
+    const info = done.rememberOf;
+    if (info === undefined) {
+      return;
+    }
+    done.rememberOf = undefined;
+    const result = remembered ? `Allowed by ${info.who} at ${info.when}. Remembered: ${info.pattern}` : `Allowed by ${info.who} at ${info.when}. Not remembered: ${info.pattern} (approved this once).`;
+    done.shortReply = remembered ? "Approval granted and remembered." : "Approval granted once; the rule was not remembered.";
+    done.finalText = done.messageId === undefined ? result : settledText(info.original, result);
+    if (done.messageId !== undefined) {
+      hub.settleMessage(sessionId, done.messageId, done.finalText, done.shortReply).catch(() => {
+        return;
+      });
+    }
+  }
   async requestPrompt(hub, request) {
     const body = await readJsonBody(request);
     if (!body.ok) {
@@ -197088,6 +198437,62 @@ ${asCodeBlock(redactSensitiveText(value.prompt))}`, {
     this.complete(value.sessionId, value.updateId);
     return ok2({ acknowledged: true });
   }
+  async approvalAck(hub, request) {
+    const body = await readJsonBody(request);
+    if (!body.ok) {
+      return body.response;
+    }
+    const value = body.value;
+    if (!isSessionId(value.sessionId)) {
+      return invalid2("sessionId must be 1 to 64 characters of letters, digits, '-' and '_'.");
+    }
+    if (!isApprovalId(value.approvalId)) {
+      return invalid2("approvalId must be 'ap' and 12 lowercase hex characters.");
+    }
+    if (!hub.hasSession(value.sessionId)) {
+      return fail4(404, "unknown-session", "This session is not registered for remote control; register again.");
+    }
+    if (value.applied !== undefined && typeof value.applied !== "boolean") {
+      return invalid2("applied must be true or false when present.");
+    }
+    const sessionId = value.sessionId;
+    const id = value.approvalId;
+    const waiting = this.awaiting.get(id);
+    if (waiting !== undefined && waiting.sessionId === sessionId) {
+      this.dropAwaiting(id);
+      this.rememberDecided(id, sessionId);
+      if (value.applied === false) {
+        this.finishApproval(id, sessionId, waiting.messageId, waiting.text, {
+          result: `Not applied at ${waiting.sentAt}: the shell was no longer waiting for this question, so the ${waiting.decision === "deny" ? "Deny" : "Allow"} from ${waiting.who} changed nothing.`,
+          shortReply: "Not applied: the shell was no longer waiting for this question."
+        });
+        return ok2({ acknowledged: true });
+      }
+      if (waiting.decision === "always" && waiting.remember !== undefined) {
+        this.finishApproval(id, sessionId, waiting.messageId, waiting.text, {
+          result: `Allowed by ${waiting.who} at ${waiting.sentAt}. Saving the rule: ${waiting.remember}`,
+          shortReply: "Approval granted; saving the rule."
+        });
+        const done = this.finished.get(id);
+        if (done !== undefined) {
+          done.rememberOf = { original: waiting.text, who: waiting.who, when: waiting.sentAt, pattern: waiting.remember };
+          if (waiting.reported !== undefined) {
+            this.settleRemembered(hub, sessionId, done, waiting.reported);
+          }
+        }
+        return ok2({ acknowledged: true });
+      }
+      this.finishApproval(id, sessionId, waiting.messageId, waiting.text, {
+        result: waiting.decision === "allow" ? `Allowed by ${waiting.who} at ${waiting.sentAt}.` : `Denied by ${waiting.who} at ${waiting.sentAt}.`,
+        shortReply: waiting.decision === "allow" ? "Approval granted." : "Approval denied."
+      });
+      return ok2({ acknowledged: true });
+    }
+    if (this.decided.get(id) === sessionId) {
+      return ok2({ acknowledged: true });
+    }
+    return fail4(404, "unknown-approval", "No approval with that id was sent to this session.");
+  }
   openStream(hub, request, io) {
     const sessionId = new URL(request.url).searchParams.get("sessionId");
     if (!isSessionId(sessionId)) {
@@ -197232,8 +198637,11 @@ ${asCodeBlock(redactSensitiveText(value.prompt))}`, {
       return;
     }
     if (entry !== undefined && entry.expiresAt > this.now()) {
+      if (approval.decision === "always" && entry.remember === undefined) {
+        return;
+      }
       this.dropApproval(id);
-      const event = { updateId: callback.updateId, approvalId: id, decision: approval.decision };
+      const event = { updateId: callback.updateId, approvalId: id, decision: approval.decision, fromId: callback.fromId };
       const told = stream?.write(encodeSseEvent("approval", event, callback.updateId)) === true;
       const messageId = entry.messageId ?? callback.messageId;
       const when = clockText(this.now());
@@ -197244,10 +198652,15 @@ ${asCodeBlock(redactSensitiveText(value.prompt))}`, {
         });
         return;
       }
-      const who = `user ${callback.fromId}`;
-      this.finishApproval(id, sessionId, messageId, entry.text, {
-        result: approval.decision === "allow" ? `Allowed by ${who} at ${when}.` : `Denied by ${who} at ${when}.`,
-        shortReply: approval.decision === "allow" ? "Approval granted." : "Approval denied."
+      this.awaiting.set(id, {
+        sessionId,
+        decision: approval.decision,
+        who: `user ${callback.fromId}`,
+        sentAt: when,
+        ...messageId === undefined ? {} : { messageId },
+        ...entry.text === undefined ? {} : { text: entry.text },
+        ...approval.decision === "always" && entry.remember !== undefined ? { remember: entry.remember } : {},
+        timer: this.timers.setTimeout(() => this.giveUpOnAck(id), this.approvalAckMs)
       });
       return;
     }
@@ -197255,6 +198668,9 @@ ${asCodeBlock(redactSensitiveText(value.prompt))}`, {
       this.expireApproval(id);
       return;
     }
+    if (this.awaiting.has(id)) {
+      return;
+    }
     const done = this.finished.get(id);
     if (done !== undefined) {
       if (done.sessionId === sessionId) {
@@ -197275,7 +198691,7 @@ ${asCodeBlock(redactSensitiveText(value.prompt))}`, {
     }
   }
   carriesLivePrompt(messageId) {
-    return [...this.approvals.values(), ...this.choices.values()].some((live) => live.messageId === messageId);
+    return [...this.approvals.values(), ...this.awaiting.values(), ...this.choices.values()].some((live) => live.messageId === messageId);
   }
   pressChoice(sessionId, callback, choice, stream) {
     const id = choice.promptId;
@@ -197358,7 +198774,7 @@ ${asCodeBlock(redactSensitiveText(value.prompt))}`, {
     });
   }
   onApprovalSent(approvalId, sessionId, messageId, text) {
-    const live = this.approvals.get(approvalId);
+    const live = this.approvals.get(approvalId) ?? this.awaiting.get(approvalId);
     if (live !== undefined) {
       live.messageId = messageId;
       live.text = text;
@@ -197411,6 +198827,37 @@ ${asCodeBlock(redactSensitiveText(value.prompt))}`, {
     this.timers.clearTimeout(entry.timer);
     this.approvals.delete(approvalId);
   }
+  dropAwaiting(approvalId) {
+    const entry = this.awaiting.get(approvalId);
+    if (entry === undefined) {
+      return;
+    }
+    this.timers.clearTimeout(entry.timer);
+    this.awaiting.delete(approvalId);
+  }
+  rememberDecided(approvalId, sessionId) {
+    this.decided.delete(approvalId);
+    this.decided.set(approvalId, sessionId);
+    while (this.decided.size > MAX_DECIDED_APPROVALS) {
+      const oldest = this.decided.keys().next().value;
+      if (oldest === undefined) {
+        break;
+      }
+      this.decided.delete(oldest);
+    }
+  }
+  giveUpOnAck(approvalId) {
+    const entry = this.awaiting.get(approvalId);
+    if (entry === undefined) {
+      return;
+    }
+    this.dropAwaiting(approvalId);
+    this.rememberDecided(approvalId, entry.sessionId);
+    this.finishApproval(approvalId, entry.sessionId, entry.messageId, entry.text, {
+      result: `Sent to the shell at ${entry.sentAt}, not confirmed; the shell denies by itself if it did not receive it.`,
+      shortReply: "Sent to the shell, not confirmed; it denies by itself if it did not receive it."
+    });
+  }
   expireApproval(approvalId) {
     const entry = this.approvals.get(approvalId);
     if (entry === undefined) {
@@ -197447,6 +198894,11 @@ ${asCodeBlock(redactSensitiveText(value.prompt))}`, {
         }
       }
     }
+    for (const [id, entry] of [...this.awaiting.entries()]) {
+      if (entry.sessionId === stream.sessionId && !this.closed) {
+        this.giveUpOnAck(id);
+      }
+    }
     for (const [id, entry] of [...this.choices.entries()]) {
       if (entry.sessionId === stream.sessionId) {
         this.dropChoice(id);
@@ -197463,6 +198915,10 @@ ${asCodeBlock(redactSensitiveText(value.prompt))}`, {
     }
   }
 }
+function alwaysButtonText(pattern) {
+  const text = `Always: ${pattern.replace(/\s+/g, " ")}`;
+  return text.length <= MAX_BUTTON_TEXT_CHARS ? text : `${text.slice(0, MAX_BUTTON_TEXT_CHARS - 1)}\u2026`;
+}
 function asCodeBlock(text) {
   const safe = (text.trim().length === 0 ? "(empty)" : text).replace(/\r\n?/g, `
 `).replace(/`{9,}/g, (run) => run.match(/`{1,8}/g).join("\u200B"));
@@ -197472,7 +198928,7 @@ function asCodeBlock(text) {
 ${safe}
 ${fence}`;
 }
-var MAX_REPLY_CHARS = 20000, MAX_PENDING_APPROVALS_PER_SESSION = 8, MAX_PENDING_CHOICES_PER_SESSION = 8, MAX_REMEMBERED_IDS_PER_SESSION = 512, MAX_PROJECT_NAME_CHARS = 128, CONTROL_CHARS2, JSON_HEADERS2, MAX_FINISHED_PROMPTS = 128, MAX_SETTLED_TEXT_CHARS = 3600, MAX_BACKTICK_RUN = 8;
+var MAX_REPLY_CHARS = 20000, MAX_PENDING_APPROVALS_PER_SESSION = 8, MAX_PENDING_CHOICES_PER_SESSION = 8, MAX_REMEMBERED_IDS_PER_SESSION = 512, MAX_PROJECT_NAME_CHARS = 128, CONTROL_CHARS2, JSON_HEADERS2, MAX_FINISHED_PROMPTS = 128, MAX_DECIDED_APPROVALS = 256, MAX_SETTLED_TEXT_CHARS = 3600, MAX_BACKTICK_RUN = 8;
 var init_http_surface = __esm(() => {
   init_service2();
   init_hub();
@@ -198612,11 +200068,24 @@ function runStatus7(args) {
   };
   const credentialState = credential.status === "ok" ? "present" : credential.status;
   const fingerprint = credential.status === "ok" ? credentialFingerprint(credential.record) : undefined;
+  const telegram = loadPosture();
+  const remoteConfig = telegram === undefined ? undefined : loadRemoteConfig();
+  const allowedUsers = remoteConfig?.ok === true ? remoteConfig.value.allowedUserIds.length : undefined;
   if (asJson) {
     console.log(JSON.stringify({
       ...report,
       credential: credentialState,
       ...fingerprint === undefined ? {} : { credentialFingerprint: fingerprint },
+      ...telegram === undefined ? {} : {
+        telegramPermissions: {
+          defaultMode: telegram.defaultMode,
+          runTimeoutMs: telegram.runTimeoutMs,
+          approvalTimeoutMs: telegram.approvalTimeoutMs,
+          savedRules: telegram.savedRules,
+          ...allowedUsers !== undefined ? { allowedUsers } : {},
+          shellModeOverridesDefault: true
+        }
+      },
       warnings: [...warnings].sort()
     }, null, 2));
     return;
@@ -198634,6 +200103,10 @@ function runStatus7(args) {
   }
   console.log(`  credential: ${credentialState}${fingerprint === undefined ? "" : ` (fingerprint ${fingerprint})`}`);
   console.log(`  pending approvals: ${report.pendingApprovals}`);
+  if (telegram !== undefined) {
+    console.log(`  telegram:   default mode ${telegram.defaultMode}, run limit ${formatPolicyDuration(telegram.runTimeoutMs)}, approval wait ${formatPolicyDuration(telegram.approvalTimeoutMs)}, ${telegram.savedRules} saved shell rule${telegram.savedRules === 1 ? "" : "s"}${allowedUsers !== undefined ? `, ${allowedUsers} allowed user${allowedUsers === 1 ? "" : "s"}` : ""}`);
+    console.log("              a running shell's /mode overrides the default mode; /remote-policy changes the defaults");
+  }
   if (report.message !== undefined) {
     console.log("");
     console.log(`  ${style.yellow(symbols.bullet)} ${sanitizeForDisplay(report.message)}`);
@@ -198891,6 +200364,8 @@ function printHelp23() {
 }
 var BIND_FLAGS, ACK_FLAG = "--acknowledge-non-loopback", FORCE_FLAG = "--force", NO_ACK_FLAG = "--no-acknowledge-non-loopback", ENABLE_FLAG = "--enable", DISABLE_FLAG = "--disable";
 var init_serve = __esm(() => {
+  init_config11();
+  init_remote_policy_command();
   init_project_registry();
   init_serve_config();
   init_serve_credential();
@@ -210604,6 +212079,7 @@ var init_group_subcommands = __esm(() => {
     ["external", ["on", "off", "status", "list"]],
     ["auth", ["list", "login", "logout", "status"]],
     ["approvals", ["list", "allow", "deny"]],
+    ["permissions", ["list", "remove"]],
     ["version", ["check"]],
     ["gdgraph", ["build", "query", "find", "symbol", "symbols", "path", "affected", "repomap", "context", "assets"]],
     ["ctx", ["status", "diff", "rg", "read", "run", "show", "hook", "install-hook", "uninstall-hook"]],
@@ -210928,6 +212404,8 @@ var VERSION3, CLI_ROUTES, MCP_KNOWN_SUBCOMMANDS, USAGE_BODY = `Usage:
   keryx serve config init|set|show
   keryx approvals list [--all] [--json] | allow <id> | deny <id>
                                                Answer, from this machine, a call a remote turn is waiting on (once, that call only)
+  keryx permissions list [--json] | remove <number|pattern>
+                                               The saved shell rules an Always answer left behind; take one back
   keryx update [--skip-runtime] [--hooks]
   keryx dashboard build
   keryx dashboard open
@@ -211108,6 +212586,7 @@ Commands:
   projects  Inspect the user-global registry of initialized projects
   serve     Loopback-bound authenticated HTTP entry (off by default; read-only routes)
   approvals Pending remote approvals: list them, allow or deny one call, once (the local answer path of the serve entry)
+  permissions The saved shell rules (what Always remembered): list them, remove one
   update    Refresh managed service files without touching data artifacts
   dashboard Build or open the project admin dashboard
   dash      Rebuild and open .metaproject/keryx-dashboard.html
@@ -211188,6 +212667,7 @@ var init_cli_registry = __esm(() => {
   init_projects();
   init_serve();
   init_approvals();
+  init_permissions_command();
   init_update();
   init_dashboard();
   init_agents2();
@@ -211231,6 +212711,7 @@ var init_cli_registry = __esm(() => {
     auth: authCommand2,
     serve: serveCommand,
     approvals: approvalsCommand,
+    permissions: permissionsCommand,
     update: updateCommand,
     dashboard: dashboardCommand,
     dash: (rest) => dashboardCommand(rest.length > 0 ? rest : ["open"]),