switchroom 0.17.6 → 0.17.10

package/telegram-plugin/dist/bridge/bridge.js

@@ -24279,6 +24279,7 @@ function createIpcClient(options) {
     onInbound,
     onPermission,
     onStatus,
+    onConnect,
     log = () => {},
     reconnectDelayMs = 2000,
     maxReconnectDelayMs = 30000,
@@ -24414,6 +24415,13 @@ function createIpcClient(options) {
             sendRegister();
             startHeartbeat();
             log(`connected to ${socketPath}`);
+            if (onConnect) {
+              try {
+                onConnect();
+              } catch (err) {
+                log(`onConnect hook threw: ${err}`);
+              }
+            }
             resolve();
           },
           data(sock, data) {
@@ -24629,6 +24637,28 @@ function matchesAllowRule(rule, toolName, inputPreview) {
   return rule === toolName;
 }
 
+// bridge/permission-ledger.ts
+function createOutstandingPermissionLedger() {
+  const map2 = new Map;
+  return {
+    add(params) {
+      map2.set(params.request_id, params);
+    },
+    delete(requestId) {
+      map2.delete(requestId);
+    },
+    has(requestId) {
+      return map2.has(requestId);
+    },
+    all() {
+      return [...map2.values()];
+    },
+    get size() {
+      return map2.size;
+    }
+  };
+}
+
 // bridge/bridge.ts
 installPluginLogger();
 var STATE_DIR = process.env.TELEGRAM_STATE_DIR ?? join4(homedir3(), ".claude", "channels", "telegram");
@@ -24981,6 +25011,23 @@ var TOOL_SCHEMAS = [
       required: ["chat_id", "key"]
     }
   },
+  {
+    name: "mental_model_propose",
+    description: "Propose a Hindsight MENTAL MODEL for the operator to approve (agent-proposes \u2192 human-approves, hindsight Phase 5). Use this when \u2014 over real work \u2014 you notice a recurring, domain-specific question worth maintaining a standing, semantically-refreshed answer to from YOUR bank (e.g. a coach's `training-plan-state`, a lawyer's `open-matters`). You may PROPOSE but can NEVER self-approve: this renders a Telegram [Approve]/[Deny] card to the operator. On Approve the model is DECLARED \u2014 appended to your `memory.mental_models[]` in switchroom.yaml via the operator-approved config-edit path \u2014 and ensured in your bank (it then refreshes from your bank content). On Deny nothing is written. This is NOT for identity/'who is the user' (dedicated profile banks own that) and NOT a substitute for `retain` (store a fact) or `create_mental_model` where you already have direct Hindsight tools \u2014 it is the leashed, human-gated way to add a DURABLE declared model to your config. After firing this tool, END YOUR TURN cleanly \u2014 a fresh inbound arrives (`<channel source=\"mental_model_proposal_applied\">` / `mental_model_proposal_denied`) once the operator decides. Do NOT propose a model whose name is already declared (it is rejected), and do NOT spam (one card per proposal; the operator sees every one).",
+    inputSchema: {
+      type: "object",
+      properties: {
+        chat_id: { type: "string", description: "Chat to render the approval card in (use the chat_id of the user message that triggered the workflow)." },
+        name: { type: "string", description: "Stable model name \u2014 the idempotent-ensure identity key (lowercase kebab/snake, e.g. `training-plan-state`). Must be UNIQUE among your already-declared models or the proposal is rejected." },
+        source_query: { type: "string", description: `The reflection query the model answers, semantically refreshed from your bank content (e.g. "What is the athlete's current training plan, recent sessions, and open adjustments?"). Frame it as a DOMAIN question, never an identity question.` },
+        reason: { type: "string", description: 'REQUIRED in practice \u2014 one-line rationale rendered on the card (e.g. "I keep re-deriving the plan state every session; a standing model would save the lookup"). Omitting it renders "why: not provided" and the operator will usually Deny.' },
+        refresh_after_consolidation: { type: "boolean", description: "Refresh this model after each consolidation. Defaults OFF \u2014 refresh adds bounded background model-spend + timeout risk (RFC Phase 5). Only set true when the model genuinely needs to track fast-moving state." },
+        max_tokens: { type: "number", description: "Optional cap on the synthesized model's token size." },
+        message_thread_id: { type: "string", description: "Forum topic thread ID. Auto-applied from the last inbound message if not specified." }
+      },
+      required: ["chat_id", "name", "source_query"]
+    }
+  },
   {
     name: "linear_agent_activity",
     description: 'Emit a structured Linear AgentActivity against an agent session (#2298). Use this ONLY inside a turn that was woken by a Linear agent session (the inbound carries meta.source="linear" and meta.agent_session_id) \u2014 pass that agent_session_id back here. Linear renders activities as status chips + a timeline on the issue, so the human sees acknowledge \u2192 work \u2192 result. Emit a `thought` within ~10s of being woken so the session does not look dead, then `message`(s) as you make progress, and finally exactly one terminal `complete` (work done) or `error` (you could not proceed). body is required for thought/message/error and optional for complete. Resolves the agent\'s Linear app token from the vault; on VAULT-BROKER-DENIED it returns an error instructing you to vault_request_access for `linear/<agent>/token`.',
@@ -25104,6 +25151,28 @@ mcp.setRequestHandler(CallToolRequestSchema2, async (req) => {
   }
 });
 var sessionAllowRules = new Set;
+var outstandingPermissions = createOutstandingPermissionLedger();
+var permissionRearmEnabled = process.env.SWITCHROOM_PERMISSION_REARM !== "0";
+function flushOutstandingPermissionRequests() {
+  if (!permissionRearmEnabled)
+    return;
+  if (!ipc || !ipc.isConnected())
+    return;
+  const pending = outstandingPermissions.all();
+  if (pending.length === 0)
+    return;
+  process.stderr.write(`telegram bridge: re-sending ${pending.length} outstanding permission request(s) on gateway (re)connect
+`);
+  for (const p of pending) {
+    ipc.sendPermissionRequest({
+      type: "permission_request",
+      requestId: p.request_id,
+      toolName: p.tool_name,
+      description: p.description,
+      inputPreview: p.input_preview
+    });
+  }
+}
 mcp.setNotificationHandler(exports_external.object({
   method: exports_external.literal("notifications/claude/channel/permission_request"),
   params: exports_external.object({
@@ -25125,9 +25194,22 @@ mcp.setNotificationHandler(exports_external.object({
       return;
     }
   }
+  if (permissionRearmEnabled) {
+    outstandingPermissions.add({
+      request_id: params.request_id,
+      tool_name: params.tool_name,
+      description: params.description,
+      input_preview: params.input_preview
+    });
+  }
   if (!ipc || !ipc.isConnected()) {
-    process.stderr.write(`telegram bridge: permission_request received but not connected to gateway
+    if (permissionRearmEnabled) {
+      process.stderr.write(`telegram bridge: permission_request buffered (gateway offline), will re-send on reconnect ` + `request_id=${params.request_id}
+`);
+    } else {
+      process.stderr.write(`telegram bridge: permission_request received but not connected to gateway
 `);
+    }
     return;
   }
   ipc.sendPermissionRequest({
@@ -25155,6 +25237,7 @@ function onPermission(msg) {
   if (msg.rule) {
     sessionAllowRules.add(msg.rule);
   }
+  outstandingPermissions.delete(msg.requestId);
   mcp.notification({
     method: "notifications/claude/channel/permission",
     params: {
@@ -25287,6 +25370,7 @@ async function main() {
     onInbound,
     onPermission,
     onStatus,
+    onConnect: flushOutstandingPermissionRequests,
     log: (msg) => process.stderr.write(`telegram bridge: ipc: ${msg}
 `),
     livenessFilePath: process.env.SWITCHROOM_BRIDGE_ALIVE_PATH ?? join4(STATE_DIR, ".bridge-alive")