@dhf-claude/grix 0.1.8 → 0.1.9

package/dist/index.js

@@ -3221,8 +3221,8 @@ var require_utils = __commonJS({
       }
       return ind;
     }
-    function removeDotSegments(path9) {
-      let input = path9;
+    function removeDotSegments(path8) {
+      let input = path8;
       const output = [];
       let nextSlash = -1;
       let len = 0;
@@ -3421,8 +3421,8 @@ var require_schemes = __commonJS({
         wsComponent.secure = void 0;
       }
       if (wsComponent.resourceName) {
-        const [path9, query] = wsComponent.resourceName.split("?");
-        wsComponent.path = path9 && path9 !== "/" ? path9 : void 0;
+        const [path8, query] = wsComponent.resourceName.split("?");
+        wsComponent.path = path8 && path8 !== "/" ? path8 : void 0;
         wsComponent.query = query;
         wsComponent.resourceName = void 0;
       }
@@ -7159,8 +7159,8 @@ function getErrorMap() {
 
 // node_modules/zod/v3/helpers/parseUtil.js
 var makeIssue = (params) => {
-  const { data, path: path9, errorMaps, issueData } = params;
-  const fullPath = [...path9, ...issueData.path || []];
+  const { data, path: path8, errorMaps, issueData } = params;
+  const fullPath = [...path8, ...issueData.path || []];
   const fullIssue = {
     ...issueData,
     path: fullPath
@@ -7275,11 +7275,11 @@ var errorUtil;
 
 // node_modules/zod/v3/types.js
 var ParseInputLazyPath = class {
-  constructor(parent, value, path9, key) {
+  constructor(parent, value, path8, key) {
     this._cachedPath = [];
     this.parent = parent;
     this.data = value;
-    this._path = path9;
+    this._path = path8;
     this._key = key;
   }
   get path() {
@@ -10923,10 +10923,10 @@ function mergeDefs(...defs) {
 function cloneDef(schema) {
   return mergeDefs(schema._zod.def);
 }
-function getElementAtPath(obj, path9) {
-  if (!path9)
+function getElementAtPath(obj, path8) {
+  if (!path8)
     return obj;
-  return path9.reduce((acc, key) => acc?.[key], obj);
+  return path8.reduce((acc, key) => acc?.[key], obj);
 }
 function promiseAllObject(promisesObj) {
   const keys = Object.keys(promisesObj);
@@ -11309,11 +11309,11 @@ function aborted(x, startIndex = 0) {
   }
   return false;
 }
-function prefixIssues(path9, issues) {
+function prefixIssues(path8, issues) {
   return issues.map((iss) => {
     var _a2;
     (_a2 = iss).path ?? (_a2.path = []);
-    iss.path.unshift(path9);
+    iss.path.unshift(path8);
     return iss;
   });
 }
@@ -20560,9 +20560,9 @@ var Server = class extends Protocol {
     const requestedVersion = request.params.protocolVersion;
     this._clientCapabilities = request.params.capabilities;
     this._clientVersion = request.params.clientInfo;
-    const protocolVersion = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
+    const protocolVersion2 = SUPPORTED_PROTOCOL_VERSIONS.includes(requestedVersion) ? requestedVersion : LATEST_PROTOCOL_VERSION;
     return {
-      protocolVersion,
+      protocolVersion: protocolVersion2,
       capabilities: this.getCapabilities(),
       serverInfo: this._serverInfo,
       ...this._instructions && { instructions: this._instructions }
@@ -20809,50 +20809,9 @@ var StdioServerTransport = class {
   }
 };
 
-// server/access-store.js
-import { randomBytes } from "node:crypto";
-
-// server/paths.js
-import { mkdir as mkdirAsync } from "node:fs/promises";
-import os from "node:os";
+// server/channel-context-store.js
+import { mkdir } from "node:fs/promises";
 import path from "node:path";
-var defaultPluginID = "grix-claude";
-function sanitizePluginID(pluginID) {
-  return String(pluginID ?? defaultPluginID).trim().replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || defaultPluginID;
-}
-function resolvePluginDataDir(pluginID = defaultPluginID) {
-  const value = String(process.env.CLAUDE_PLUGIN_DATA ?? "").trim();
-  if (value) {
-    return value;
-  }
-  return path.join(os.homedir(), ".claude", sanitizePluginID(pluginID));
-}
-async function ensurePluginDataDir(pluginID = defaultPluginID) {
-  const dir = resolvePluginDataDir(pluginID);
-  await mkdirAsync(dir, { recursive: true });
-  return dir;
-}
-function resolveConfigPath(pluginID = defaultPluginID) {
-  return path.join(resolvePluginDataDir(pluginID), "grix-claude-config.json");
-}
-function resolveAccessPath(pluginID = defaultPluginID) {
-  return path.join(resolvePluginDataDir(pluginID), "grix-claude-access.json");
-}
-function resolveApprovalRequestsDir(pluginID = defaultPluginID) {
-  return path.join(resolvePluginDataDir(pluginID), "approval-requests");
-}
-function resolveApprovalNotificationsDir(pluginID = defaultPluginID) {
-  return path.join(resolvePluginDataDir(pluginID), "approval-notifications");
-}
-function resolveElicitationRequestsDir(pluginID = defaultPluginID) {
-  return path.join(resolvePluginDataDir(pluginID), "elicitation-requests");
-}
-function resolveSessionContextsDir(pluginID = defaultPluginID) {
-  return path.join(resolvePluginDataDir(pluginID), "session-contexts");
-}
-function resolveEventStatesDir(pluginID = defaultPluginID) {
-  return path.join(resolvePluginDataDir(pluginID), "event-states");
-}
 
 // server/json-file.js
 import { randomUUID } from "node:crypto";
@@ -20886,628 +20845,48 @@ async function writeJSONFileAtomic(filePath, value, { mode = 384 } = {}) {
   }
 }
 
-// server/access-store.js
-var defaultAccess = Object.freeze({
-  schema_version: 2,
-  policy: "allowlist",
-  allowlist: {},
-  approver_allowlist: {},
-  pending_pairs: {}
-});
-var pairingTTLMS = 10 * 60 * 1e3;
-function normalizeString(value) {
-  return String(value ?? "").trim();
-}
-function normalizePolicy(value) {
-  const normalized = normalizeString(value);
-  if (normalized === "open" || normalized === "disabled" || normalized === "allowlist") {
-    return normalized;
-  }
-  return "allowlist";
-}
-function cloneJSON(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-function generatePairingCode() {
-  const alphabet = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
-  const bytes = randomBytes(6);
-  let result = "";
-  for (const byte of bytes) {
-    result += alphabet[byte % alphabet.length];
-  }
-  return result;
-}
-function pruneExpiredPairs(state, now = Date.now()) {
-  for (const [code, entry] of Object.entries(state.pending_pairs ?? {})) {
-    const expiresAt = Number(entry?.expires_at ?? 0);
-    if (!Number.isFinite(expiresAt) || expiresAt <= now) {
-      delete state.pending_pairs[code];
-    }
-  }
-}
-function listAllowlistEntries(state) {
-  return Object.values(state.allowlist ?? {}).map((entry) => ({
-    sender_id: normalizeString(entry?.sender_id),
-    paired_at: Number(entry?.paired_at ?? 0)
-  })).filter((entry) => entry.sender_id).sort((left, right) => left.sender_id.localeCompare(right.sender_id));
-}
-function listApproverEntries(state) {
-  return Object.values(state.approver_allowlist ?? {}).map((entry) => ({
-    sender_id: normalizeString(entry?.sender_id),
-    added_at: Number(entry?.added_at ?? 0)
-  })).filter((entry) => entry.sender_id).sort((left, right) => left.sender_id.localeCompare(right.sender_id));
-}
-function listPendingPairs(state) {
-  return Object.entries(state.pending_pairs ?? {}).map(([code, entry]) => ({
-    code: normalizeString(code),
-    sender_id: normalizeString(entry?.sender_id),
-    session_id: normalizeString(entry?.session_id),
-    expires_at: Number(entry?.expires_at ?? 0)
-  })).filter((entry) => entry.code && entry.sender_id && entry.session_id).sort((left, right) => left.code.localeCompare(right.code));
-}
-function ensureShape(input = {}) {
-  const state = cloneJSON(defaultAccess);
-  if (Number(input.schema_version ?? 0) !== defaultAccess.schema_version) {
-    return state;
-  }
-  state.policy = normalizePolicy(input.policy);
-  state.allowlist = {};
-  state.approver_allowlist = {};
-  state.pending_pairs = {};
-  for (const [senderID, entry] of Object.entries(input.allowlist ?? {})) {
-    const normalizedSenderID = normalizeString(senderID || entry?.sender_id);
-    if (!normalizedSenderID) {
-      continue;
-    }
-    state.allowlist[normalizedSenderID] = {
-      sender_id: normalizedSenderID,
-      paired_at: Number(entry?.paired_at ?? Date.now())
-    };
-  }
-  for (const [code, entry] of Object.entries(input.pending_pairs ?? {})) {
-    const normalizedCode = normalizeString(code).toUpperCase();
-    const senderID = normalizeString(entry?.sender_id);
-    const sessionID = normalizeString(entry?.session_id);
-    const expiresAt = Number(entry?.expires_at ?? 0);
-    if (!normalizedCode || !senderID || !sessionID || !Number.isFinite(expiresAt)) {
-      continue;
-    }
-    state.pending_pairs[normalizedCode] = {
-      sender_id: senderID,
-      session_id: sessionID,
-      expires_at: Math.floor(expiresAt)
-    };
-  }
-  for (const [senderID, entry] of Object.entries(input.approver_allowlist ?? {})) {
-    const normalizedSenderID = normalizeString(senderID || entry?.sender_id);
-    if (!normalizedSenderID) {
-      continue;
-    }
-    state.approver_allowlist[normalizedSenderID] = {
-      sender_id: normalizedSenderID,
-      added_at: Number(entry?.added_at ?? Date.now())
-    };
-  }
-  pruneExpiredPairs(state);
-  return state;
-}
-var AccessStore = class {
-  constructor(filePath) {
-    this.filePath = filePath;
-    this.state = cloneJSON(defaultAccess);
-  }
-  async load() {
-    await ensurePluginDataDir();
-    const stored = await readJSONFile(this.filePath, defaultAccess);
-    this.state = ensureShape(stored);
-    return this.getStatus();
-  }
-  getStatus() {
-    pruneExpiredPairs(this.state);
-    const allowlist = listAllowlistEntries(this.state);
-    const approver_allowlist = listApproverEntries(this.state);
-    const pending_pairs = listPendingPairs(this.state);
-    return {
-      policy: this.state.policy,
-      allowlist_count: allowlist.length,
-      approver_count: approver_allowlist.length,
-      pending_pair_count: pending_pairs.length,
-      allowlist,
-      approver_allowlist,
-      pending_pairs
-    };
-  }
-  getPolicy() {
-    pruneExpiredPairs(this.state);
-    return this.state.policy;
-  }
-  isSenderAllowed(senderID) {
-    const normalizedSenderID = normalizeString(senderID);
-    if (!normalizedSenderID) {
-      return false;
-    }
-    const policy = this.getPolicy();
-    if (policy === "open") {
-      return true;
-    }
-    if (policy === "disabled") {
-      return false;
-    }
-    return Object.hasOwn(this.state.allowlist, normalizedSenderID);
-  }
-  isSenderAllowlisted(senderID) {
-    const normalizedSenderID = normalizeString(senderID);
-    if (!normalizedSenderID) {
-      return false;
-    }
-    return Object.hasOwn(this.state.allowlist, normalizedSenderID);
-  }
-  isSenderApprover(senderID) {
-    const normalizedSenderID = normalizeString(senderID);
-    if (!normalizedSenderID) {
-      return false;
-    }
-    return Object.hasOwn(this.state.approver_allowlist, normalizedSenderID);
-  }
-  hasApprovers() {
-    return listApproverEntries(this.state).length > 0;
-  }
-  hasAllowedSenders() {
-    return listAllowlistEntries(this.state).length > 0;
-  }
-  async setPolicy(policy) {
-    this.state.policy = normalizePolicy(policy);
-    await this.save();
-    return this.getStatus();
-  }
-  async issuePairingCode({ senderID, sessionID }) {
-    const normalizedSenderID = normalizeString(senderID);
-    const normalizedSessionID = normalizeString(sessionID);
-    if (!normalizedSenderID || !normalizedSessionID) {
-      throw new Error("senderID and sessionID are required");
-    }
-    const now = Date.now();
-    pruneExpiredPairs(this.state, now);
-    for (const [code2, entry] of Object.entries(this.state.pending_pairs)) {
-      if (normalizeString(entry.sender_id) === normalizedSenderID && normalizeString(entry.session_id) === normalizedSessionID) {
-        return {
-          code: code2,
-          sender_id: normalizedSenderID,
-          session_id: normalizedSessionID,
-          expires_at: entry.expires_at
-        };
-      }
-    }
-    let code = generatePairingCode();
-    while (Object.hasOwn(this.state.pending_pairs, code)) {
-      code = generatePairingCode();
-    }
-    const pair = {
-      sender_id: normalizedSenderID,
-      session_id: normalizedSessionID,
-      expires_at: now + pairingTTLMS
-    };
-    this.state.pending_pairs[code] = pair;
-    await this.save();
-    return {
-      code,
-      ...pair
-    };
-  }
-  async approvePairing(code) {
-    const normalizedCode = normalizeString(code).toUpperCase();
-    if (!normalizedCode) {
-      throw new Error("pairing code is required");
-    }
-    pruneExpiredPairs(this.state);
-    const pending = this.state.pending_pairs[normalizedCode];
-    if (!pending) {
-      throw new Error("pairing code not found or expired");
-    }
-    const senderID = normalizeString(pending.sender_id);
-    this.state.allowlist[senderID] = {
-      sender_id: senderID,
-      paired_at: Date.now()
-    };
-    delete this.state.pending_pairs[normalizedCode];
-    await this.save();
-    return {
-      sender_id: senderID,
-      session_id: normalizeString(pending.session_id),
-      policy: this.state.policy
-    };
-  }
-  async denyPairing(code) {
-    const normalizedCode = normalizeString(code).toUpperCase();
-    if (!normalizedCode) {
-      throw new Error("pairing code is required");
-    }
-    pruneExpiredPairs(this.state);
-    const pending = this.state.pending_pairs[normalizedCode];
-    if (!pending) {
-      throw new Error("pairing code not found or expired");
-    }
-    delete this.state.pending_pairs[normalizedCode];
-    await this.save();
-    return {
-      code: normalizedCode,
-      sender_id: normalizeString(pending.sender_id),
-      session_id: normalizeString(pending.session_id),
-      policy: this.state.policy
-    };
-  }
-  async allowSender(senderID) {
-    const normalizedSenderID = normalizeString(senderID);
-    if (!normalizedSenderID) {
-      throw new Error("sender_id is required");
-    }
-    this.state.allowlist[normalizedSenderID] = {
-      sender_id: normalizedSenderID,
-      paired_at: Date.now()
-    };
-    await this.save();
-    return {
-      sender_id: normalizedSenderID,
-      policy: this.state.policy
-    };
-  }
-  async bootstrapFirstSender(senderID, { lockPolicyToAllowlist = false } = {}) {
-    const normalizedSenderID = normalizeString(senderID);
-    if (!normalizedSenderID) {
-      throw new Error("sender_id is required");
-    }
-    if (this.state.policy === "disabled") {
-      return {
-        sender_id: normalizedSenderID,
-        bootstrapped: false,
-        policy: this.state.policy
-      };
-    }
-    if (this.hasAllowedSenders() || Object.hasOwn(this.state.allowlist, normalizedSenderID)) {
-      return {
-        sender_id: normalizedSenderID,
-        bootstrapped: false,
-        policy: this.state.policy
-      };
-    }
-    this.state.allowlist[normalizedSenderID] = {
-      sender_id: normalizedSenderID,
-      paired_at: Date.now()
-    };
-    if (lockPolicyToAllowlist && this.state.policy === "open") {
-      this.state.policy = "allowlist";
-    }
-    await this.save();
-    return {
-      sender_id: normalizedSenderID,
-      bootstrapped: true,
-      policy: this.state.policy
-    };
-  }
-  async allowApprover(senderID) {
-    const normalizedSenderID = normalizeString(senderID);
-    if (!normalizedSenderID) {
-      throw new Error("sender_id is required");
-    }
-    this.state.approver_allowlist[normalizedSenderID] = {
-      sender_id: normalizedSenderID,
-      added_at: Date.now()
-    };
-    await this.save();
-    return {
-      sender_id: normalizedSenderID,
-      approver: true
-    };
-  }
-  async removeSender(senderID) {
-    const normalizedSenderID = normalizeString(senderID);
-    if (!normalizedSenderID) {
-      throw new Error("sender_id is required");
-    }
-    delete this.state.allowlist[normalizedSenderID];
-    await this.save();
-    return {
-      sender_id: normalizedSenderID,
-      policy: this.state.policy,
-      removed: true
-    };
-  }
-  async removeApprover(senderID) {
-    const normalizedSenderID = normalizeString(senderID);
-    if (!normalizedSenderID) {
-      throw new Error("sender_id is required");
-    }
-    const removed = Object.hasOwn(this.state.approver_allowlist, normalizedSenderID);
-    delete this.state.approver_allowlist[normalizedSenderID];
-    await this.save();
-    return {
-      sender_id: normalizedSenderID,
-      approver: true,
-      removed
-    };
-  }
-  async save() {
-    await ensurePluginDataDir();
-    pruneExpiredPairs(this.state);
-    await writeJSONFileAtomic(this.filePath, this.state);
-  }
-};
-
-// server/approval-store.js
-import { mkdir, readdir } from "node:fs/promises";
-import path2 from "node:path";
+// server/channel-context-store.js
 var schemaVersion = 1;
-function normalizeString2(value) {
+function normalizeString(value) {
   return String(value ?? "").trim();
 }
-function cloneJSON2(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-function normalizeDecision(input) {
-  if (!input || typeof input !== "object") {
-    return null;
-  }
-  const behavior = normalizeString2(input.behavior);
-  if (behavior !== "allow" && behavior !== "deny") {
-    return null;
-  }
-  const next = {
-    behavior
-  };
-  if (Array.isArray(input.updatedPermissions) && input.updatedPermissions.length > 0) {
-    next.updatedPermissions = cloneJSON2(input.updatedPermissions);
-  }
-  const message = normalizeString2(input.message);
-  if (message) {
-    next.message = message;
-  }
-  if (input.interrupt === true) {
-    next.interrupt = true;
-  }
-  return next;
-}
-function normalizeRequest(input) {
-  if (!input || typeof input !== "object" || Number(input.schema_version) !== schemaVersion) {
-    return null;
-  }
-  const status = normalizeString2(input.status) || "pending";
-  const channelContext = input.channel_context ?? {};
-  return {
-    schema_version: schemaVersion,
-    request_id: normalizeString2(input.request_id),
-    status,
-    created_at: Number(input.created_at ?? 0),
-    updated_at: Number(input.updated_at ?? 0),
-    dispatched_at: Number(input.dispatched_at ?? 0),
-    dispatch_error: normalizeString2(input.dispatch_error),
-    approval_message_id: normalizeString2(input.approval_message_id),
-    session_id: normalizeString2(input.session_id),
-    transcript_path: normalizeString2(input.transcript_path),
-    tool_name: normalizeString2(input.tool_name),
-    tool_input: cloneJSON2(input.tool_input ?? {}),
-    permission_suggestions: cloneJSON2(input.permission_suggestions ?? []),
-    channel_context: {
-      chat_id: normalizeString2(channelContext.chat_id),
-      event_id: normalizeString2(channelContext.event_id),
-      message_id: normalizeString2(channelContext.message_id),
-      sender_id: normalizeString2(channelContext.sender_id),
-      user_id: normalizeString2(channelContext.user_id),
-      msg_id: normalizeString2(channelContext.msg_id)
-    },
-    decision: normalizeDecision(input.decision),
-    resolved_by: input.resolved_by && typeof input.resolved_by === "object" ? {
-      sender_id: normalizeString2(input.resolved_by.sender_id),
-      session_id: normalizeString2(input.resolved_by.session_id),
-      event_id: normalizeString2(input.resolved_by.event_id),
-      msg_id: normalizeString2(input.resolved_by.msg_id)
-    } : null
-  };
-}
-async function listJSONFiles(dirPath) {
-  let names = [];
-  try {
-    names = await readdir(dirPath);
-  } catch (error2) {
-    if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
-      return [];
-    }
-    throw error2;
-  }
-  return names.filter((name) => name.endsWith(".json"));
+function sanitizeFileName(value) {
+  return normalizeString(value).replace(/[^a-zA-Z0-9_-]+/g, "-");
 }
-var ApprovalStore = class {
-  constructor({ requestsDir, notificationsDir }) {
-    this.requestsDir = requestsDir;
-    this.notificationsDir = notificationsDir;
-  }
-  async init() {
-    await mkdir(this.requestsDir, { recursive: true });
-    await mkdir(this.notificationsDir, { recursive: true });
-  }
-  resolveRequestPath(requestID) {
-    return path2.join(this.requestsDir, `${normalizeString2(requestID)}.json`);
-  }
-  async createPermissionRequest(input) {
-    const requestID = normalizeString2(input.request_id);
-    const now = Math.floor(input.created_at ?? Date.now());
-    if (!requestID) {
-      throw new Error("request_id is required");
-    }
-    const request = normalizeRequest({
-      schema_version: schemaVersion,
-      request_id: requestID,
-      status: "pending",
-      created_at: now,
-      updated_at: now,
-      dispatched_at: 0,
-      dispatch_error: "",
-      approval_message_id: "",
-      session_id: input.session_id,
-      transcript_path: input.transcript_path,
-      tool_name: input.tool_name,
-      tool_input: input.tool_input ?? {},
-      permission_suggestions: input.permission_suggestions ?? [],
-      channel_context: input.channel_context ?? {},
-      decision: null,
-      resolved_by: null
-    });
-    await writeJSONFileAtomic(this.resolveRequestPath(requestID), request);
-    return request;
-  }
-  async getRequest(requestID) {
-    const stored = await readJSONFile(this.resolveRequestPath(requestID), null);
-    return normalizeRequest(stored);
-  }
-  async saveRequest(request) {
-    const normalized = normalizeRequest(request);
-    if (!normalized?.request_id) {
-      throw new Error("request_id is required");
-    }
-    normalized.updated_at = Math.floor(Date.now());
-    await writeJSONFileAtomic(this.resolveRequestPath(normalized.request_id), normalized);
-    return normalized;
-  }
-  async listPendingDispatches() {
-    const names = await listJSONFiles(this.requestsDir);
-    const requests = [];
-    for (const name of names) {
-      const request = await this.getRequest(name.replace(/\.json$/u, ""));
-      if (!request) {
-        continue;
-      }
-      if (request.status !== "pending") {
-        continue;
-      }
-      if (!request.channel_context.chat_id) {
-        continue;
-      }
-      if (request.dispatched_at > 0) {
-        continue;
-      }
-      requests.push(request);
-    }
-    requests.sort((left, right) => left.created_at - right.created_at);
-    return requests;
-  }
-  async markDispatched(requestID, { dispatchedAt = Date.now(), approvalMessageID = "" } = {}) {
-    const request = await this.getRequest(requestID);
-    if (!request) {
-      throw new Error("approval request not found");
-    }
-    request.dispatched_at = Math.floor(dispatchedAt);
-    request.dispatch_error = "";
-    request.approval_message_id = normalizeString2(approvalMessageID);
-    return this.saveRequest(request);
-  }
-  async markDispatchFailed(requestID, errorText) {
-    const request = await this.getRequest(requestID);
-    if (!request) {
-      throw new Error("approval request not found");
-    }
-    request.dispatch_error = normalizeString2(errorText);
-    return this.saveRequest(request);
+function buildContextFileName(sessionID, agentID = "") {
+  const normalizedSessionID = sanitizeFileName(sessionID);
+  if (!normalizedSessionID) {
+    throw new Error("session_id is required");
   }
-  async resolveRequest(requestID, { decision, resolvedBy }) {
-    const request = await this.getRequest(requestID);
-    if (!request) {
-      throw new Error("approval request not found");
-    }
-    if (request.status !== "pending") {
-      throw new Error(`approval request is ${request.status}`);
-    }
-    const normalizedDecision = normalizeDecision(decision);
-    if (!normalizedDecision) {
-      throw new Error("invalid approval decision");
-    }
-    request.status = "resolved";
-    request.decision = normalizedDecision;
-    request.resolved_by = {
-      sender_id: normalizeString2(resolvedBy?.sender_id),
-      session_id: normalizeString2(resolvedBy?.session_id),
-      event_id: normalizeString2(resolvedBy?.event_id),
-      msg_id: normalizeString2(resolvedBy?.msg_id)
-    };
-    return this.saveRequest(request);
-  }
-  async markExpired(requestID) {
-    const request = await this.getRequest(requestID);
-    if (!request || request.status !== "pending") {
-      return request;
-    }
-    request.status = "expired";
-    return this.saveRequest(request);
+  const normalizedAgentID = sanitizeFileName(agentID);
+  if (!normalizedAgentID) {
+    return `${normalizedSessionID}.json`;
   }
-  async recordNotification(event) {
-    const now = Date.now();
-    const filePath = path2.join(this.notificationsDir, `${now}.json`);
-    await writeJSONFileAtomic(filePath, {
-      schema_version: schemaVersion,
-      created_at: now,
-      payload: cloneJSON2(event ?? {})
-    });
-  }
-  async getStatus() {
-    const names = await listJSONFiles(this.requestsDir);
-    let pendingCount = 0;
-    let resolvedCount = 0;
-    let expiredCount = 0;
-    for (const name of names) {
-      const request = await this.getRequest(name.replace(/\.json$/u, ""));
-      if (!request) {
-        continue;
-      }
-      if (request.status === "pending") {
-        pendingCount += 1;
-      } else if (request.status === "resolved") {
-        resolvedCount += 1;
-      } else if (request.status === "expired") {
-        expiredCount += 1;
-      }
-    }
-    return {
-      pending_count: pendingCount,
-      resolved_count: resolvedCount,
-      expired_count: expiredCount
-    };
-  }
-};
-
-// server/channel-context-store.js
-import { mkdir as mkdir2 } from "node:fs/promises";
-import path3 from "node:path";
-var schemaVersion2 = 1;
-function normalizeString3(value) {
-  return String(value ?? "").trim();
-}
-function sanitizeFileName(value) {
-  return normalizeString3(value).replace(/[^a-zA-Z0-9_-]+/g, "-");
+  return `${normalizedSessionID}--${normalizedAgentID}.json`;
 }
 function normalizeContext(input) {
   if (!input || typeof input !== "object") {
     return null;
   }
   const context = input.context ?? {};
-  const sessionID = normalizeString3(input.session_id);
-  const transcriptPath = normalizeString3(input.transcript_path);
-  const cwd = normalizeString3(input.cwd);
-  const chatID = normalizeString3(context.chat_id);
+  const sessionID = normalizeString(input.session_id);
+  const agentID = normalizeString(input.agent_id);
+  const transcriptPath = normalizeString(input.transcript_path);
+  const cwd = normalizeString(input.cwd);
+  const chatID = normalizeString(context.chat_id);
   if (!sessionID || !transcriptPath || !chatID) {
     return null;
   }
   return {
-    schema_version: schemaVersion2,
+    schema_version: schemaVersion,
     session_id: sessionID,
+    agent_id: agentID,
     transcript_path: transcriptPath,
     cwd,
     updated_at: Number(input.updated_at ?? Date.now()),
     context: {
-      raw_tag: normalizeString3(context.raw_tag),
       chat_id: chatID,
-      event_id: normalizeString3(context.event_id),
-      message_id: normalizeString3(context.message_id),
-      sender_id: normalizeString3(context.sender_id),
-      user_id: normalizeString3(context.user_id),
-      msg_id: normalizeString3(context.msg_id)
+      message_id: normalizeString(context.message_id || context.msg_id)
     }
   };
 }
@@ -21516,14 +20895,10 @@ var ChannelContextStore = class {
     this.contextsDir = contextsDir;
   }
   async init() {
-    await mkdir2(this.contextsDir, { recursive: true });
+    await mkdir(this.contextsDir, { recursive: true });
   }
-  resolveSessionPath(sessionID) {
-    const name = sanitizeFileName(sessionID);
-    if (!name) {
-      throw new Error("session_id is required");
-    }
-    return path3.join(this.contextsDir, `${name}.json`);
+  resolveSessionPath(sessionID, agentID = "") {
+    return path.join(this.contextsDir, buildContextFileName(sessionID, agentID));
   }
   async put(input) {
     const normalized = normalizeContext(input);
@@ -21531,20 +20906,33 @@ var ChannelContextStore = class {
       throw new Error("valid session context is required");
     }
     await this.init();
-    await writeJSONFileAtomic(this.resolveSessionPath(normalized.session_id), normalized);
+    await writeJSONFileAtomic(
+      this.resolveSessionPath(normalized.session_id, normalized.agent_id),
+      normalized
+    );
     return normalized;
   }
-  async get(sessionID) {
-    const normalizedSessionID = normalizeString3(sessionID);
+  async get(sessionID, { agentID = "" } = {}) {
+    const normalizedSessionID = normalizeString(sessionID);
     if (!normalizedSessionID) {
       return null;
     }
-    const stored = await readJSONFile(this.resolveSessionPath(normalizedSessionID), null);
+    const stored = await readJSONFile(
+      this.resolveSessionPath(normalizedSessionID, agentID),
+      null
+    );
     return normalizeContext(stored);
   }
-  async getMatchingContext({ sessionID, transcriptPath, workingDir, maxAgeMs }) {
+  async getMatchingContext({
+    sessionID,
+    agentID,
+    transcriptPath,
+    workingDir,
+    maxAgeMs
+  }) {
     const inspection = await this.inspectMatchingContext({
       sessionID,
+      agentID,
       transcriptPath,
       workingDir,
       maxAgeMs
@@ -21554,21 +20942,27 @@ var ChannelContextStore = class {
     }
     return inspection.context;
   }
-  async inspectMatchingContext({ sessionID, transcriptPath, workingDir, maxAgeMs }) {
-    const stored = await this.get(sessionID);
+  async inspectMatchingContext({
+    sessionID,
+    agentID,
+    transcriptPath,
+    workingDir,
+    maxAgeMs
+  }) {
+    const stored = await this.get(sessionID, { agentID });
     if (!stored) {
       return {
         status: "missing",
         context: null
       };
     }
-    if (normalizeString3(transcriptPath) && stored.transcript_path !== normalizeString3(transcriptPath)) {
+    if (normalizeString(transcriptPath) && stored.transcript_path !== normalizeString(transcriptPath)) {
       return {
         status: "transcript_mismatch",
         context: null
       };
     }
-    if (normalizeString3(workingDir) && stored.cwd !== normalizeString3(workingDir)) {
+    if (normalizeString(workingDir) && stored.cwd !== normalizeString(workingDir)) {
       return {
         status: "cwd_mismatch",
         context: null
@@ -21588,15 +20982,15 @@ var ChannelContextStore = class {
 };
 
 // server/config-store.js
-import path4 from "node:path";
-import { mkdir as mkdir3 } from "node:fs/promises";
+import path2 from "node:path";
+import { mkdir as mkdir2 } from "node:fs/promises";
 
 // server/connection-env.js
-function normalizeString4(value) {
+function normalizeString2(value) {
   return String(value ?? "").trim();
 }
 function normalizePositiveInt(value) {
-  const normalized = normalizeString4(value);
+  const normalized = normalizeString2(value);
   if (!normalized) {
     return void 0;
   }
@@ -21608,7 +21002,7 @@ function normalizePositiveInt(value) {
 }
 function readFirstNonEmpty(values = []) {
   for (const value of values) {
-    const normalized = normalizeString4(value);
+    const normalized = normalizeString2(value);
     if (normalized) {
       return normalized;
     }
@@ -21645,7 +21039,7 @@ var defaultConfig = Object.freeze({
   api_key: "",
   outbound_text_chunk_limit: DEFAULT_OUTBOUND_TEXT_CHUNK_LIMIT
 });
-function normalizeString5(value) {
+function normalizeString3(value) {
   return String(value ?? "").trim();
 }
 function normalizePositiveInt2(value, fallbackValue) {
@@ -21658,9 +21052,9 @@ function normalizePositiveInt2(value, fallbackValue) {
 function normalizeConfigShape(input = {}) {
   return {
     schema_version: 1,
-    ws_url: normalizeString5(input.ws_url),
-    agent_id: normalizeString5(input.agent_id),
-    api_key: normalizeString5(input.api_key),
+    ws_url: normalizeString3(input.ws_url),
+    agent_id: normalizeString3(input.agent_id),
+    api_key: normalizeString3(input.api_key),
     outbound_text_chunk_limit: normalizePositiveInt2(
       input.outbound_text_chunk_limit,
       DEFAULT_OUTBOUND_TEXT_CHUNK_LIMIT
@@ -21704,7 +21098,7 @@ function validateConfig(config2) {
   }
 }
 function redactAPIKey(apiKey) {
-  const normalized = normalizeString5(apiKey);
+  const normalized = normalizeString3(apiKey);
   if (!normalized) {
     return "";
   }
@@ -21720,7 +21114,7 @@ var ConfigStore = class {
     this.config = { ...defaultConfig };
   }
   async load() {
-    await mkdir3(path4.dirname(this.filePath), { recursive: true, mode: 448 });
+    await mkdir2(path2.dirname(this.filePath), { recursive: true, mode: 448 });
     const stored = await readJSONFile(this.filePath, defaultConfig);
     this.config = normalizeConfigShape(applyEnvOverrides(stored, this.env));
     validateConfig(this.config);
@@ -21758,7 +21152,7 @@ var ConfigStore = class {
       ...input
     });
     validateConfig(next);
-    await mkdir3(path4.dirname(this.filePath), { recursive: true, mode: 448 });
+    await mkdir2(path2.dirname(this.filePath), { recursive: true, mode: 448 });
     await writeJSONFileAtomic(this.filePath, next, { mode: 384 });
     this.config = applyEnvOverrides(next, this.env);
     validateConfig(this.config);
@@ -21767,31 +21161,25 @@ var ConfigStore = class {
 };
 
 // server/elicitation-store.js
-import { mkdir as mkdir4, readdir as readdir2 } from "node:fs/promises";
-import path5 from "node:path";
+import { mkdir as mkdir3, readdir } from "node:fs/promises";
+import path3 from "node:path";
 
 // server/elicitation-schema.js
-function normalizeString6(value) {
+function normalizeString4(value) {
   return String(value ?? "").trim();
 }
-function cloneJSON3(value) {
-  return JSON.parse(JSON.stringify(value));
-}
-function isRecord(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
 function normalizeStringArray(input) {
   if (!Array.isArray(input)) {
     return [];
   }
-  return input.map((value) => normalizeString6(value)).filter(Boolean);
+  return input.map((value) => normalizeString4(value)).filter(Boolean);
 }
 function normalizeFieldType(value) {
-  const normalized = normalizeString6(value).toLowerCase();
+  const normalized = normalizeString4(value).toLowerCase();
   return normalized || "string";
 }
 function normalizeFieldKind(value) {
-  const normalized = normalizeString6(value).toLowerCase();
+  const normalized = normalizeString4(value).toLowerCase();
   if (!normalized) {
     return "string";
   }
@@ -21799,7 +21187,7 @@ function normalizeFieldKind(value) {
 }
 function normalizeFieldPrompt(title, description, kind) {
   const lines = [];
-  const normalizedDescription = normalizeString6(description);
+  const normalizedDescription = normalizeString4(description);
   if (normalizedDescription) {
     lines.push(normalizedDescription);
   }
@@ -21815,7 +21203,7 @@ function normalizeFieldPrompt(title, description, kind) {
   if (typeHint) {
     lines.push(typeHint);
   }
-  return lines.join(" ").trim() || `Provide ${normalizeString6(title) || "a value"}.`;
+  return lines.join(" ").trim() || `Provide ${normalizeString4(title) || "a value"}.`;
 }
 function normalizeFieldOptions(input) {
   return normalizeStringArray(input);
@@ -21825,15 +21213,15 @@ function normalizeElicitationFields(input) {
     return [];
   }
   return input.map((field) => {
-    const key = normalizeString6(field?.key);
-    const title = normalizeString6(field?.title) || key;
+    const key = normalizeString4(field?.key);
+    const title = normalizeString4(field?.title) || key;
     if (!key || !title) {
       return null;
     }
     return {
       key,
       title,
-      prompt: normalizeString6(field?.prompt) || normalizeFieldPrompt(title, "", field?.kind),
+      prompt: normalizeString4(field?.prompt) || normalizeFieldPrompt(title, "", field?.kind),
       type: normalizeFieldType(field?.type),
       kind: normalizeFieldKind(field?.kind),
       options: normalizeFieldOptions(field?.options),
@@ -21842,112 +21230,66 @@ function normalizeElicitationFields(input) {
     };
   }).filter(Boolean);
 }
-function buildQuestionPromptsFromFields(fields) {
-  return normalizeElicitationFields(fields).map((field) => ({
-    header: field.title,
-    question: field.prompt,
-    options: field.options.map((label) => ({ label })),
-    multiSelect: field.multi_select
-  }));
-}
-function cloneRequestedSchema(requestedSchema) {
-  if (!isRecord(requestedSchema)) {
-    return null;
-  }
-  return cloneJSON3(requestedSchema);
-}
 
 // server/elicitation-store.js
-var schemaVersion3 = 1;
-function normalizeString7(value) {
+var schemaVersion2 = 1;
+function normalizeString5(value) {
   return String(value ?? "").trim();
 }
-function cloneJSON4(value) {
+function cloneJSON(value) {
   return JSON.parse(JSON.stringify(value));
 }
-function isRecord2(value) {
+function isRecord(value) {
   return Boolean(value) && typeof value === "object" && !Array.isArray(value);
 }
 function normalizeChannelContext(input) {
   const context = input ?? {};
   return {
-    chat_id: normalizeString7(context.chat_id),
-    event_id: normalizeString7(context.event_id),
-    message_id: normalizeString7(context.message_id),
-    sender_id: normalizeString7(context.sender_id),
-    user_id: normalizeString7(context.user_id),
-    msg_id: normalizeString7(context.msg_id)
+    chat_id: normalizeString5(context.chat_id),
+    message_id: normalizeString5(context.message_id || context.msg_id)
   };
 }
-function normalizeResolvedBy(input) {
-  if (!isRecord2(input)) {
+function normalizeResponseContent(input) {
+  if (!isRecord(input)) {
     return null;
   }
-  return {
-    sender_id: normalizeString7(input.sender_id),
-    session_id: normalizeString7(input.session_id),
-    event_id: normalizeString7(input.event_id),
-    msg_id: normalizeString7(input.msg_id)
-  };
+  return cloneJSON(input);
 }
-function normalizeResponseContent(input) {
-  if (!isRecord2(input)) {
+function normalizeRequestPayload(input) {
+  if (!isRecord(input)) {
     return null;
   }
-  return cloneJSON4(input);
+  return cloneJSON(input);
 }
-function normalizeQuestions(input) {
-  if (!Array.isArray(input)) {
-    return [];
+function allowsEmptyFields(requestPayload) {
+  const payload = normalizeRequestPayload(requestPayload);
+  if (!payload) {
+    return false;
   }
-  return input.map((question) => {
-    const prompt = normalizeString7(question?.question);
-    if (!prompt) {
-      return null;
-    }
-    return {
-      question: prompt,
-      header: normalizeString7(question?.header),
-      options: Array.isArray(question?.options) ? cloneJSON4(question.options) : [],
-      multiSelect: question?.multiSelect === true
-    };
-  }).filter(Boolean);
+  return normalizeString5(payload.mode).toLowerCase() === "url" && normalizeString5(payload.url) !== "";
 }
-function normalizeRequest2(input) {
-  if (!isRecord2(input) || Number(input.schema_version) !== schemaVersion3) {
+function normalizeRequest(input) {
+  if (!isRecord(input) || Number(input.schema_version) !== schemaVersion2) {
     return null;
   }
   const fields = normalizeElicitationFields(input.fields);
-  const storedQuestions = normalizeQuestions(input.questions);
   return {
-    schema_version: schemaVersion3,
-    request_id: normalizeString7(input.request_id),
-    status: normalizeString7(input.status) || "pending",
+    schema_version: schemaVersion2,
+    request_id: normalizeString5(input.request_id),
+    status: normalizeString5(input.status) || "pending",
     created_at: Number(input.created_at ?? 0),
-    updated_at: Number(input.updated_at ?? 0),
     dispatched_at: Number(input.dispatched_at ?? 0),
-    dispatch_error: normalizeString7(input.dispatch_error),
-    prompt_message_id: normalizeString7(input.prompt_message_id),
-    session_id: normalizeString7(input.session_id),
-    transcript_path: normalizeString7(input.transcript_path),
-    mcp_server_name: normalizeString7(input.mcp_server_name),
-    elicitation_id: normalizeString7(input.elicitation_id),
-    message: normalizeString7(input.message),
-    mode: normalizeString7(input.mode) || "form",
-    url: normalizeString7(input.url),
-    requested_schema: input.requested_schema === null ? null : cloneRequestedSchema(input.requested_schema),
     fields,
-    questions: storedQuestions.length > 0 ? storedQuestions : buildQuestionPromptsFromFields(fields),
+    request_payload: normalizeRequestPayload(input.request_payload),
     channel_context: normalizeChannelContext(input.channel_context),
-    response_action: normalizeString7(input.response_action),
-    response_content: input.response_content === null ? null : normalizeResponseContent(input.response_content),
-    resolved_by: normalizeResolvedBy(input.resolved_by)
+    response_action: normalizeString5(input.response_action),
+    response_content: input.response_content === null ? null : normalizeResponseContent(input.response_content)
   };
 }
-async function listJSONFiles2(dirPath) {
+async function listJSONFiles(dirPath) {
   let names = [];
   try {
-    names = await readdir2(dirPath);
+    names = await readdir(dirPath);
   } catch (error2) {
     if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
       return [];
@@ -21961,63 +21303,50 @@ var ElicitationStore = class {
     this.requestsDir = requestsDir;
   }
   async init() {
-    await mkdir4(this.requestsDir, { recursive: true });
+    await mkdir3(this.requestsDir, { recursive: true });
   }
   resolveRequestPath(requestID) {
-    return path5.join(this.requestsDir, `${normalizeString7(requestID)}.json`);
+    return path3.join(this.requestsDir, `${normalizeString5(requestID)}.json`);
   }
   async createRequest(input) {
-    const requestID = normalizeString7(input.request_id);
+    const requestID = normalizeString5(input.request_id);
     const now = Math.floor(input.created_at ?? Date.now());
     if (!requestID) {
       throw new Error("request_id is required");
     }
     const fields = normalizeElicitationFields(input.fields);
-    if (fields.length === 0) {
+    if (fields.length === 0 && !allowsEmptyFields(input.request_payload)) {
       throw new Error("elicitation request fields are required");
     }
-    const request = normalizeRequest2({
-      schema_version: schemaVersion3,
+    const request = normalizeRequest({
+      schema_version: schemaVersion2,
       request_id: requestID,
       status: "pending",
       created_at: now,
-      updated_at: now,
       dispatched_at: 0,
-      dispatch_error: "",
-      prompt_message_id: "",
-      session_id: input.session_id,
-      transcript_path: input.transcript_path,
-      mcp_server_name: input.mcp_server_name,
-      elicitation_id: input.elicitation_id,
-      message: input.message,
-      mode: input.mode,
-      url: input.url,
-      requested_schema: input.requested_schema ?? null,
       fields,
-      questions: buildQuestionPromptsFromFields(fields),
+      request_payload: input.request_payload ?? null,
       channel_context: input.channel_context ?? {},
       response_action: "",
-      response_content: null,
-      resolved_by: null
+      response_content: null
     });
     await writeJSONFileAtomic(this.resolveRequestPath(requestID), request);
     return request;
   }
   async getRequest(requestID) {
     const stored = await readJSONFile(this.resolveRequestPath(requestID), null);
-    return normalizeRequest2(stored);
+    return normalizeRequest(stored);
   }
   async saveRequest(request) {
-    const normalized = normalizeRequest2(request);
+    const normalized = normalizeRequest(request);
     if (!normalized?.request_id) {
       throw new Error("request_id is required");
     }
-    normalized.updated_at = Math.floor(Date.now());
     await writeJSONFileAtomic(this.resolveRequestPath(normalized.request_id), normalized);
     return normalized;
   }
   async listPendingDispatches() {
-    const names = await listJSONFiles2(this.requestsDir);
+    const names = await listJSONFiles(this.requestsDir);
     const requests = [];
     for (const name of names) {
       const request = await this.getRequest(name.replace(/\.json$/u, ""));
@@ -22038,25 +21367,23 @@ var ElicitationStore = class {
     requests.sort((left, right) => left.created_at - right.created_at);
     return requests;
   }
-  async markDispatched(requestID, { dispatchedAt = Date.now(), promptMessageID = "" } = {}) {
+  async markDispatched(requestID, { dispatchedAt = Date.now() } = {}) {
     const request = await this.getRequest(requestID);
     if (!request) {
       throw new Error("elicitation request not found");
     }
     request.dispatched_at = Math.floor(dispatchedAt);
-    request.dispatch_error = "";
-    request.prompt_message_id = normalizeString7(promptMessageID);
     return this.saveRequest(request);
   }
   async markDispatchFailed(requestID, errorText) {
+    void errorText;
     const request = await this.getRequest(requestID);
     if (!request) {
       throw new Error("elicitation request not found");
     }
-    request.dispatch_error = normalizeString7(errorText);
-    return this.saveRequest(request);
+    return request;
   }
-  async resolveRequest(requestID, { action, content, resolvedBy }) {
+  async resolveRequest(requestID, { action, content }) {
     const request = await this.getRequest(requestID);
     if (!request) {
       throw new Error("elicitation request not found");
@@ -22064,8 +21391,8 @@ var ElicitationStore = class {
     if (request.status !== "pending") {
       throw new Error(`elicitation request is ${request.status}`);
     }
-    const normalizedAction = normalizeString7(action);
-    if (!["accept", "decline", "cancel"].includes(normalizedAction)) {
+    const normalizedAction = normalizeString5(action);
+    if (!["accept", "cancel"].includes(normalizedAction)) {
       throw new Error("invalid elicitation action");
     }
     const normalizedContent = normalizedAction === "accept" ? normalizeResponseContent(content) : null;
@@ -22075,7 +21402,6 @@ var ElicitationStore = class {
     request.status = "resolved";
     request.response_action = normalizedAction;
     request.response_content = normalizedContent;
-    request.resolved_by = normalizeResolvedBy(resolvedBy);
     return this.saveRequest(request);
   }
   async markExpired(requestID) {
@@ -22087,10 +21413,8 @@ var ElicitationStore = class {
     return this.saveRequest(request);
   }
   async getStatus() {
-    const names = await listJSONFiles2(this.requestsDir);
+    const names = await listJSONFiles(this.requestsDir);
     let pendingCount = 0;
-    let resolvedCount = 0;
-    let expiredCount = 0;
     for (const name of names) {
       const request = await this.getRequest(name.replace(/\.json$/u, ""));
       if (!request) {
@@ -22098,16 +21422,10 @@ var ElicitationStore = class {
       }
       if (request.status === "pending") {
         pendingCount += 1;
-      } else if (request.status === "resolved") {
-        resolvedCount += 1;
-      } else if (request.status === "expired") {
-        expiredCount += 1;
       }
     }
     return {
-      pending_count: pendingCount,
-      resolved_count: resolvedCount,
-      expired_count: expiredCount
+      pending_count: pendingCount
     };
   }
 };
@@ -22115,15 +21433,14 @@ var ElicitationStore = class {
 // server/event-state.js
 var defaultTTLMS = 30 * 60 * 1e3;
 var defaultPendingTTLMS = 48 * 60 * 60 * 1e3;
-var defaultPairingCooldownMs = 60 * 1e3;
-function normalizeString8(value) {
+function normalizeString6(value) {
   return String(value ?? "").trim();
 }
 function normalizeStringArray2(value) {
   if (!Array.isArray(value)) {
     return [];
   }
-  return value.map((item) => normalizeString8(item)).filter((item) => item);
+  return value.map((item) => normalizeString6(item)).filter((item) => item);
 }
 function cloneEntry(entry) {
   return entry ? JSON.parse(JSON.stringify(entry)) : null;
@@ -22132,12 +21449,10 @@ var EventState = class {
   constructor({
     ttlMs = defaultTTLMS,
     pendingTTLms = defaultPendingTTLMS,
-    pairingCooldownMs = defaultPairingCooldownMs,
     onChange = null
   } = {}) {
     this.ttlMs = ttlMs;
     this.pendingTTLms = pendingTTLms;
-    this.pairingCooldownMs = pairingCooldownMs;
     this.onChange = typeof onChange === "function" ? onChange : null;
     this.events = /* @__PURE__ */ new Map();
   }
@@ -22147,16 +21462,16 @@ var EventState = class {
     }
   }
   restore(rawEntry) {
-    const eventID = normalizeString8(rawEntry?.event_id);
+    const eventID = normalizeString6(rawEntry?.event_id);
     if (!eventID || this.events.has(eventID)) {
       return;
     }
     this.events.set(eventID, JSON.parse(JSON.stringify(rawEntry)));
   }
   registerInbound(payload) {
-    const eventID = normalizeString8(payload.event_id);
-    const sessionID = normalizeString8(payload.session_id);
-    const msgID = normalizeString8(payload.msg_id);
+    const eventID = normalizeString6(payload.event_id);
+    const sessionID = normalizeString6(payload.session_id);
+    const msgID = normalizeString6(payload.msg_id);
     if (!eventID || !sessionID || !msgID) {
       throw new Error("event_id, session_id, and msg_id are required");
     }
@@ -22174,26 +21489,25 @@ var EventState = class {
       event_id: eventID,
       session_id: sessionID,
       msg_id: msgID,
-      quoted_message_id: normalizeString8(payload.quoted_message_id),
-      sender_id: normalizeString8(payload.sender_id),
-      event_type: normalizeString8(payload.event_type),
-      session_type: normalizeString8(payload.session_type),
+      quoted_message_id: normalizeString6(payload.quoted_message_id),
+      sender_id: normalizeString6(payload.sender_id),
+      event_type: normalizeString6(payload.event_type),
+      session_type: normalizeString6(payload.session_type),
       content: String(payload.content ?? ""),
-      owner_id: normalizeString8(payload.owner_id),
-      agent_id: normalizeString8(payload.agent_id),
-      msg_type: normalizeString8(payload.msg_type),
+      owner_id: normalizeString6(payload.owner_id),
+      agent_id: normalizeString6(payload.agent_id),
+      msg_type: normalizeString6(payload.msg_type),
       message_created_at: Number(payload.message_created_at ?? payload.created_at ?? 0),
       mention_user_ids: normalizeStringArray2(payload.mention_user_ids),
       extra_json: String(payload.extra_json ?? ""),
       attachments_json: String(payload.attachments_json ?? ""),
-      attachment_count: normalizeString8(payload.attachment_count),
+      attachment_count: normalizeString6(payload.attachment_count),
       biz_card_json: String(payload.biz_card_json ?? ""),
       channel_data_json: String(payload.channel_data_json ?? ""),
+      context_messages_json: String(payload.context_messages_json ?? ""),
       acked: false,
       ack_at: 0,
       notification_dispatched_at: 0,
-      pairing_sent_at: 0,
-      pairing_retry_after: 0,
       result_deadline_at: 0,
       result_intent: null,
       completed: null,
@@ -22212,7 +21526,7 @@ var EventState = class {
     };
   }
   get(eventID) {
-    const existing = this.events.get(normalizeString8(eventID));
+    const existing = this.events.get(normalizeString6(eventID));
     if (!existing) {
       return null;
     }
@@ -22220,13 +21534,13 @@ var EventState = class {
     return cloneEntry(existing);
   }
   getLatestActiveBySession(sessionID) {
-    const normalizedSessionID = normalizeString8(sessionID);
+    const normalizedSessionID = normalizeString6(sessionID);
     if (!normalizedSessionID) {
       return null;
     }
     let latest = null;
     for (const entry of this.events.values()) {
-      if (normalizeString8(entry.session_id) !== normalizedSessionID) {
+      if (normalizeString6(entry.session_id) !== normalizedSessionID) {
         continue;
       }
       if (entry.internal_probe === true) {
@@ -22246,7 +21560,7 @@ var EventState = class {
     return cloneEntry(latest);
   }
   markAcked(eventID, { ackedAt = Date.now() } = {}) {
-    const entry = this.events.get(normalizeString8(eventID));
+    const entry = this.events.get(normalizeString6(eventID));
     if (!entry) {
       return null;
     }
@@ -22257,7 +21571,7 @@ var EventState = class {
     return cloneEntry(entry);
   }
   markNotificationDispatched(eventID, { dispatchedAt = Date.now() } = {}) {
-    const entry = this.events.get(normalizeString8(eventID));
+    const entry = this.events.get(normalizeString6(eventID));
     if (!entry) {
       return null;
     }
@@ -22266,29 +21580,8 @@ var EventState = class {
     this._notify(entry);
     return cloneEntry(entry);
   }
-  markPairingSent(eventID, { sentAt = Date.now(), cooldownMs = this.pairingCooldownMs } = {}) {
-    const entry = this.events.get(normalizeString8(eventID));
-    if (!entry) {
-      return null;
-    }
-    entry.pairing_sent_at = Math.floor(sentAt);
-    entry.pairing_retry_after = Math.floor(sentAt + cooldownMs);
-    entry.last_seen_at = Date.now();
-    this._notify(entry);
-    return cloneEntry(entry);
-  }
-  canResendPairing(eventID, now = Date.now()) {
-    const entry = this.events.get(normalizeString8(eventID));
-    if (!entry) {
-      return false;
-    }
-    if (!entry.pairing_sent_at) {
-      return true;
-    }
-    return now >= Number(entry.pairing_retry_after ?? 0);
-  }
   setResultDeadline(eventID, { deadlineAt } = {}) {
-    const entry = this.events.get(normalizeString8(eventID));
+    const entry = this.events.get(normalizeString6(eventID));
     if (!entry) {
       return null;
     }
@@ -22298,7 +21591,7 @@ var EventState = class {
     return cloneEntry(entry);
   }
   clearResultDeadline(eventID) {
-    const entry = this.events.get(normalizeString8(eventID));
+    const entry = this.events.get(normalizeString6(eventID));
     if (!entry) {
       return null;
     }
@@ -22308,14 +21601,14 @@ var EventState = class {
     return cloneEntry(entry);
   }
   setResultIntent(eventID, result) {
-    const entry = this.events.get(normalizeString8(eventID));
+    const entry = this.events.get(normalizeString6(eventID));
     if (!entry) {
       return null;
     }
     entry.result_intent = {
-      status: normalizeString8(result.status),
-      code: normalizeString8(result.code),
-      msg: normalizeString8(result.msg),
+      status: normalizeString6(result.status),
+      code: normalizeString6(result.code),
+      msg: normalizeString6(result.msg),
       updated_at: Number(result.updated_at ?? Date.now())
     };
     entry.last_seen_at = Date.now();
@@ -22323,7 +21616,7 @@ var EventState = class {
     return cloneEntry(entry);
   }
   clearResultIntent(eventID) {
-    const entry = this.events.get(normalizeString8(eventID));
+    const entry = this.events.get(normalizeString6(eventID));
     if (!entry) {
       return null;
     }
@@ -22333,16 +21626,16 @@ var EventState = class {
     return cloneEntry(entry);
   }
   markCompleted(eventID, result) {
-    const entry = this.events.get(normalizeString8(eventID));
+    const entry = this.events.get(normalizeString6(eventID));
     if (!entry) {
       return null;
     }
     entry.result_deadline_at = 0;
     entry.result_intent = null;
     entry.completed = {
-      status: normalizeString8(result.status),
-      code: normalizeString8(result.code),
-      msg: normalizeString8(result.msg),
+      status: normalizeString6(result.status),
+      code: normalizeString6(result.code),
+      msg: normalizeString6(result.msg),
       updated_at: Number(result.updated_at ?? Date.now())
     };
     entry.last_seen_at = Date.now();
@@ -22350,13 +21643,13 @@ var EventState = class {
     return cloneEntry(entry);
   }
   markStopped(eventID, stop) {
-    const entry = this.events.get(normalizeString8(eventID));
+    const entry = this.events.get(normalizeString6(eventID));
     if (!entry) {
       return null;
     }
     entry.stopped = {
-      stop_id: normalizeString8(stop.stop_id),
-      reason: normalizeString8(stop.reason),
+      stop_id: normalizeString6(stop.stop_id),
+      reason: normalizeString6(stop.reason),
       updated_at: Number(stop.updated_at ?? Date.now())
     };
     entry.last_seen_at = Date.now();
@@ -22373,11 +21666,38 @@ var EventState = class {
   }
 };
 
+// server/paths.js
+import os from "node:os";
+import path4 from "node:path";
+var defaultPluginID = "grix-claude";
+function sanitizePluginID(pluginID) {
+  return String(pluginID ?? defaultPluginID).trim().replace(/[^a-zA-Z0-9_-]+/g, "-").replace(/^-+|-+$/g, "") || defaultPluginID;
+}
+function resolvePluginDataDir(pluginID = defaultPluginID) {
+  const value = String(process.env.CLAUDE_PLUGIN_DATA ?? "").trim();
+  if (value) {
+    return value;
+  }
+  return path4.join(os.homedir(), ".claude", sanitizePluginID(pluginID));
+}
+function resolveConfigPath(pluginID = defaultPluginID) {
+  return path4.join(resolvePluginDataDir(pluginID), "grix-claude-config.json");
+}
+function resolveElicitationRequestsDir(pluginID = defaultPluginID) {
+  return path4.join(resolvePluginDataDir(pluginID), "elicitation-requests");
+}
+function resolveSessionContextsDir(pluginID = defaultPluginID) {
+  return path4.join(resolvePluginDataDir(pluginID), "session-contexts");
+}
+function resolveEventStatesDir(pluginID = defaultPluginID) {
+  return path4.join(resolvePluginDataDir(pluginID), "event-states");
+}
+
 // server/event-state-persistence.js
-import { mkdir as mkdir5, readdir as readdir3 } from "node:fs/promises";
-import path6 from "node:path";
-var schemaVersion4 = 1;
-function normalizeString9(value) {
+import { mkdir as mkdir4, readdir as readdir2 } from "node:fs/promises";
+import path5 from "node:path";
+var schemaVersion3 = 1;
+function normalizeString7(value) {
   return String(value ?? "").trim();
 }
 function normalizeResultField(input) {
@@ -22385,9 +21705,9 @@ function normalizeResultField(input) {
     return null;
   }
   return {
-    status: normalizeString9(input.status),
-    code: normalizeString9(input.code),
-    msg: normalizeString9(input.msg),
+    status: normalizeString7(input.status),
+    code: normalizeString7(input.code),
+    msg: normalizeString7(input.msg),
     updated_at: Number(input.updated_at ?? 0)
   };
 }
@@ -22396,46 +21716,45 @@ function normalizeStopField(input) {
     return null;
   }
   return {
-    stop_id: normalizeString9(input.stop_id),
-    reason: normalizeString9(input.reason),
+    stop_id: normalizeString7(input.stop_id),
+    reason: normalizeString7(input.reason),
     updated_at: Number(input.updated_at ?? 0)
   };
 }
 function normalizeEntry(input) {
-  if (!input || typeof input !== "object" || Number(input.schema_version) !== schemaVersion4) {
+  if (!input || typeof input !== "object" || Number(input.schema_version) !== schemaVersion3) {
     return null;
   }
-  const eventID = normalizeString9(input.event_id);
-  const sessionID = normalizeString9(input.session_id);
-  const msgID = normalizeString9(input.msg_id);
+  const eventID = normalizeString7(input.event_id);
+  const sessionID = normalizeString7(input.session_id);
+  const msgID = normalizeString7(input.msg_id);
   if (!eventID || !sessionID || !msgID) {
     return null;
   }
   return {
-    schema_version: schemaVersion4,
+    schema_version: schemaVersion3,
     event_id: eventID,
     session_id: sessionID,
     msg_id: msgID,
-    quoted_message_id: normalizeString9(input.quoted_message_id),
-    sender_id: normalizeString9(input.sender_id),
-    event_type: normalizeString9(input.event_type),
-    session_type: normalizeString9(input.session_type),
+    quoted_message_id: normalizeString7(input.quoted_message_id),
+    sender_id: normalizeString7(input.sender_id),
+    event_type: normalizeString7(input.event_type),
+    session_type: normalizeString7(input.session_type),
     content: String(input.content ?? ""),
-    owner_id: normalizeString9(input.owner_id),
-    agent_id: normalizeString9(input.agent_id),
-    msg_type: normalizeString9(input.msg_type),
+    owner_id: normalizeString7(input.owner_id),
+    agent_id: normalizeString7(input.agent_id),
+    msg_type: normalizeString7(input.msg_type),
     message_created_at: Number(input.message_created_at ?? 0),
-    mention_user_ids: Array.isArray(input.mention_user_ids) ? input.mention_user_ids.map((item) => normalizeString9(item)).filter((item) => item) : [],
+    mention_user_ids: Array.isArray(input.mention_user_ids) ? input.mention_user_ids.map((item) => normalizeString7(item)).filter((item) => item) : [],
     extra_json: String(input.extra_json ?? ""),
     attachments_json: String(input.attachments_json ?? ""),
-    attachment_count: normalizeString9(input.attachment_count),
+    attachment_count: normalizeString7(input.attachment_count),
     biz_card_json: String(input.biz_card_json ?? ""),
     channel_data_json: String(input.channel_data_json ?? ""),
+    context_messages_json: String(input.context_messages_json ?? ""),
     acked: input.acked === true,
     ack_at: Number(input.ack_at ?? 0),
     notification_dispatched_at: Number(input.notification_dispatched_at ?? 0),
-    pairing_sent_at: Number(input.pairing_sent_at ?? 0),
-    pairing_retry_after: Number(input.pairing_retry_after ?? 0),
     result_deadline_at: Number(input.result_deadline_at ?? 0),
     result_intent: normalizeResultField(input.result_intent),
     completed: normalizeResultField(input.completed),
@@ -22445,14 +21764,14 @@ function normalizeEntry(input) {
   };
 }
 async function saveEventEntry(dir, entry) {
-  await mkdir5(dir, { recursive: true });
-  const filePath = path6.join(dir, `${entry.event_id}.json`);
-  await writeJSONFileAtomic(filePath, { schema_version: schemaVersion4, ...entry });
+  await mkdir4(dir, { recursive: true });
+  const filePath = path5.join(dir, `${entry.event_id}.json`);
+  await writeJSONFileAtomic(filePath, { schema_version: schemaVersion3, ...entry });
 }
 async function loadEventEntries(dir, ttlMs) {
   let names;
   try {
-    names = await readdir3(dir);
+    names = await readdir2(dir);
   } catch (error2) {
     if (error2 && typeof error2 === "object" && "code" in error2 && error2.code === "ENOENT") {
       return [];
@@ -22465,7 +21784,7 @@ async function loadEventEntries(dir, ttlMs) {
     if (!name.endsWith(".json")) {
       continue;
     }
-    const filePath = path6.join(dir, name);
+    const filePath = path5.join(dir, name);
     const raw = await readJSONFile(filePath, null);
     const entry = normalizeEntry(raw);
     if (!entry) {
@@ -22483,7 +21802,7 @@ async function loadEventEntries(dir, ttlMs) {
 
 // server/logging.js
 import { appendFileSync } from "node:fs";
-function normalizeString10(value) {
+function normalizeString8(value) {
   return String(value ?? "").trim();
 }
 function formatTraceValue(value) {
@@ -22493,7 +21812,7 @@ function formatTraceValue(value) {
   if (typeof value === "number" || typeof value === "boolean") {
     return String(value);
   }
-  const text = normalizeString10(value);
+  const text = normalizeString8(value);
   if (!text) {
     return "";
   }
@@ -22503,7 +21822,7 @@ function formatTraceValue(value) {
   return JSON.stringify(text);
 }
 function listTraceEntries(fields) {
-  return Object.entries(fields).filter(([, value]) => value !== void 0 && value !== null && normalizeString10(value) !== "").sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey));
+  return Object.entries(fields).filter(([, value]) => value !== void 0 && value !== null && normalizeString8(value) !== "").sort(([leftKey], [rightKey]) => leftKey.localeCompare(rightKey));
 }
 function isTraceLoggingEnabled(env = process.env) {
   return env.GRIX_CLAUDE_TRACE_LOG === "1" || env.GRIX_CLAUDE_E2E_DEBUG === "1";
@@ -22524,7 +21843,7 @@ function createProcessLogger({
   onTrace = null
 } = {}) {
   const verboseDebugEnabled = env.GRIX_CLAUDE_E2E_DEBUG === "1";
-  const verboseDebugLogPath = normalizeString10(env.GRIX_CLAUDE_E2E_DEBUG_LOG);
+  const verboseDebugLogPath = normalizeString8(env.GRIX_CLAUDE_E2E_DEBUG_LOG);
   const traceCallback = typeof onTrace === "function" ? onTrace : null;
   function write(prefix, message) {
     if (verboseDebugLogPath) {
@@ -22572,7 +21891,7 @@ function createProcessLogger({
 }
 
 // server/session-activity-dispatcher.js
-function normalizeString11(value) {
+function normalizeString9(value) {
   return String(value ?? "").trim();
 }
 function buildSessionActivityDispatchKey({
@@ -22581,10 +21900,10 @@ function buildSessionActivityDispatchKey({
   refEventID = "",
   refMsgID = ""
 } = {}) {
-  const normalizedSessionID = normalizeString11(sessionID);
-  const normalizedKind = normalizeString11(kind) || "composing";
-  const normalizedRefEventID = normalizeString11(refEventID);
-  const normalizedRefMsgID = normalizeString11(refMsgID);
+  const normalizedSessionID = normalizeString9(sessionID);
+  const normalizedKind = normalizeString9(kind) || "composing";
+  const normalizedRefEventID = normalizeString9(refEventID);
+  const normalizedRefMsgID = normalizeString9(refMsgID);
   if (normalizedRefEventID) {
     return `event:${normalizedRefEventID}`;
   }
@@ -22616,12 +21935,15 @@ function createSessionActivityDispatcher(sendFn) {
 }
 
 // server/hook-signal-store.js
-import { appendFile, mkdir as mkdir6 } from "node:fs/promises";
-import path7 from "node:path";
+import { appendFile, mkdir as mkdir5, open, rm, stat } from "node:fs/promises";
+import path6 from "node:path";
 import { randomUUID as randomUUID2 } from "node:crypto";
-var schemaVersion5 = 1;
+var schemaVersion4 = 1;
 var defaultRecentEventLimit = 20;
-function normalizeString12(value) {
+var defaultLockTimeoutMs = 5e3;
+var defaultLockPollMs = 25;
+var defaultLockStaleMs = 3e4;
+function normalizeString10(value) {
   return String(value ?? "").trim();
 }
 function normalizeOptionalTimestamp(value) {
@@ -22633,16 +21955,25 @@ function normalizeOptionalTimestamp(value) {
 }
 function pickHookEventDetail(input = {}, hookEventName) {
   if (hookEventName === "SessionStart") {
-    return normalizeString12(input.source);
+    return normalizeString10(input.source);
+  }
+  if (hookEventName === "PermissionRequest") {
+    return normalizeString10(input.tool_name);
   }
   if (hookEventName === "PostToolUse" || hookEventName === "PostToolUseFailure") {
-    return normalizeString12(input.tool_name);
+    return normalizeString10(input.tool_name);
+  }
+  if (hookEventName === "PermissionDenied") {
+    return normalizeString10(input.tool_name) || normalizeString10(input.reason);
   }
   if (hookEventName === "Elicitation") {
-    return normalizeString12(input.mode);
+    return normalizeString10(input.mode);
+  }
+  if (hookEventName === "ElicitationResult") {
+    return normalizeString10(input.action) || normalizeString10(input.mode);
   }
   if (hookEventName === "Notification") {
-    return normalizeString12(input.matcher) || normalizeString12(input.notification_type) || normalizeString12(input.type);
+    return normalizeString10(input.matcher) || normalizeString10(input.notification_type) || normalizeString10(input.type);
   }
   return "";
 }
@@ -22650,8 +21981,8 @@ function normalizeHookSignalEvent(input) {
   if (!input || typeof input !== "object") {
     return null;
   }
-  const hookEventName = normalizeString12(input.hook_event_name);
-  const eventID = normalizeString12(input.event_id);
+  const hookEventName = normalizeString10(input.hook_event_name);
+  const eventID = normalizeString10(input.event_id);
   if (!hookEventName || !eventID) {
     return null;
   }
@@ -22659,42 +21990,58 @@ function normalizeHookSignalEvent(input) {
     event_id: eventID,
     hook_event_name: hookEventName,
     event_at: normalizeOptionalTimestamp(input.event_at),
-    detail: normalizeString12(input.detail),
-    tool_name: normalizeString12(input.tool_name),
-    session_id: normalizeString12(input.session_id),
-    cwd: normalizeString12(input.cwd),
-    transcript_path: normalizeString12(input.transcript_path)
+    detail: normalizeString10(input.detail)
   };
 }
 function normalizeState(input) {
   const empty = {
-    schema_version: schemaVersion5,
+    schema_version: schemaVersion4,
     updated_at: 0,
     latest_event: null,
     recent_events: []
   };
-  if (!input || typeof input !== "object" || Number(input.schema_version) !== schemaVersion5) {
+  if (!input || typeof input !== "object" || Number(input.schema_version) !== schemaVersion4) {
     return empty;
   }
   return {
-    schema_version: schemaVersion5,
+    schema_version: schemaVersion4,
     updated_at: normalizeOptionalTimestamp(input.updated_at),
     latest_event: normalizeHookSignalEvent(input.latest_event),
     recent_events: Array.isArray(input.recent_events) ? input.recent_events.map((item) => normalizeHookSignalEvent(item)).filter(Boolean) : []
   };
 }
 function resolveHookSignalsPath(pluginID) {
-  return path7.join(resolvePluginDataDir(pluginID), "hook-signals.json");
+  return path6.join(resolvePluginDataDir(pluginID), "hook-signals.json");
 }
 function resolveHookSignalsPathFromDataDir(pluginDataDir, pluginID) {
-  const normalizedDir = normalizeString12(pluginDataDir);
+  const normalizedDir = normalizeString10(pluginDataDir);
   if (normalizedDir) {
-    return path7.join(normalizedDir, "hook-signals.json");
+    return path6.join(normalizedDir, "hook-signals.json");
   }
   return resolveHookSignalsPath(pluginID);
 }
+function resolveHookSignalsLockPathFromDataDir(pluginDataDir, pluginID) {
+  const normalizedDir = normalizeString10(pluginDataDir);
+  if (normalizedDir) {
+    return path6.join(normalizedDir, "hook-signals.lock");
+  }
+  return path6.join(resolvePluginDataDir(pluginID), "hook-signals.lock");
+}
+function sleep(delayMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+  });
+}
+async function readLockAgeMs(filePath) {
+  try {
+    const details = await stat(filePath);
+    return Date.now() - Number(details.mtimeMs ?? 0);
+  } catch {
+    return 0;
+  }
+}
 function buildHookSignalEvent(input, { recordedAt = Date.now() } = {}) {
-  const hookEventName = normalizeString12(input?.hook_event_name);
+  const hookEventName = normalizeString10(input?.hook_event_name);
   if (!hookEventName) {
     return null;
   }
@@ -22702,46 +22049,87 @@ function buildHookSignalEvent(input, { recordedAt = Date.now() } = {}) {
     event_id: randomUUID2(),
     hook_event_name: hookEventName,
     event_at: normalizeOptionalTimestamp(recordedAt) || Date.now(),
-    detail: pickHookEventDetail(input, hookEventName),
-    tool_name: normalizeString12(input?.tool_name),
-    session_id: normalizeString12(input?.session_id),
-    cwd: normalizeString12(input?.cwd),
-    transcript_path: normalizeString12(input?.transcript_path)
+    detail: pickHookEventDetail(input, hookEventName)
   };
 }
 var HookSignalStore = class {
-  constructor(filePath = resolveHookSignalsPath(), { logPath = path7.join(path7.dirname(filePath), "hook-signals.log") } = {}) {
+  constructor(filePath = resolveHookSignalsPath(), {
+    logPath = path6.join(path6.dirname(filePath), "hook-signals.log"),
+    lockPath = resolveHookSignalsLockPathFromDataDir(path6.dirname(filePath))
+  } = {}) {
     this.filePath = filePath;
     this.logPath = logPath;
+    this.lockPath = lockPath;
   }
   async readState() {
     const stored = await readJSONFile(this.filePath, null);
     return normalizeState(stored);
   }
   async writeState(state) {
-    await mkdir6(path7.dirname(this.filePath), { recursive: true });
+    await mkdir5(path6.dirname(this.filePath), { recursive: true });
     await writeJSONFileAtomic(this.filePath, normalizeState(state));
   }
+  async withStateLock(callback, {
+    timeoutMs = defaultLockTimeoutMs,
+    pollMs = defaultLockPollMs,
+    staleMs = defaultLockStaleMs
+  } = {}) {
+    await mkdir5(path6.dirname(this.lockPath), { recursive: true });
+    const deadlineAt = Date.now() + Math.max(1, Number(timeoutMs) || defaultLockTimeoutMs);
+    while (Date.now() < deadlineAt) {
+      let handle = null;
+      try {
+        handle = await open(this.lockPath, "wx", 384);
+        await handle.writeFile(JSON.stringify({
+          schema_version: schemaVersion4,
+          pid: process.pid,
+          acquired_at: Date.now()
+        }), "utf8");
+        try {
+          return await callback();
+        } finally {
+          await handle.close().catch(() => {
+          });
+          await rm(this.lockPath, { force: true }).catch(() => {
+          });
+        }
+      } catch (error2) {
+        if (!error2 || typeof error2 !== "object" || !("code" in error2) || error2.code !== "EEXIST") {
+          if (handle) {
+            await handle.close().catch(() => {
+            });
+          }
+          throw error2;
+        }
+        const lockAgeMs = await readLockAgeMs(this.lockPath);
+        if (lockAgeMs > staleMs) {
+          await rm(this.lockPath, { force: true }).catch(() => {
+          });
+          continue;
+        }
+        await sleep(Math.min(pollMs, Math.max(1, deadlineAt - Date.now())));
+      }
+    }
+    throw new Error("hook signal store lock timeout");
+  }
   async reset() {
-    await this.writeState(normalizeState(null));
-    return this.readState();
+    return this.withStateLock(async () => {
+      await this.writeState(normalizeState(null));
+      return this.readState();
+    });
   }
   async appendEventLog(event) {
     const normalized = normalizeHookSignalEvent(event);
     if (!normalized) {
       return false;
     }
-    await mkdir6(path7.dirname(this.logPath), { recursive: true });
+    await mkdir5(path6.dirname(this.logPath), { recursive: true });
     await appendFile(this.logPath, `${formatTraceLine({
       stage: "hook_signal_recorded",
       event_id: normalized.event_id,
       hook_event_name: normalized.hook_event_name,
       hook_detail: normalized.detail,
-      event_at: normalized.event_at,
-      tool_name: normalized.tool_name,
-      session_id: normalized.session_id,
-      cwd: normalized.cwd,
-      transcript_path: normalized.transcript_path
+      event_at: normalized.event_at
     })}
 `, "utf8");
     return true;
@@ -22754,30 +22142,34 @@ var HookSignalStore = class {
     if (!nextEvent) {
       return this.readState();
     }
-    const current = await this.readState();
-    const nextState = {
-      schema_version: schemaVersion5,
-      updated_at: nextEvent.event_at,
-      latest_event: nextEvent,
-      recent_events: [
+    return this.withStateLock(async () => {
+      const current = await this.readState();
+      const recentEvents = [
         ...current.recent_events,
         nextEvent
-      ].slice(-Math.max(1, Number(recentEventLimit) || defaultRecentEventLimit))
-    };
-    await this.writeState(nextState);
-    await this.appendEventLog(nextEvent);
-    return normalizeState(nextState);
+      ].sort((left, right) => left.event_at - right.event_at).slice(-Math.max(1, Number(recentEventLimit) || defaultRecentEventLimit));
+      const latestEvent = !current.latest_event || nextEvent.event_at >= current.updated_at ? nextEvent : current.latest_event;
+      const nextState = {
+        schema_version: schemaVersion4,
+        updated_at: Math.max(current.updated_at, nextEvent.event_at),
+        latest_event: latestEvent,
+        recent_events: recentEvents
+      };
+      await this.writeState(nextState);
+      await this.appendEventLog(nextEvent);
+      return normalizeState(nextState);
+    });
   }
 };
 
 // server/worker/worker-bridge-client.js
-function normalizeString13(value) {
+function normalizeString11(value) {
   return String(value ?? "").trim();
 }
 function buildHeaders(token) {
   return {
     "content-type": "application/json",
-    authorization: `Bearer ${normalizeString13(token)}`
+    authorization: `Bearer ${normalizeString11(token)}`
   };
 }
 async function parseJSONResponse(response) {
@@ -22793,8 +22185,8 @@ async function parseJSONResponse(response) {
 }
 var WorkerBridgeClient = class {
   constructor({ bridgeURL, token, fetchImpl = globalThis.fetch } = {}) {
-    this.bridgeURL = normalizeString13(bridgeURL).replace(/\/+$/u, "");
-    this.token = normalizeString13(token);
+    this.bridgeURL = normalizeString11(bridgeURL).replace(/\/+$/u, "");
+    this.token = normalizeString11(token);
     this.fetchImpl = fetchImpl;
   }
   isConfigured() {
@@ -22811,7 +22203,7 @@ var WorkerBridgeClient = class {
     });
     const json2 = await parseJSONResponse(response);
     if (!response.ok) {
-      throw new Error(normalizeString13(json2.error) || `bridge request failed ${response.status}`);
+      throw new Error(normalizeString11(json2.error) || `bridge request failed ${response.status}`);
     }
     return json2;
   }
@@ -22845,20 +22237,26 @@ var WorkerBridgeClient = class {
   async setSessionComposing(payload) {
     return this.post("/v1/worker/session-composing", payload);
   }
+  async agentInvoke(payload) {
+    return this.post("/v1/worker/agent-invoke", payload);
+  }
+  async sendLocalActionResult(payload) {
+    return this.post("/v1/worker/local-action-result", payload);
+  }
 };
 
 // server/worker/inbound-bridge-server.js
 import http from "node:http";
 import { randomUUID as randomUUID3 } from "node:crypto";
-function normalizeString14(value) {
+function normalizeString12(value) {
   return String(value ?? "").trim();
 }
 function parseBearerToken(request) {
-  const header = normalizeString14(request.headers.authorization);
+  const header = normalizeString12(request.headers.authorization);
   if (!header.toLowerCase().startsWith("bearer ")) {
     return "";
   }
-  return normalizeString14(header.slice("bearer ".length));
+  return normalizeString12(header.slice("bearer ".length));
 }
 async function readJSONBody(request) {
   const chunks = [];
@@ -22880,6 +22278,7 @@ var WorkerInboundBridgeServer = class {
     onDeliverEvent = null,
     onDeliverStop = null,
     onDeliverRevoke = null,
+    onDeliverLocalAction = null,
     onPing = null
   } = {}) {
     this.host = host;
@@ -22888,6 +22287,7 @@ var WorkerInboundBridgeServer = class {
     this.onDeliverEvent = typeof onDeliverEvent === "function" ? onDeliverEvent : null;
     this.onDeliverStop = typeof onDeliverStop === "function" ? onDeliverStop : null;
     this.onDeliverRevoke = typeof onDeliverRevoke === "function" ? onDeliverRevoke : null;
+    this.onDeliverLocalAction = typeof onDeliverLocalAction === "function" ? onDeliverLocalAction : null;
     this.onPing = typeof onPing === "function" ? onPing : null;
     this.server = null;
     this.address = null;
@@ -22927,6 +22327,8 @@ var WorkerInboundBridgeServer = class {
     const current = this.server;
     this.server = null;
     this.address = null;
+    current.closeIdleConnections?.();
+    current.closeAllConnections?.();
     await new Promise((resolve, reject) => {
       current.close((error2) => {
         if (error2) {
@@ -22946,7 +22348,7 @@ var WorkerInboundBridgeServer = class {
       writeJSON(response, 405, { error: "method_not_allowed" });
       return;
     }
-    const pathname = normalizeString14(new URL(request.url, "http://localhost").pathname);
+    const pathname = normalizeString12(new URL(request.url, "http://localhost").pathname);
     const payload = await readJSONBody(request);
     if (pathname === "/v1/worker/deliver-event") {
       if (!this.onDeliverEvent) {
@@ -22975,6 +22377,15 @@ var WorkerInboundBridgeServer = class {
       writeJSON(response, 200, result ?? { ok: true });
       return;
     }
+    if (pathname === "/v1/worker/deliver-local-action") {
+      if (!this.onDeliverLocalAction) {
+        writeJSON(response, 200, { ok: true });
+        return;
+      }
+      const result = await this.onDeliverLocalAction(payload);
+      writeJSON(response, 200, result ?? { ok: true });
+      return;
+    }
     if (pathname === "/v1/worker/ping") {
       if (!this.onPing) {
         writeJSON(response, 200, {
@@ -22995,11 +22406,11 @@ var WorkerInboundBridgeServer = class {
 };
 
 // server/worker/bridge-runtime.js
-function normalizeString15(value) {
+function normalizeString13(value) {
   return String(value ?? "").trim();
 }
 function normalizeOptionalString(value) {
-  const normalized = normalizeString15(value);
+  const normalized = normalizeString13(value);
   return normalized || "";
 }
 var DaemonBridgeRuntime = class {
@@ -23008,7 +22419,8 @@ var DaemonBridgeRuntime = class {
     logger,
     onDeliverEvent = null,
     onDeliverStop = null,
-    onDeliverRevoke = null
+    onDeliverRevoke = null,
+    onDeliverLocalAction = null
   } = {}) {
     this.env = env;
     this.logger = logger;
@@ -23067,6 +22479,20 @@ var DaemonBridgeRuntime = class {
         this.markMcpActivity();
         return { ok: true };
       },
+      onDeliverLocalAction: async (input) => {
+        this.logger?.trace?.({
+          component: "worker.bridge",
+          stage: "deliver_local_action_received",
+          action_id: input?.payload?.action_id,
+          action_type: input?.payload?.action_type,
+          event_id: input?.payload?.event_id
+        });
+        if (typeof onDeliverLocalAction === "function") {
+          await onDeliverLocalAction(input?.payload ?? {});
+        }
+        this.markMcpActivity();
+        return { ok: true };
+      },
       onPing: async () => {
         const hookSignalState = await this.hookSignalStore.readState();
         return {
@@ -23138,7 +22564,7 @@ var DaemonBridgeRuntime = class {
     const hints = [
       "This worker is managed by grix-claude daemon.",
       "Use the daemon CLI to change ws_url, agent_id, or api_key.",
-      "Send open <\u76EE\u5F55> from Grix to let daemon start or recover a Claude session."
+      "Ask Grix to bind a working directory for this chat before sending Claude requests."
     ];
     if (!this.isDaemonBridgeActive()) {
       hints.unshift("This worker must be started by grix-claude daemon.");
@@ -23297,6 +22723,62 @@ var DaemonBridgeRuntime = class {
     this.markMcpActivity();
     return response;
   }
+  async agentInvoke({
+    invokeID = "",
+    action,
+    params = {},
+    timeoutMs = 15e3
+  } = {}) {
+    this.requireDaemonBridge();
+    this.logger?.trace?.({
+      component: "worker.bridge",
+      stage: "agent_invoke_requested",
+      invoke_id: invokeID,
+      action
+    });
+    const response = await this.workerBridgeClient.agentInvoke({
+      ...this.buildWorkerIdentityPayload(),
+      invoke_id: normalizeOptionalString(invokeID),
+      action: normalizeOptionalString(action),
+      params: params && typeof params === "object" && !Array.isArray(params) ? params : {},
+      timeout_ms: Number.isFinite(Number(timeoutMs)) && Number(timeoutMs) > 0 ? Math.floor(Number(timeoutMs)) : 15e3
+    });
+    this.markMcpActivity();
+    return response;
+  }
+  async sendLocalActionResult({
+    actionID,
+    status,
+    result,
+    errorCode = "",
+    errorMsg = ""
+  } = {}) {
+    this.requireDaemonBridge();
+    this.logger?.trace?.({
+      component: "worker.bridge",
+      stage: "local_action_result_requested",
+      action_id: actionID,
+      status,
+      error_code: errorCode
+    });
+    const payload = {
+      ...this.buildWorkerIdentityPayload(),
+      action_id: normalizeOptionalString(actionID),
+      status: normalizeOptionalString(status)
+    };
+    if (arguments[0] && Object.prototype.hasOwnProperty.call(arguments[0], "result")) {
+      payload.result = result;
+    }
+    if (normalizeOptionalString(errorCode)) {
+      payload.error_code = normalizeOptionalString(errorCode);
+    }
+    if (normalizeOptionalString(errorMsg)) {
+      payload.error_msg = normalizeOptionalString(errorMsg);
+    }
+    const response = await this.workerBridgeClient.sendLocalActionResult(payload);
+    this.markMcpActivity();
+    return response;
+  }
   async setSessionComposing({
     sessionID,
     kind = "composing",
@@ -23378,341 +22860,46 @@ var DaemonBridgeRuntime = class {
         aibot_session_id: this.env.GRIX_CLAUDE_AIBOT_SESSION_ID,
         worker_id: this.env.GRIX_CLAUDE_WORKER_ID,
         status: "ready"
-      });
-      await this.workerBridgeClient.sendStatusUpdate({
-        ...this.buildWorkerIdentityPayload(),
-        worker_control_url: this.getWorkerControlURL(),
-        worker_control_token: this.getWorkerControlToken(),
-        status: "ready"
-      });
-      this.markMcpActivity();
-      this.workerReadyReported = true;
-      this.logger?.info?.("worker ready after MCP tools handshake");
-    })();
-    try {
-      await this.workerReadyPromise;
-    } finally {
-      this.workerReadyPromise = null;
-    }
-  }
-  async shutdown() {
-    if (!this.daemonModeEnabled || !this.workerBridgeClient.isConfigured()) {
-      return;
-    }
-    try {
-      await this.stopControlServer();
-      await this.workerBridgeClient.sendStatusUpdate({
-        ...this.buildWorkerIdentityPayload(),
-        status: "stopped"
-      });
-      this.markMcpActivity();
-    } catch (error2) {
-      this.logger?.error?.(`worker bridge stop update failed: ${String(error2)}`);
-    }
-  }
-};
-
-// server/permission-relay-text.js
-function normalizeString16(value) {
-  return String(value ?? "").trim();
-}
-function truncateText(value, maxLength = 240) {
-  const normalized = normalizeString16(value);
-  if (!normalized) {
-    return "";
-  }
-  if (normalized.length <= maxLength) {
-    return normalized;
-  }
-  return `${normalized.slice(0, maxLength - 3)}...`;
-}
-function buildPermissionRelayCommandText(request) {
-  const toolName = normalizeString16(request?.tool_name) || "unknown";
-  const description = truncateText(request?.description, 200);
-  const inputPreview = truncateText(request?.input_preview, 240);
-  const lines = [
-    `Tool: ${toolName}`,
-    description ? `Description: ${description}` : "",
-    inputPreview ? `Input: ${inputPreview}` : ""
-  ].filter(Boolean);
-  return lines.join("\n");
-}
-function buildPermissionRelayRequestText(request) {
-  const requestID = normalizeString16(request?.request_id);
-  const commandText = buildPermissionRelayCommandText(request);
-  const lines = [
-    "Claude needs permission to continue this Grix turn.",
-    `Request ID: ${requestID}`,
-    commandText,
-    `Reply "yes ${requestID}" to allow once, or "no ${requestID}" to deny.`
-  ].filter(Boolean);
-  return lines.join("\n");
-}
-function buildPermissionRelayVerdictText({ requestID, behavior }) {
-  const normalizedRequestID = normalizeString16(requestID);
-  const normalizedBehavior = normalizeString16(behavior);
-  if (normalizedBehavior === "allow") {
-    return `Allow reply for request ${normalizedRequestID} sent to Claude.`;
-  }
-  return `Deny reply for request ${normalizedRequestID} sent to Claude.`;
-}
-
-// server/elicitation-text.js
-function normalizeString17(value) {
-  return String(value ?? "").trim();
-}
-function formatOptions(question) {
-  if (!Array.isArray(question?.options) || question.options.length === 0) {
-    return [];
-  }
-  const labels = question.options.map((option) => normalizeString17(option?.label)).filter(Boolean);
-  if (labels.length === 0) {
-    return [];
-  }
-  return [
-    `   Options: ${labels.join(" | ")}`
-  ];
-}
-function buildElicitationFooterText() {
-  return "Use the card to answer. Free text is allowed when none of the listed options fit.";
-}
-function buildElicitationRequestText(request) {
-  const lines = [
-    "Claude needs more input to continue this Grix turn."
-  ];
-  const message = normalizeString17(request?.message);
-  if (message) {
-    lines.push(message);
-  }
-  const questions = Array.isArray(request?.questions) ? request.questions : [];
-  questions.forEach((question, index) => {
-    const header = normalizeString17(question?.header) || `Question ${index + 1}`;
-    const prompt = normalizeString17(question?.question) || "(missing question text)";
-    lines.push(`${index + 1}. ${header}`);
-    lines.push(`   ${prompt}`);
-    lines.push(...formatOptions(question));
-    if (question?.multiSelect === true) {
-      lines.push("   Multiple selections: join values with commas.");
-    }
-  });
-  lines.push(buildElicitationFooterText());
-  return lines.join("\n");
-}
-function buildElicitationResponseText({ requestID }) {
-  return `Input request ${requestID} answers recorded.`;
-}
-
-// server/message-card-envelope.js
-var currentVersion = 1;
-function buildMessageCardEnvelope(type, payload) {
-  return {
-    version: currentVersion,
-    type,
-    payload
-  };
-}
-
-// server/claude-card-payload.js
-var claudeHostLabel = "Claude Grix";
-var pairingCommandHint = "/grix:access pair <code>";
-function normalizeString18(value) {
-  return String(value ?? "").trim();
-}
-function normalizeQuestionOptions(question) {
-  if (!Array.isArray(question?.options)) {
-    return [];
-  }
-  return question.options.map((option) => normalizeString18(option?.label)).filter(Boolean);
-}
-function buildPermissionRelayRequestBizCard(request, { expiresAtMs } = {}) {
-  const requestID = normalizeString18(request?.request_id);
-  const payload = {
-    approval_id: requestID,
-    approval_slug: requestID,
-    approval_command_id: requestID,
-    command: buildPermissionRelayCommandText(request),
-    host: claudeHostLabel,
-    allowed_decisions: ["allow-once", "deny"],
-    decision_commands: {
-      "allow-once": `yes ${requestID}`,
-      deny: `no ${requestID}`
-    }
-  };
-  if (expiresAtMs > 0) {
-    payload.expires_at_ms = expiresAtMs;
-    payload.expires_in_seconds = Math.max(0, Math.floor((expiresAtMs - Date.now()) / 1e3));
-  }
-  return buildMessageCardEnvelope("exec_approval", payload);
-}
-function buildApprovalCommandStatusBizCard({
-  summary,
-  referenceID = "",
-  detailText = "",
-  status = "warning"
-}) {
-  return buildMessageCardEnvelope("claude_status", {
-    category: "approval",
-    status,
-    summary: normalizeString18(summary),
-    detail_text: normalizeString18(detailText),
-    reference_id: normalizeString18(referenceID)
-  });
-}
-function buildPermissionRelaySubmittedBizCard({
-  request,
-  behavior,
-  resolvedByID = ""
-}) {
-  const normalizedBehavior = normalizeString18(behavior) === "allow" ? "allow" : "deny";
-  return buildMessageCardEnvelope("exec_status", {
-    status: "approval-forwarded",
-    summary: buildPermissionRelayVerdictText({
-      requestID: request?.request_id,
-      behavior: normalizedBehavior
-    }),
-    detail_text: normalizedBehavior === "allow" ? "Decision: allow-once" : "Decision: deny",
-    approval_id: normalizeString18(request?.request_id),
-    approval_command_id: normalizeString18(request?.request_id),
-    host: claudeHostLabel,
-    decision: normalizedBehavior === "allow" ? "allow-once" : "deny",
-    resolved_by_id: normalizeString18(resolvedByID),
-    command: buildPermissionRelayCommandText(request),
-    channel_label: claudeHostLabel
-  });
-}
-function buildQuestionRequestBizCard(request) {
-  const questions = Array.isArray(request?.questions) ? request.questions : [];
-  return buildMessageCardEnvelope("claude_question", {
-    request_id: normalizeString18(request?.request_id),
-    questions: questions.map((question, index) => ({
-      index: index + 1,
-      header: normalizeString18(question?.header) || `Question ${index + 1}`,
-      prompt: normalizeString18(question?.question) || "(missing question text)",
-      options: normalizeQuestionOptions(question),
-      multi_select: question?.multiSelect === true
-    })),
-    answer_command_hint: "",
-    footer_text: buildElicitationFooterText()
-  });
-}
-function buildQuestionStatusBizCard({
-  summary,
-  referenceID = "",
-  detailText = "",
-  status = "warning"
-}) {
-  return buildMessageCardEnvelope("claude_status", {
-    category: "question",
-    status,
-    summary: normalizeString18(summary),
-    detail_text: normalizeString18(detailText),
-    reference_id: normalizeString18(referenceID)
-  });
-}
-function buildAccessStatusBizCard({
-  summary,
-  detailText = "",
-  status = "info",
-  referenceID = ""
-}) {
-  return buildMessageCardEnvelope("claude_status", {
-    category: "access",
-    status,
-    summary: normalizeString18(summary),
-    detail_text: normalizeString18(detailText),
-    reference_id: normalizeString18(referenceID)
-  });
-}
-function buildPairingBizCard(pairingCode) {
-  return buildMessageCardEnvelope("claude_pairing", {
-    pairing_code: normalizeString18(pairingCode),
-    instruction_text: `Ask the Claude Code user to run ${pairingCommandHint} with this code to approve the sender.`,
-    command_hint: pairingCommandHint
-  });
-}
-
-// server/question-command.js
-var usageText = [
-  "usage:",
-  "/grix-question <request_id> <answer>",
-  "/grix-question <request_id> 1=first answer; 2=second answer"
-].join("\n");
-function normalizeString19(value) {
-  return String(value ?? "").trim();
-}
-function buildInvalidResult(error2) {
-  return {
-    matched: true,
-    ok: false,
-    error: `${error2}
-${usageText}`
-  };
-}
-function parseMappedAnswers(payload) {
-  const entries = [];
-  for (const segment of payload.split(";")) {
-    const trimmed = normalizeString19(segment);
-    if (!trimmed) {
-      continue;
+      });
+      await this.workerBridgeClient.sendStatusUpdate({
+        ...this.buildWorkerIdentityPayload(),
+        worker_control_url: this.getWorkerControlURL(),
+        worker_control_token: this.getWorkerControlToken(),
+        status: "ready"
+      });
+      this.markMcpActivity();
+      this.workerReadyReported = true;
+      this.logger?.info?.("worker ready after MCP tools handshake");
+    })();
+    try {
+      await this.workerReadyPromise;
+    } finally {
+      this.workerReadyPromise = null;
     }
-    const separatorIndex = trimmed.indexOf("=");
-    if (separatorIndex <= 0) {
-      return null;
+  }
+  async shutdown() {
+    if (!this.daemonModeEnabled || !this.workerBridgeClient.isConfigured()) {
+      return;
     }
-    const key = normalizeString19(trimmed.slice(0, separatorIndex));
-    const value = normalizeString19(trimmed.slice(separatorIndex + 1));
-    if (!key || !value) {
-      return null;
+    try {
+      await this.stopControlServer();
+      await this.workerBridgeClient.sendStatusUpdate({
+        ...this.buildWorkerIdentityPayload(),
+        status: "stopped"
+      });
+      this.markMcpActivity();
+    } catch (error2) {
+      this.logger?.error?.(`worker bridge stop update failed: ${String(error2)}`);
     }
-    entries.push({ key, value });
-  }
-  return entries.length > 0 ? entries : null;
-}
-function parseQuestionResponseCommand(text) {
-  const trimmed = normalizeString19(text);
-  if (!trimmed.startsWith("/grix-question")) {
-    return {
-      matched: false
-    };
-  }
-  const parts = trimmed.split(/\s+/u);
-  if (parts.length < 3) {
-    return buildInvalidResult("missing request_id or answer");
-  }
-  const requestID = normalizeString19(parts[1]);
-  const answerPayload = normalizeString19(trimmed.slice(trimmed.indexOf(requestID) + requestID.length));
-  if (!requestID || !answerPayload) {
-    return buildInvalidResult("missing request_id or answer");
   }
-  const responseText = normalizeString19(answerPayload);
-  if (!responseText) {
-    return buildInvalidResult("missing answer");
-  }
-  const usesIndexedFormat = /^[1-9][0-9]*\s*=/u.test(responseText) || responseText.includes(";");
-  const mappedAnswers = usesIndexedFormat ? parseMappedAnswers(responseText) : null;
-  if (usesIndexedFormat && !mappedAnswers) {
-    return buildInvalidResult("invalid indexed answer format");
-  }
-  return {
-    matched: true,
-    ok: true,
-    request_id: requestID,
-    response: mappedAnswers ? {
-      type: "map",
-      entries: mappedAnswers
-    } : {
-      type: "single",
-      value: responseText
-    }
-  };
-}
+};
 
 // server/elicitation-response.js
-function normalizeString20(value) {
+function normalizeString14(value) {
   return String(value ?? "").trim();
 }
 function parseBooleanValue(value) {
-  const normalized = normalizeString20(value).toLowerCase();
+  const normalized = normalizeString14(value).toLowerCase();
   if (["true", "1", "yes", "y"].includes(normalized)) {
     return true;
   }
@@ -23722,7 +22909,7 @@ function parseBooleanValue(value) {
   throw new Error("boolean answers must be yes or no");
 }
 function parseNumericValue(value, integerOnly) {
-  const normalized = normalizeString20(value);
+  const normalized = normalizeString14(value);
   if (!normalized) {
     throw new Error("answer is required");
   }
@@ -23736,7 +22923,7 @@ function parseNumericValue(value, integerOnly) {
   return parsed;
 }
 function matchOption(value, options) {
-  const normalized = normalizeString20(value);
+  const normalized = normalizeString14(value);
   if (!normalized) {
     return "";
   }
@@ -23748,7 +22935,7 @@ function matchOption(value, options) {
   return options.find((option) => option.toLowerCase() === folded) || "";
 }
 function parseArrayValue(value, options) {
-  const items = normalizeString20(value).split(",").map((item) => normalizeString20(item)).filter(Boolean);
+  const items = normalizeString14(value).split(",").map((item) => normalizeString14(item)).filter(Boolean);
   if (items.length === 0) {
     throw new Error("at least one value is required");
   }
@@ -23764,7 +22951,7 @@ function parseArrayValue(value, options) {
   });
 }
 function parseFieldValue(field, value) {
-  const normalizedValue = normalizeString20(value);
+  const normalizedValue = normalizeString14(value);
   if (!normalizedValue) {
     throw new Error(`${field.title} is required`);
   }
@@ -23791,14 +22978,35 @@ function parseFieldValue(field, value) {
       return normalizedValue;
   }
 }
+function isURLModeRequest(request) {
+  return normalizeString14(request?.request_payload?.mode).toLowerCase() === "url";
+}
 function buildElicitationHookOutput(request, response) {
+  if (response?.type === "action") {
+    const action = normalizeString14(response.value).toLowerCase();
+    if (!isURLModeRequest(request)) {
+      throw new Error("elicitation action replies are only supported for url mode");
+    }
+    if (!["accept", "cancel"].includes(action)) {
+      throw new Error("invalid elicitation action");
+    }
+    if (action === "accept") {
+      return {
+        action,
+        content: {}
+      };
+    }
+    return {
+      action
+    };
+  }
   const fields = normalizeElicitationFields(request?.fields);
   if (fields.length === 0) {
     throw new Error("elicitation request has no supported fields");
   }
-  if (response?.type === "single") {
+  if (response?.type === "text") {
     if (fields.length !== 1) {
-      throw new Error("multiple answers require 1=answer; 2=answer format");
+      throw new Error("multiple answers require map resolution");
     }
     return {
       action: "accept",
@@ -23810,30 +23018,27 @@ function buildElicitationHookOutput(request, response) {
   if (response?.type !== "map" || !Array.isArray(response.entries)) {
     throw new Error("invalid elicitation response");
   }
+  const fieldByKey = new Map(fields.map((field) => [field.key, field]));
   const content = {};
-  const answeredIndexes = /* @__PURE__ */ new Set();
+  const answeredKeys = /* @__PURE__ */ new Set();
   for (const entry of response.entries) {
-    const key = normalizeString20(entry?.key);
-    const value = normalizeString20(entry?.value);
-    if (!/^[1-9][0-9]*$/u.test(key)) {
-      throw new Error("elicitation answers must use numeric indexes like 1=answer");
+    const key = normalizeString14(entry?.key);
+    const value = normalizeString14(entry?.value);
+    const field = fieldByKey.get(key);
+    if (!field) {
+      throw new Error(`field ${key} is not part of this elicitation request`);
     }
     if (!value) {
       throw new Error(`field ${key} answer is required`);
     }
-    const index = Number(key);
-    if (index < 1 || index > fields.length) {
-      throw new Error(`field index ${index} is out of range`);
-    }
-    if (answeredIndexes.has(index)) {
-      throw new Error(`field index ${index} answered more than once`);
+    if (answeredKeys.has(key)) {
+      throw new Error(`field ${key} answered more than once`);
     }
-    const field = fields[index - 1];
-    answeredIndexes.add(index);
+    answeredKeys.add(key);
     content[field.key] = parseFieldValue(field, value);
   }
-  if (answeredIndexes.size !== fields.length) {
-    throw new Error(`expected ${fields.length} answers but received ${answeredIndexes.size}`);
+  if (answeredKeys.size !== fields.length) {
+    throw new Error(`expected ${fields.length} answers but received ${answeredKeys.size}`);
   }
   return {
     action: "accept",
@@ -23841,119 +23046,550 @@ function buildElicitationHookOutput(request, response) {
   };
 }
 
+// server/protocol-contract.js
+var contractVersion = 1;
+var protocolVersion = "aibot-agent-api-v1";
+var adapterHint = "claude/base";
+var declaredCapabilities = Object.freeze([
+  "session_route",
+  "local_action_v1",
+  "agent_invoke"
+]);
+var localActionTypes = Object.freeze({
+  sessionControl: "claude_session_control",
+  interactionReply: "claude_interaction_reply"
+});
+var declaredLocalActions = Object.freeze([
+  localActionTypes.sessionControl,
+  localActionTypes.interactionReply
+]);
+var agentInvokeActions = Object.freeze({
+  interactionRequestCreate: "claude_interaction_request_create",
+  accessControl: "claude_access_control"
+});
+var sessionControlVerbs = Object.freeze({
+  open: "open",
+  status: "status",
+  where: "where",
+  stop: "stop"
+});
+var interactionKinds = Object.freeze({
+  permission: "permission",
+  elicitation: "elicitation"
+});
+var interactionResolutionTypes = Object.freeze({
+  decision: "decision",
+  action: "action",
+  text: "text",
+  map: "map"
+});
+var accessControlVerbs = Object.freeze({
+  statusRead: "status_read",
+  pairApprove: "pair_approve",
+  pairDeny: "pair_deny",
+  senderAllow: "sender_allow",
+  senderRemove: "sender_remove",
+  policySet: "policy_set"
+});
+var resultDomains = Object.freeze({
+  sessionControl: "session_control",
+  interactionReply: "interaction_reply"
+});
+var bindingWorkerStatuses = Object.freeze({
+  starting: "starting",
+  connected: "connected",
+  ready: "ready",
+  stopped: "stopped",
+  failed: "failed"
+});
+var sessionControlOutcomes = Object.freeze({
+  opened: "opened",
+  alreadyBound: "already_bound",
+  status: "status",
+  where: "where",
+  stopped: "stopped"
+});
+var localActionResultStatuses = Object.freeze({
+  ok: "ok",
+  failed: "failed"
+});
+var localActionErrorCodes = Object.freeze({
+  unsupportedLocalAction: "unsupported_local_action",
+  localActionRouteMissing: "local_action_route_missing"
+});
+var sessionControlErrorCodes = Object.freeze({
+  cwdRequired: "session_cwd_required",
+  invalidCwd: "session_invalid_cwd",
+  bindingMissing: "session_binding_missing",
+  rebindForbidden: "session_rebind_forbidden",
+  verbInvalid: "session_verb_invalid",
+  runtimeError: "session_runtime_error"
+});
+var interactionReplyOutcomes = Object.freeze({
+  resolved: "resolved"
+});
+var interactionReplyErrorCodes = Object.freeze({
+  requestIDRequired: "interaction_request_id_required",
+  requestNotFound: "interaction_request_not_found",
+  requestNotPending: "interaction_request_not_pending",
+  resolutionInvalid: "interaction_resolution_invalid",
+  forwardFailed: "interaction_forward_failed"
+});
+var eventResultStatuses = Object.freeze({
+  responded: "responded",
+  failed: "failed",
+  canceled: "canceled"
+});
+var publicProtocolContract = Object.freeze({
+  contract_version: contractVersion,
+  protocol_version: protocolVersion,
+  adapter_hint: adapterHint,
+  capabilities: [...declaredCapabilities],
+  local_actions: [...declaredLocalActions],
+  agent_invoke_actions: [
+    agentInvokeActions.interactionRequestCreate,
+    agentInvokeActions.accessControl
+  ],
+  local_action_types: [
+    localActionTypes.sessionControl,
+    localActionTypes.interactionReply
+  ],
+  session_control_verbs: [
+    sessionControlVerbs.open,
+    sessionControlVerbs.status,
+    sessionControlVerbs.where,
+    sessionControlVerbs.stop
+  ],
+  interaction_kinds: [
+    interactionKinds.permission,
+    interactionKinds.elicitation
+  ],
+  interaction_resolution_types: [
+    interactionResolutionTypes.decision,
+    interactionResolutionTypes.action,
+    interactionResolutionTypes.text,
+    interactionResolutionTypes.map
+  ],
+  access_control_verbs: [
+    accessControlVerbs.statusRead,
+    accessControlVerbs.pairApprove,
+    accessControlVerbs.pairDeny,
+    accessControlVerbs.senderAllow,
+    accessControlVerbs.senderRemove,
+    accessControlVerbs.policySet
+  ],
+  result_domains: [
+    resultDomains.sessionControl,
+    resultDomains.interactionReply
+  ],
+  binding_worker_statuses: [
+    bindingWorkerStatuses.starting,
+    bindingWorkerStatuses.connected,
+    bindingWorkerStatuses.ready,
+    bindingWorkerStatuses.stopped,
+    bindingWorkerStatuses.failed
+  ],
+  session_control_outcomes: [
+    sessionControlOutcomes.opened,
+    sessionControlOutcomes.alreadyBound,
+    sessionControlOutcomes.status,
+    sessionControlOutcomes.where,
+    sessionControlOutcomes.stopped
+  ],
+  local_action_result_statuses: [
+    localActionResultStatuses.ok,
+    localActionResultStatuses.failed
+  ],
+  local_action_error_codes: [
+    localActionErrorCodes.unsupportedLocalAction,
+    localActionErrorCodes.localActionRouteMissing
+  ],
+  session_control_error_codes: [
+    sessionControlErrorCodes.cwdRequired,
+    sessionControlErrorCodes.invalidCwd,
+    sessionControlErrorCodes.bindingMissing,
+    sessionControlErrorCodes.rebindForbidden,
+    sessionControlErrorCodes.verbInvalid,
+    sessionControlErrorCodes.runtimeError
+  ],
+  interaction_reply_outcomes: [
+    interactionReplyOutcomes.resolved
+  ],
+  interaction_reply_error_codes: [
+    interactionReplyErrorCodes.requestIDRequired,
+    interactionReplyErrorCodes.requestNotFound,
+    interactionReplyErrorCodes.requestNotPending,
+    interactionReplyErrorCodes.resolutionInvalid,
+    interactionReplyErrorCodes.forwardFailed
+  ],
+  event_result_statuses: [
+    eventResultStatuses.responded,
+    eventResultStatuses.failed,
+    eventResultStatuses.canceled
+  ]
+});
+
+// server/worker/interaction-protocol.js
+function normalizeString15(value) {
+  return String(value ?? "").trim();
+}
+function requireNonEmpty(value, errorMessage) {
+  const normalized = normalizeString15(value);
+  if (!normalized) {
+    throw new Error(errorMessage);
+  }
+  return normalized;
+}
+function isRecord2(value) {
+  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function normalizeMapEntries(value) {
+  if (!Array.isArray(value)) {
+    return [];
+  }
+  return value.map((entry) => {
+    if (!isRecord2(entry)) {
+      return null;
+    }
+    const key = normalizeString15(entry.key);
+    const mappedValue = normalizeString15(entry.value);
+    if (!key || !mappedValue) {
+      return null;
+    }
+    return {
+      key,
+      value: mappedValue
+    };
+  }).filter(Boolean);
+}
+function normalizeInteractionField(field) {
+  const normalized = {
+    key: normalizeString15(field?.key),
+    title: normalizeString15(field?.title),
+    prompt: normalizeString15(field?.prompt),
+    kind: normalizeString15(field?.kind),
+    required: field?.required !== false,
+    multi_select: field?.multi_select === true,
+    options: Array.isArray(field?.options) ? field.options.map((option) => normalizeString15(option)).filter(Boolean) : []
+  };
+  if (!normalized.key || !normalized.title || !normalized.prompt || !normalized.kind) {
+    return null;
+  }
+  return normalized;
+}
+function normalizeInteractionFields(fields) {
+  return normalizeElicitationFields(fields).map((field) => normalizeInteractionField(field)).filter(Boolean);
+}
+function buildInteractionRequestInvokeParams({
+  kind,
+  requestID,
+  sessionID,
+  messageID,
+  payload
+} = {}) {
+  const normalizedKind = requireNonEmpty(kind, "interaction kind is required");
+  if (!Object.values(interactionKinds).includes(normalizedKind)) {
+    throw new Error(`interaction kind ${normalizedKind} is invalid`);
+  }
+  return {
+    kind: normalizedKind,
+    request_id: requireNonEmpty(requestID, "interaction request id is required"),
+    session_id: requireNonEmpty(sessionID, "interaction session id is required"),
+    message_id: requireNonEmpty(messageID, "interaction message id is required"),
+    payload: isRecord2(payload) ? payload : {}
+  };
+}
+function buildPermissionInteractionPayload(input = {}) {
+  return {
+    tool_name: normalizeString15(input.tool_name),
+    description: normalizeString15(input.description),
+    input_preview: normalizeString15(input.input_preview)
+  };
+}
+function buildElicitationInteractionPayload(request = {}) {
+  const rawPayload = isRecord2(request?.request_payload) ? request.request_payload : {};
+  const fields = normalizeInteractionFields(request?.fields);
+  const mode = normalizeString15(rawPayload.mode).toLowerCase() === "url" ? "url" : "form";
+  const payload = {
+    mode,
+    prompt: normalizeString15(rawPayload.message || rawPayload.prompt)
+  };
+  if (mode === "url") {
+    payload.url = normalizeString15(rawPayload.url);
+    return payload;
+  }
+  payload.fields = fields;
+  return payload;
+}
+function buildInteractionReplyResult({
+  kind,
+  requestID,
+  outcome = interactionReplyOutcomes.resolved
+} = {}) {
+  return {
+    domain: resultDomains.interactionReply,
+    kind: normalizeString15(kind),
+    request_id: normalizeString15(requestID),
+    outcome: normalizeString15(outcome) || interactionReplyOutcomes.resolved
+  };
+}
+function parseInteractionReplyAction(rawPayload) {
+  const actionType = normalizeString15(rawPayload?.action_type).toLowerCase();
+  if (actionType !== localActionTypes.interactionReply) {
+    return {
+      matched: false,
+      kind: "",
+      requestID: "",
+      resolution: null,
+      errorCode: "",
+      errorMsg: ""
+    };
+  }
+  const params = isRecord2(rawPayload?.params) ? rawPayload.params : {};
+  const kind = normalizeString15(params.kind).toLowerCase();
+  if (!Object.values(interactionKinds).includes(kind)) {
+    return {
+      matched: true,
+      kind: "",
+      requestID: normalizeString15(params.request_id),
+      resolution: null,
+      errorCode: interactionReplyErrorCodes.resolutionInvalid,
+      errorMsg: "interaction kind is invalid"
+    };
+  }
+  const requestID = normalizeString15(params.request_id);
+  const resolutionInput = isRecord2(params.resolution) ? params.resolution : null;
+  if (!resolutionInput) {
+    return {
+      matched: true,
+      kind,
+      requestID,
+      resolution: null,
+      errorCode: interactionReplyErrorCodes.resolutionInvalid,
+      errorMsg: "interaction resolution is required"
+    };
+  }
+  const type = normalizeString15(resolutionInput.type).toLowerCase();
+  if (type === interactionResolutionTypes.decision) {
+    const value = normalizeString15(resolutionInput.value).toLowerCase();
+    if (value === "allow" || value === "deny") {
+      return {
+        matched: true,
+        kind,
+        requestID,
+        resolution: {
+          type: interactionResolutionTypes.decision,
+          value
+        },
+        errorCode: "",
+        errorMsg: ""
+      };
+    }
+    return {
+      matched: true,
+      kind,
+      requestID,
+      resolution: null,
+      errorCode: interactionReplyErrorCodes.resolutionInvalid,
+      errorMsg: `interaction decision ${value} is invalid`
+    };
+  }
+  if (type === interactionResolutionTypes.action) {
+    const value = normalizeString15(resolutionInput.value).toLowerCase();
+    if (["accept", "decline", "cancel"].includes(value)) {
+      return {
+        matched: true,
+        kind,
+        requestID,
+        resolution: {
+          type: interactionResolutionTypes.action,
+          value
+        },
+        errorCode: "",
+        errorMsg: ""
+      };
+    }
+    return {
+      matched: true,
+      kind,
+      requestID,
+      resolution: null,
+      errorCode: interactionReplyErrorCodes.resolutionInvalid,
+      errorMsg: `interaction action ${value} is invalid`
+    };
+  }
+  if (type === interactionResolutionTypes.text) {
+    const value = normalizeString15(resolutionInput.value);
+    if (value) {
+      return {
+        matched: true,
+        kind,
+        requestID,
+        resolution: {
+          type: interactionResolutionTypes.text,
+          value
+        },
+        errorCode: "",
+        errorMsg: ""
+      };
+    }
+    return {
+      matched: true,
+      kind,
+      requestID,
+      resolution: null,
+      errorCode: interactionReplyErrorCodes.resolutionInvalid,
+      errorMsg: "interaction text resolution is required"
+    };
+  }
+  if (type === interactionResolutionTypes.map) {
+    const entries = normalizeMapEntries(resolutionInput.entries);
+    if (entries.length > 0) {
+      return {
+        matched: true,
+        kind,
+        requestID,
+        resolution: {
+          type: interactionResolutionTypes.map,
+          entries
+        },
+        errorCode: "",
+        errorMsg: ""
+      };
+    }
+    return {
+      matched: true,
+      kind,
+      requestID,
+      resolution: null,
+      errorCode: interactionReplyErrorCodes.resolutionInvalid,
+      errorMsg: "interaction map resolution is required"
+    };
+  }
+  return {
+    matched: true,
+    kind,
+    requestID,
+    resolution: null,
+    errorCode: interactionReplyErrorCodes.resolutionInvalid,
+    errorMsg: `interaction resolution type ${type} is invalid`
+  };
+}
+
 // server/worker/elicitation-relay-service.js
 var elicitationPollIntervalMs = 1500;
+function normalizeString16(value) {
+  return String(value ?? "").trim();
+}
 function normalizeOptionalString2(value) {
-  const normalized = String(value ?? "").trim();
+  const normalized = normalizeString16(value);
   return normalized || "";
 }
 var WorkerElicitationRelayService = class {
   constructor({
     elicitationStore,
     bridge,
-    finalizeEvent,
     logger
   }) {
     this.elicitationStore = elicitationStore;
     this.bridge = bridge;
-    this.finalizeEvent = typeof finalizeEvent === "function" ? finalizeEvent : async () => false;
     this.logger = logger;
     this.pollTimer = null;
   }
-  async finalizeEventSafely(eventID, result, context) {
-    return this.finalizeEvent(eventID, result, context);
-  }
-  async sendCommandReply(event, text, bizCard = null) {
-    await this.bridge.sendText({
-      eventID: event.event_id,
-      sessionID: event.session_id,
-      text,
-      quotedMessageID: event.msg_id,
-      clientMsgID: `elicitation_reply_${event.event_id}`,
-      extra: {
-        reply_source: "claude_channel_question",
-        ...bizCard ? { biz_card: bizCard } : {}
-      }
+  async dispatchRequest(request) {
+    const requestID = normalizeString16(request?.request_id);
+    const invokeResult = await this.bridge.agentInvoke({
+      invokeID: `elicitation_request_${requestID}`,
+      action: agentInvokeActions.interactionRequestCreate,
+      params: buildInteractionRequestInvokeParams({
+        kind: interactionKinds.elicitation,
+        requestID,
+        sessionID: normalizeString16(request?.channel_context?.chat_id),
+        messageID: normalizeString16(request?.channel_context?.message_id),
+        payload: buildElicitationInteractionPayload(request)
+      })
+    });
+    if (Number(invokeResult?.code ?? 0) !== 0) {
+      throw new Error(normalizeOptionalString2(invokeResult?.msg) || "agent invoke failed");
+    }
+    await this.elicitationStore.markDispatched(request.request_id, {
+      dispatchedAt: Date.now()
+    });
+    this.logger.trace?.({
+      component: "worker.elicitation",
+      stage: "elicitation_request_dispatched",
+      request_id: request.request_id,
+      chat_id: request.channel_context.chat_id,
+      msg_id: request.channel_context.message_id
     });
   }
-  async handleCommandEvent(event) {
-    const parsed = parseQuestionResponseCommand(event.content);
-    if (!parsed.matched) {
+  async handleLocalAction(rawPayload) {
+    const resolved = parseInteractionReplyAction(rawPayload);
+    if (!resolved.matched) {
       return {
         handled: false,
         kind: ""
       };
     }
-    if (!parsed.ok) {
-      await this.sendCommandReply(event, parsed.error, buildQuestionStatusBizCard({
-        summary: parsed.error
-      }));
-      await this.finalizeEventSafely(event.event_id, {
-        status: "responded",
-        code: "elicitation_command_invalid",
-        msg: "elicitation command invalid"
-      }, "elicitation invalid terminal result failed");
+    if (resolved.kind && resolved.kind !== "elicitation") {
+      return {
+        handled: false,
+        kind: ""
+      };
+    }
+    const actionID = normalizeString16(rawPayload?.action_id);
+    if (!actionID) {
+      this.logger.error(`elicitation local_action missing action_id: ${JSON.stringify(rawPayload)}`);
       return {
         handled: true,
         kind: "elicitation"
       };
     }
-    const request = await this.elicitationStore.getRequest(parsed.request_id);
-    if (!request) {
-      await this.sendCommandReply(
-        event,
-        `Input request ${parsed.request_id} was not found.`,
-        buildQuestionStatusBizCard({
-          summary: `Input request ${parsed.request_id} was not found.`,
-          referenceID: parsed.request_id,
-          status: "warning"
-        })
-      );
-      await this.finalizeEventSafely(event.event_id, {
-        status: "responded",
-        code: "elicitation_request_not_found",
-        msg: "elicitation request not found"
-      }, "elicitation not-found terminal result failed");
+    const requestID = normalizeString16(resolved.requestID);
+    if (!requestID) {
+      await this.bridge.sendLocalActionResult({
+        actionID,
+        status: localActionResultStatuses.failed,
+        errorCode: interactionReplyErrorCodes.requestIDRequired,
+        errorMsg: "interaction request id is required"
+      });
       return {
         handled: true,
         kind: "elicitation"
       };
     }
-    if (request.channel_context.chat_id !== event.session_id) {
-      await this.sendCommandReply(
-        event,
-        "This input request belongs to a different Grix chat.",
-        buildQuestionStatusBizCard({
-          summary: "This input request belongs to a different Grix chat.",
-          referenceID: parsed.request_id,
-          status: "warning"
-        })
-      );
-      await this.finalizeEventSafely(event.event_id, {
-        status: "responded",
-        code: "elicitation_chat_mismatch",
-        msg: "elicitation request belongs to a different chat"
-      }, "elicitation chat-mismatch terminal result failed");
+    const request = await this.elicitationStore.getRequest(requestID);
+    if (!request) {
+      await this.bridge.sendLocalActionResult({
+        actionID,
+        status: localActionResultStatuses.failed,
+        errorCode: interactionReplyErrorCodes.requestNotFound,
+        errorMsg: `interaction request ${requestID} was not found`
+      });
       return {
         handled: true,
         kind: "elicitation"
       };
     }
     if (request.status !== "pending") {
-      await this.sendCommandReply(
-        event,
-        `Input request ${parsed.request_id} is ${request.status}.`,
-        buildQuestionStatusBizCard({
-          summary: `Input request ${parsed.request_id} is ${request.status}.`,
-          referenceID: parsed.request_id,
-          status: "warning"
-        })
-      );
-      await this.finalizeEventSafely(event.event_id, {
-        status: "responded",
-        code: "elicitation_request_not_pending",
-        msg: `elicitation request is ${request.status}`
-      }, "elicitation not-pending terminal result failed");
+      await this.bridge.sendLocalActionResult({
+        actionID,
+        status: localActionResultStatuses.failed,
+        errorCode: interactionReplyErrorCodes.requestNotPending,
+        errorMsg: `interaction request ${requestID} is ${request.status}`
+      });
+      return {
+        handled: true,
+        kind: "elicitation"
+      };
+    }
+    if (!resolved.resolution) {
+      await this.bridge.sendLocalActionResult({
+        actionID,
+        status: localActionResultStatuses.failed,
+        errorCode: resolved.errorCode || interactionReplyErrorCodes.resolutionInvalid,
+        errorMsg: resolved.errorMsg || "interaction resolution is invalid"
+      });
       return {
         handled: true,
         kind: "elicitation"
@@ -23961,87 +23597,42 @@ var WorkerElicitationRelayService = class {
     }
     let hookOutput;
     try {
-      hookOutput = buildElicitationHookOutput(request, parsed.response);
+      hookOutput = buildElicitationHookOutput(request, resolved.resolution);
     } catch (error2) {
-      const message = String(error2 instanceof Error ? error2.message : error2);
-      await this.sendCommandReply(event, message, buildQuestionStatusBizCard({
-        summary: message,
-        referenceID: parsed.request_id,
-        status: "warning"
-      }));
-      await this.finalizeEventSafely(event.event_id, {
-        status: "responded",
-        code: "elicitation_answer_invalid",
-        msg: message
-      }, "elicitation invalid-answer terminal result failed");
+      await this.bridge.sendLocalActionResult({
+        actionID,
+        status: localActionResultStatuses.failed,
+        errorCode: interactionReplyErrorCodes.resolutionInvalid,
+        errorMsg: String(error2 instanceof Error ? error2.message : error2)
+      });
       return {
         handled: true,
         kind: "elicitation"
       };
     }
-    await this.elicitationStore.resolveRequest(parsed.request_id, {
+    await this.elicitationStore.resolveRequest(requestID, {
       action: hookOutput.action,
-      content: hookOutput.content,
-      resolvedBy: {
-        sender_id: event.sender_id,
-        session_id: event.session_id,
-        event_id: event.event_id,
-        msg_id: event.msg_id
-      }
+      content: hookOutput.content
+    });
+    await this.bridge.sendLocalActionResult({
+      actionID,
+      status: localActionResultStatuses.ok,
+      result: buildInteractionReplyResult({
+        kind: interactionKinds.elicitation,
+        requestID
+      })
     });
     this.logger.trace?.({
       component: "worker.elicitation",
-      stage: "elicitation_command_resolved",
-      event_id: event.event_id,
-      session_id: event.session_id,
-      sender_id: event.sender_id,
-      request_id: parsed.request_id,
-      origin_event_id: request.channel_context.event_id,
+      stage: "elicitation_local_action_resolved",
+      request_id: requestID,
       chat_id: request.channel_context.chat_id
     });
-    const responseText = buildElicitationResponseText({
-      requestID: parsed.request_id
-    });
-    await this.sendCommandReply(event, responseText, buildQuestionStatusBizCard({
-      summary: responseText,
-      referenceID: parsed.request_id,
-      status: "success"
-    }));
-    await this.finalizeEventSafely(event.event_id, {
-      status: "responded",
-      code: "elicitation_recorded",
-      msg: "elicitation answers recorded"
-    }, "elicitation recorded terminal result failed");
     return {
       handled: true,
       kind: "elicitation"
     };
   }
-  async dispatchRequest(request) {
-    const ack = await this.bridge.sendText({
-      sessionID: request.channel_context.chat_id,
-      text: buildElicitationRequestText(request),
-      quotedMessageID: request.channel_context.message_id || request.channel_context.msg_id,
-      clientMsgID: `elicitation_request_${request.request_id}`,
-      extra: {
-        reply_source: "claude_elicitation",
-        elicitation_request_id: request.request_id,
-        biz_card: buildQuestionRequestBizCard(request)
-      }
-    });
-    await this.elicitationStore.markDispatched(request.request_id, {
-      dispatchedAt: Date.now(),
-      promptMessageID: normalizeOptionalString2(ack.msg_id)
-    });
-    this.logger.trace?.({
-      component: "worker.elicitation",
-      stage: "elicitation_request_dispatched",
-      request_id: request.request_id,
-      event_id: request.channel_context.event_id,
-      chat_id: request.channel_context.chat_id,
-      msg_id: request.channel_context.message_id || request.channel_context.msg_id
-    });
-  }
   async pumpRequests() {
     const pending = await this.elicitationStore.listPendingDispatches();
     for (const request of pending) {
@@ -24074,17 +23665,17 @@ var WorkerElicitationRelayService = class {
 };
 
 // server/inbound-event-meta.js
-function normalizeString21(value) {
+function normalizeString17(value) {
   return String(value ?? "").trim();
 }
 function normalizeOptionalString3(value) {
-  return normalizeString21(value) || "";
+  return normalizeString17(value) || "";
 }
 function normalizeStringArray3(value) {
   if (!Array.isArray(value)) {
     return [];
   }
-  return value.map((item) => normalizeString21(item)).filter((item) => item);
+  return value.map((item) => normalizeString17(item)).filter((item) => item);
 }
 function normalizeJSONObject(value) {
   if (!value) {
@@ -24138,7 +23729,44 @@ function normalizeAttachmentRecord(value) {
   if (!attachment.attachment_type && !attachment.media_url && !attachment.file_name && !attachment.content_type) {
     return null;
   }
-  return attachment;
+  return attachment;
+}
+function normalizeContextMessageRecord(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return null;
+  }
+  const normalized = {
+    msg_id: normalizeOptionalString3(value.msg_id),
+    sender_id: normalizeOptionalString3(value.sender_id),
+    sender_type: Number(value.sender_type ?? 0),
+    msg_type: Number(value.msg_type ?? 0),
+    content: String(value.content ?? ""),
+    quoted_message_id: normalizeOptionalString3(value.quoted_message_id),
+    mention_user_ids: normalizeStringArray3(value.mention_user_ids),
+    created_at: Number(value.created_at ?? 0)
+  };
+  if (!normalized.msg_id) {
+    return null;
+  }
+  return normalized;
+}
+function normalizeContextMessageArray(value) {
+  if (Array.isArray(value)) {
+    return value.map((item) => normalizeContextMessageRecord(item)).filter(Boolean);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) {
+      return [];
+    }
+    try {
+      const parsed = JSON.parse(trimmed);
+      return normalizeContextMessageArray(parsed);
+    } catch {
+      return [];
+    }
+  }
+  return [];
 }
 function deriveAttachments(payload, extra) {
   const explicit = normalizeJSONArray(payload.attachments).map((item) => normalizeAttachmentRecord(item)).filter(Boolean);
@@ -24169,19 +23797,25 @@ function stringifyJSON(value) {
   }
   return JSON.stringify(value);
 }
+function deriveContextMessages(payload) {
+  const currentMsgID = normalizeString17(payload.msg_id);
+  return normalizeContextMessageArray(payload.context_messages).filter((entry) => entry.msg_id !== currentMsgID);
+}
 function normalizeInboundEventPayload(rawPayload) {
   const extra = normalizeJSONObject(rawPayload.extra);
   const attachments = deriveAttachments(rawPayload, extra);
   const bizCard = normalizeJSONObject(rawPayload.biz_card) ?? normalizeJSONObject(extra?.biz_card);
   const channelData = normalizeJSONObject(rawPayload.channel_data) ?? normalizeJSONObject(extra?.channel_data);
+  const contextMessages = deriveContextMessages(rawPayload);
   return {
-    event_id: normalizeString21(rawPayload.event_id),
-    event_type: normalizeString21(rawPayload.event_type),
-    session_id: normalizeString21(rawPayload.session_id),
+    event_id: normalizeString17(rawPayload.event_id),
+    event_type: normalizeString17(rawPayload.event_type),
+    mirror_mode: normalizeString17(rawPayload.mirror_mode),
+    session_id: normalizeString17(rawPayload.session_id),
     session_type: normalizeOptionalString3(rawPayload.session_type),
-    msg_id: normalizeString21(rawPayload.msg_id),
+    msg_id: normalizeString17(rawPayload.msg_id),
     quoted_message_id: normalizeOptionalString3(rawPayload.quoted_message_id),
-    sender_id: normalizeString21(rawPayload.sender_id),
+    sender_id: normalizeString17(rawPayload.sender_id),
     owner_id: normalizeOptionalString3(rawPayload.owner_id),
     agent_id: normalizeOptionalString3(rawPayload.agent_id),
     msg_type: normalizeOptionalString3(rawPayload.msg_type),
@@ -24192,12 +23826,13 @@ function normalizeInboundEventPayload(rawPayload) {
     attachments_json: stringifyJSON(attachments),
     attachment_count: attachments.length > 0 ? String(attachments.length) : "",
     biz_card_json: stringifyJSON(bizCard),
-    channel_data_json: stringifyJSON(channelData)
+    channel_data_json: stringifyJSON(channelData),
+    context_messages_json: stringifyJSON(contextMessages)
   };
 }
 
 // server/channel-notification.js
-function normalizeString22(value) {
+function normalizeString18(value) {
   return String(value ?? "").trim();
 }
 function compactRecord(source) {
@@ -24209,8 +23844,8 @@ function compactRecord(source) {
       }
       continue;
     }
-    if (normalizeString22(value)) {
-      target[key] = normalizeString22(value);
+    if (normalizeString18(value)) {
+      target[key] = normalizeString18(value);
     }
   }
   return target;
@@ -24223,11 +23858,11 @@ function formatTimestamp(value) {
   return new Date(numeric).toISOString();
 }
 function resolveEventType(event) {
-  const explicit = normalizeString22(event?.event_type);
+  const explicit = normalizeString18(event?.event_type);
   if (explicit) {
     return explicit;
   }
-  return normalizeString22(event?.session_type) === "2" ? "group_message" : "user_chat";
+  return normalizeString18(event?.session_type) === "2" ? "group_message" : "user_chat";
 }
 function buildChannelNotificationParams(event) {
   return {
@@ -24236,6 +23871,7 @@ function buildChannelNotificationParams(event) {
       chat_id: event?.session_id,
       event_id: event?.event_id,
       event_type: resolveEventType(event),
+      mirror_mode: event?.mirror_mode,
       message_id: event?.msg_id,
       sender_id: event?.sender_id,
       user: event?.sender_id,
@@ -24252,7 +23888,8 @@ function buildChannelNotificationParams(event) {
       attachments_json: event?.attachments_json,
       attachment_count: event?.attachment_count,
       biz_card_json: event?.biz_card_json,
-      channel_data_json: event?.channel_data_json
+      channel_data_json: event?.channel_data_json,
+      context_messages_json: event?.context_messages_json
     })
   };
 }
@@ -24261,7 +23898,7 @@ function buildChannelNotificationParams(event) {
 var probeChannelNamespace = "grix-claude";
 var probeKind = "ping_pong";
 var defaultWorkerPingProbeTimeoutMs = 15 * 1e3;
-function normalizeString23(value) {
+function normalizeString19(value) {
   return String(value ?? "").trim();
 }
 function parseJSONObject(value) {
@@ -24291,17 +23928,17 @@ function extractWorkerProbeMeta(payload) {
   if (!probe || typeof probe !== "object") {
     return null;
   }
-  if (normalizeString23(probe.kind) !== probeKind) {
+  if (normalizeString19(probe.kind) !== probeKind) {
     return null;
   }
-  const probeID = normalizeString23(probe.probe_id);
+  const probeID = normalizeString19(probe.probe_id);
   if (!probeID) {
     return null;
   }
   return {
     probeID,
     kind: probeKind,
-    expectedReply: normalizeString23(probe.expected_reply) || "pong"
+    expectedReply: normalizeString19(probe.expected_reply) || "pong"
   };
 }
 
@@ -24351,11 +23988,11 @@ var defaultResultTimeoutMs = 90 * 1e3;
 var defaultResultTimeoutRetryMs = 10 * 1e3;
 var defaultComposingHeartbeatMs = 10 * 1e3;
 var defaultComposingTTLMS = 30 * 1e3;
-function normalizeString24(value) {
+function normalizeString20(value) {
   return String(value ?? "").trim();
 }
 function normalizeOptionalString4(value) {
-  const normalized = normalizeString24(value);
+  const normalized = normalizeString20(value);
   return normalized || "";
 }
 function normalizePositiveInt3(value, fallbackValue) {
@@ -24424,10 +24061,10 @@ var WorkerEventLifecycleManager = class {
     this.logger.trace?.({
       component: "worker.interaction",
       stage: "local_result_timeout_armed",
-      event_id: normalizeString24(eventID),
+      event_id: normalizeString20(eventID),
       timeout_ms: normalizedTimeoutMs,
       deadline_at: deadlineAt,
-      timeout_kind: normalizeString24(timeoutKind) || "default"
+      timeout_kind: normalizeString20(timeoutKind) || "default"
     });
     return deadlineAt;
   }
@@ -24436,7 +24073,7 @@ var WorkerEventLifecycleManager = class {
     this.eventState.clearResultDeadline(eventID);
   }
   clearComposingKeepaliveTimer(eventID) {
-    const normalizedEventID = normalizeString24(eventID);
+    const normalizedEventID = normalizeString20(eventID);
     if (!normalizedEventID) {
       return;
     }
@@ -24451,7 +24088,7 @@ var WorkerEventLifecycleManager = class {
     return event?.suppress_composing === true;
   }
   sendComposingState(event, active) {
-    if (!event || !normalizeString24(event.session_id) || this.shouldSuppressComposing(event)) {
+    if (!event || !normalizeString20(event.session_id) || this.shouldSuppressComposing(event)) {
       return false;
     }
     void this.bridge.setSessionComposing({
@@ -24468,7 +24105,7 @@ var WorkerEventLifecycleManager = class {
     return true;
   }
   startComposingKeepalive(eventID) {
-    const normalizedEventID = normalizeString24(eventID);
+    const normalizedEventID = normalizeString20(eventID);
     if (!normalizedEventID) {
       return;
     }
@@ -24486,7 +24123,7 @@ var WorkerEventLifecycleManager = class {
     this.composingKeepaliveTimers.set(normalizedEventID, timer);
   }
   stopComposingKeepalive(eventID, fallbackEvent = null) {
-    const normalizedEventID = normalizeString24(eventID);
+    const normalizedEventID = normalizeString20(eventID);
     if (!normalizedEventID) {
       return;
     }
@@ -24502,7 +24139,7 @@ var WorkerEventLifecycleManager = class {
   }
   buildTerminalResult({ status, code = "", msg = "" }) {
     return {
-      status: normalizeString24(status),
+      status: normalizeString20(status),
       code: normalizeOptionalString4(code),
       msg: normalizeOptionalString4(msg),
       updated_at: Date.now()
@@ -24577,21 +24214,18 @@ var WorkerEventLifecycleManager = class {
 };
 
 // server/worker/interaction-service.js
-function normalizeString25(value) {
+function normalizeString21(value) {
   return String(value ?? "").trim();
 }
 function normalizeOptionalString5(value) {
-  const normalized = normalizeString25(value);
+  const normalized = normalizeString21(value);
   return normalized || "";
 }
 function shouldRestoreLocalResultTimeout(entry) {
   return Boolean(entry?.result_intent);
 }
-function isGroupSession(payload) {
-  return Number(payload.session_type ?? 0) === 2 || normalizeString25(payload.event_type).startsWith("group_");
-}
 async function persistEventChannelContext(sessionContextStore, event) {
-  if (!normalizeString25(event.session_id) || !normalizeString25(event.msg_id)) {
+  if (!normalizeString21(event.session_id) || !normalizeString21(event.msg_id)) {
     return;
   }
   await sessionContextStore.put({
@@ -24599,13 +24233,8 @@ async function persistEventChannelContext(sessionContextStore, event) {
     transcript_path: `event:${event.event_id}`,
     updated_at: Date.now(),
     context: {
-      raw_tag: "",
       chat_id: event.session_id,
-      event_id: event.event_id,
-      message_id: event.msg_id,
-      sender_id: event.sender_id,
-      user_id: event.sender_id,
-      msg_id: event.msg_id
+      message_id: event.msg_id
     }
   });
 }
@@ -24613,7 +24242,6 @@ var WorkerInteractionService = class {
   constructor({
     eventState,
     sessionContextStore,
-    accessStore,
     eventStatesDir,
     mcp,
     bridge,
@@ -24627,7 +24255,6 @@ var WorkerInteractionService = class {
   }) {
     this.eventState = eventState;
     this.sessionContextStore = sessionContextStore;
-    this.accessStore = accessStore;
     this.eventStatesDir = eventStatesDir;
     this.mcp = mcp;
     this.bridge = bridge;
@@ -24673,51 +24300,6 @@ var WorkerInteractionService = class {
     });
     this.logger.debug(`event notification-dispatched event=${event.event_id}`);
   }
-  async sendAccessStatusMessage(sessionID, text, clientMsgID, bizCard = null) {
-    await this.bridge.sendText({
-      sessionID,
-      text,
-      clientMsgID,
-      extra: {
-        reply_source: "claude_channel_access",
-        ...bizCard ? { biz_card: bizCard } : {}
-      }
-    });
-  }
-  async sendPairingMessage(event) {
-    const pair = await this.accessStore.issuePairingCode({
-      senderID: event.sender_id,
-      sessionID: event.session_id
-    });
-    const text = [
-      "This sender is not allowlisted for the Claude Grix channel.",
-      `Pairing code: ${pair.code}`,
-      "Ask the Claude Code user to run /grix:access pair <code> with this code to approve the sender."
-    ].join("\n");
-    await this.bridge.sendText({
-      sessionID: event.session_id,
-      text,
-      clientMsgID: `pair_${event.event_id}`,
-      extra: {
-        biz_card: buildPairingBizCard(pair.code)
-      }
-    });
-    this.eventState.markPairingSent(event.event_id, {
-      sentAt: Date.now()
-    });
-    this.logger.trace?.({
-      component: "worker.interaction",
-      stage: "pairing_sent",
-      event_id: event.event_id,
-      session_id: event.session_id,
-      sender_id: event.sender_id
-    });
-    await this.finalizeEventSafely(event.event_id, {
-      status: "responded",
-      code: "pairing_required",
-      msg: "pairing code sent"
-    }, "pairing terminal result failed");
-  }
   async handleDuplicateEvent(event) {
     this.logger.info(`duplicate inbound event handled event=${event.event_id}`);
     if (!event.acked) {
@@ -24738,14 +24320,6 @@ var WorkerInteractionService = class {
       return;
     }
     this.eventLifecycle.startComposingKeepalive(event.event_id);
-    if (event.pairing_sent_at && this.eventState.canResendPairing(event.event_id)) {
-      try {
-        await this.sendPairingMessage(event);
-      } catch (error2) {
-        this.logger.error(`duplicate pairing resend failed event=${event.event_id}: ${String(error2)}`);
-      }
-      return;
-    }
     if (event.notification_dispatched_at) {
       return;
     }
@@ -24819,10 +24393,6 @@ var WorkerInteractionService = class {
     } catch (error2) {
       this.logger.error(`session-context store failed event=${event.event_id}: ${String(error2)}`);
     }
-    let policy = this.accessStore.getPolicy();
-    const senderAllowlisted = this.accessStore.isSenderAllowlisted(event.sender_id);
-    let senderAllowed = this.accessStore.isSenderAllowed(event.sender_id);
-    const hasAllowedSenders = this.accessStore.hasAllowedSenders();
     event = this.markEventAccepted(event);
     this.logger.trace?.({
       component: "worker.interaction",
@@ -24830,142 +24400,8 @@ var WorkerInteractionService = class {
       event_id: event.event_id,
       session_id: event.session_id,
       msg_id: event.msg_id,
-      sender_id: event.sender_id,
-      policy
+      sender_id: event.sender_id
     });
-    if (policy === "disabled") {
-      this.logger.debug(`event disabled-policy event=${event.event_id}`);
-      try {
-        await this.sendAccessStatusMessage(
-          event.session_id,
-          "Claude Grix access is currently disabled for this channel.",
-          `access_disabled_${event.event_id}`,
-          buildAccessStatusBizCard({
-            summary: "Claude Grix access is currently disabled for this channel.",
-            status: "warning",
-            referenceID: event.event_id
-          })
-        );
-      } catch (error2) {
-        this.logger.error(`disabled-policy notice failed event=${event.event_id}: ${String(error2)}`);
-      }
-      await this.finalizeEventSafely(event.event_id, {
-        status: "canceled",
-        code: "policy_disabled",
-        msg: "channel policy disabled"
-      }, "policy-disabled result send failed");
-      return;
-    }
-    if (!senderAllowlisted && !isGroupSession(rawPayload) && (policy === "open" || policy === "allowlist" && !hasAllowedSenders)) {
-      try {
-        const bootstrap = await this.accessStore.bootstrapFirstSender(event.sender_id, {
-          lockPolicyToAllowlist: policy === "open"
-        });
-        if (bootstrap.bootstrapped) {
-          policy = bootstrap.policy;
-          senderAllowed = true;
-          this.logger.trace?.({
-            component: "worker.interaction",
-            stage: "sender_bootstrapped",
-            event_id: event.event_id,
-            session_id: event.session_id,
-            sender_id: event.sender_id,
-            policy
-          });
-          this.logger.info(`bootstrapped sender allowlist sender=${event.sender_id} policy=${policy}`);
-          this.logger.debug(`event first-sender-bootstrap event=${event.event_id} sender=${event.sender_id}`);
-        }
-      } catch (error2) {
-        try {
-          await this.sendAccessStatusMessage(
-            event.session_id,
-            `Claude Grix could not auto-authorize this sender: ${String(error2)}.`,
-            `sender_bootstrap_failed_${event.event_id}`,
-            buildAccessStatusBizCard({
-              summary: `Claude Grix could not auto-authorize this sender: ${String(error2)}.`,
-              status: "error",
-              referenceID: event.event_id
-            })
-          );
-        } catch (notifyError) {
-          this.logger.error(`sender bootstrap notice failed event=${event.event_id}: ${String(notifyError)}`);
-        }
-        await this.finalizeEventSafely(event.event_id, {
-          status: "failed",
-          code: "sender_bootstrap_failed",
-          msg: String(error2)
-        }, "sender bootstrap result send failed");
-        return;
-      }
-    }
-    if (!senderAllowed) {
-      this.logger.trace?.({
-        component: "worker.interaction",
-        stage: "sender_blocked",
-        event_id: event.event_id,
-        session_id: event.session_id,
-        sender_id: event.sender_id,
-        policy,
-        group_session: isGroupSession(rawPayload)
-      }, { level: "error" });
-      this.logger.debug(`event sender-blocked event=${event.event_id} sender=${event.sender_id} group=${isGroupSession(rawPayload)}`);
-      if (isGroupSession(rawPayload)) {
-        try {
-          await this.sendAccessStatusMessage(
-            event.session_id,
-            "This sender is not allowlisted for the Claude Grix channel.",
-            `sender_blocked_${event.event_id}`,
-            buildAccessStatusBizCard({
-              summary: "This sender is not allowlisted for the Claude Grix channel.",
-              status: "warning",
-              referenceID: event.event_id
-            })
-          );
-        } catch (error2) {
-          this.logger.error(`group allowlist notice failed event=${event.event_id}: ${String(error2)}`);
-        }
-        await this.finalizeEventSafely(event.event_id, {
-          status: "canceled",
-          code: "sender_not_allowlisted",
-          msg: "sender not allowlisted"
-        }, "group allowlist result send failed");
-        return;
-      }
-      try {
-        await this.sendPairingMessage(event);
-      } catch (error2) {
-        await this.finalizeEventSafely(event.event_id, {
-          status: "failed",
-          code: "pairing_send_failed",
-          msg: String(error2)
-        }, "pairing failure result send failed");
-      }
-      return;
-    }
-    const permissionRelayCommand = await this.permissionRelayService?.handleCommandEvent?.(event);
-    if (permissionRelayCommand?.handled) {
-      this.logger.trace?.({
-        component: "worker.interaction",
-        stage: "permission_relay_command_handled",
-        event_id: event.event_id,
-        session_id: event.session_id,
-        kind: permissionRelayCommand.kind
-      });
-      this.logger.debug(`event ${permissionRelayCommand.kind}-command event=${event.event_id}`);
-      return;
-    }
-    const elicitationCommand = await this.elicitationRelayService?.handleCommandEvent?.(event);
-    if (elicitationCommand?.handled) {
-      this.logger.trace?.({
-        component: "worker.interaction",
-        stage: "elicitation_command_handled",
-        event_id: event.event_id,
-        session_id: event.session_id,
-        kind: elicitationCommand.kind
-      });
-      this.logger.debug(`event ${elicitationCommand.kind}-command event=${event.event_id}`);
-      return;
-    }
     try {
       await this.dispatchChannelNotification(event);
       this.logger.trace?.({
@@ -24985,7 +24421,7 @@ var WorkerInteractionService = class {
     }
   }
   async handleStopEvent(rawPayload) {
-    const eventID = normalizeString25(rawPayload.event_id);
+    const eventID = normalizeString21(rawPayload.event_id);
     if (!eventID) {
       return;
     }
@@ -24996,7 +24432,7 @@ var WorkerInteractionService = class {
       session_id: rawPayload.session_id,
       stop_id: rawPayload.stop_id
     });
-    const stopID = normalizeString25(rawPayload.stop_id);
+    const stopID = normalizeString21(rawPayload.stop_id);
     const existing = this.eventState.get(eventID);
     try {
       await this.bridge.sendEventStopAck({
@@ -25053,7 +24489,7 @@ var WorkerInteractionService = class {
     }, "stop terminal result failed");
   }
   async handleRevokeEvent(rawPayload) {
-    const eventID = normalizeString25(rawPayload.event_id);
+    const eventID = normalizeString21(rawPayload.event_id);
     if (!eventID) {
       return;
     }
@@ -25072,6 +24508,35 @@ var WorkerInteractionService = class {
     });
     this.logger.info(`event_revoke acked event=${eventID}`);
   }
+  async handleLocalAction(rawPayload) {
+    const actionID = normalizeString21(rawPayload?.action_id);
+    if (!actionID) {
+      this.logger.error(`local_action missing action_id: ${JSON.stringify(rawPayload)}`);
+      return;
+    }
+    const actionType = normalizeString21(rawPayload?.action_type);
+    this.logger.trace?.({
+      component: "worker.interaction",
+      stage: "local_action_received",
+      action_id: actionID,
+      action_type: actionType,
+      event_id: rawPayload?.event_id
+    });
+    const permissionAction = await this.permissionRelayService?.handleLocalAction?.(rawPayload);
+    if (permissionAction?.handled) {
+      return;
+    }
+    const elicitationAction = await this.elicitationRelayService?.handleLocalAction?.(rawPayload);
+    if (elicitationAction?.handled) {
+      return;
+    }
+    await this.bridge.sendLocalActionResult({
+      actionID,
+      status: localActionResultStatuses.failed,
+      errorCode: localActionErrorCodes.unsupportedLocalAction,
+      errorMsg: actionType ? `unsupported local action: ${actionType}` : "local action type is required"
+    });
+  }
   async restoreEventState() {
     const entries = await loadEventEntries(this.eventStatesDir, {
       completedTTLms: this.eventState.ttlMs,
@@ -25113,7 +24578,6 @@ var WorkerInteractionService = class {
 
 // server/worker/permission-relay-service.js
 var pendingRequestTtlMs = 24 * 60 * 60 * 1e3;
-var permissionReplyPattern = /^\s*(y|yes|n|no)\s+([a-km-z]{5})\s*$/iu;
 var PermissionRequestNotificationSchema = NotificationSchema.extend({
   method: literal("notifications/claude/channel/permission_request"),
   params: object2({
@@ -25123,57 +24587,28 @@ var PermissionRequestNotificationSchema = NotificationSchema.extend({
     input_preview: string2()
   })
 });
-function normalizeString26(value) {
+function normalizeString22(value) {
   return String(value ?? "").trim();
 }
 function normalizeOptionalString6(value) {
-  const normalized = normalizeString26(value);
+  const normalized = normalizeString22(value);
   return normalized || "";
 }
-function parsePermissionReply(text) {
-  const match = permissionReplyPattern.exec(String(text ?? ""));
-  if (!match) {
-    return {
-      matched: false,
-      request_id: "",
-      behavior: ""
-    };
-  }
-  return {
-    matched: true,
-    request_id: normalizeString26(match[2]).toLowerCase(),
-    behavior: normalizeString26(match[1]).toLowerCase().startsWith("y") ? "allow" : "deny"
-  };
-}
-function buildStatusResult(code, msg) {
-  return {
-    status: "responded",
-    code,
-    msg
-  };
-}
 var WorkerPermissionRelayService = class {
   constructor({
     mcp,
     bridge,
-    accessStore,
     eventState,
-    finalizeEvent,
     logger,
     aibotSessionID = ""
   }) {
     this.mcp = mcp;
     this.bridge = bridge;
-    this.accessStore = accessStore;
     this.eventState = eventState;
-    this.finalizeEvent = typeof finalizeEvent === "function" ? finalizeEvent : async () => false;
     this.logger = logger;
     this.aibotSessionID = normalizeOptionalString6(aibotSessionID);
     this.pendingRequests = /* @__PURE__ */ new Map();
   }
-  async finalizeEventSafely(eventID, result, context) {
-    return this.finalizeEvent(eventID, result, context);
-  }
   registerHandlers() {
     this.mcp.setNotificationHandler(
       PermissionRequestNotificationSchema,
@@ -25185,13 +24620,12 @@ var WorkerPermissionRelayService = class {
   getStatus() {
     this.prunePendingRequests();
     return {
-      pending_count: this.pendingRequests.size,
-      pending_request_ids: Array.from(this.pendingRequests.keys()).sort()
+      pending_count: this.pendingRequests.size
     };
   }
   prunePendingRequests(now = Date.now()) {
-    for (const [requestID, request] of this.pendingRequests.entries()) {
-      if (now - Number(request.created_at ?? 0) > pendingRequestTtlMs) {
+    for (const [requestID, createdAt] of this.pendingRequests.entries()) {
+      if (now - Number(createdAt ?? 0) > pendingRequestTtlMs) {
         this.pendingRequests.delete(requestID);
       }
     }
@@ -25200,16 +24634,20 @@ var WorkerPermissionRelayService = class {
     this.prunePendingRequests();
     return this.eventState.getLatestActiveBySession(this.aibotSessionID);
   }
+  hasPendingRequest(requestID) {
+    this.prunePendingRequests();
+    return this.pendingRequests.has(normalizeString22(requestID));
+  }
+  async forwardPermissionReply({ requestID, behavior }) {
+    await this.mcp.notification({
+      method: "notifications/claude/channel/permission",
+      params: {
+        request_id: normalizeString22(requestID),
+        behavior: normalizeString22(behavior)
+      }
+    });
+  }
   async handlePermissionRequest(params) {
-    if (!this.accessStore.hasApprovers()) {
-      this.logger.trace?.({
-        component: "worker.permission_relay",
-        stage: "permission_request_skipped",
-        reason: "no_approvers",
-        request_id: params.request_id
-      });
-      return;
-    }
     const activeEvent = this.getActiveEventContext();
     if (!activeEvent) {
       this.logger.trace?.({
@@ -25220,175 +24658,133 @@ var WorkerPermissionRelayService = class {
       });
       return;
     }
-    const request = {
-      request_id: normalizeString26(params.request_id),
-      tool_name: normalizeString26(params.tool_name),
-      description: normalizeString26(params.description),
-      input_preview: normalizeString26(params.input_preview),
-      created_at: Date.now(),
-      channel_context: {
-        chat_id: activeEvent.session_id,
-        event_id: activeEvent.event_id,
-        message_id: activeEvent.msg_id,
-        msg_id: activeEvent.msg_id,
-        sender_id: activeEvent.sender_id,
-        user_id: activeEvent.sender_id
-      }
+    const requestID = normalizeString22(params.request_id);
+    const createdAt = Date.now();
+    const channelContext = {
+      chat_id: activeEvent.session_id,
+      message_id: activeEvent.msg_id
     };
     try {
-      const ack = await this.bridge.sendText({
-        sessionID: request.channel_context.chat_id,
-        text: buildPermissionRelayRequestText(request),
-        quotedMessageID: request.channel_context.message_id || request.channel_context.msg_id,
-        clientMsgID: `permission_request_${request.request_id}`,
-        extra: {
-          reply_source: "claude_permission_request",
-          approval_request_id: request.request_id,
-          biz_card: buildPermissionRelayRequestBizCard(request, {
-            expiresAtMs: request.created_at + pendingRequestTtlMs
-          })
-        }
-      });
-      this.pendingRequests.set(request.request_id, {
-        ...request,
-        approval_message_id: normalizeOptionalString6(ack?.msg_id)
+      const invokeResult = await this.bridge.agentInvoke({
+        invokeID: `permission_request_${requestID}`,
+        action: agentInvokeActions.interactionRequestCreate,
+        params: buildInteractionRequestInvokeParams({
+          kind: interactionKinds.permission,
+          requestID,
+          sessionID: channelContext.chat_id,
+          messageID: channelContext.message_id,
+          payload: buildPermissionInteractionPayload(params)
+        })
       });
+      if (Number(invokeResult?.code ?? 0) !== 0) {
+        throw new Error(normalizeOptionalString6(invokeResult?.msg) || "agent invoke failed");
+      }
+      this.pendingRequests.set(requestID, createdAt);
       this.logger.trace?.({
         component: "worker.permission_relay",
-        stage: "permission_request_dispatched",
-        request_id: request.request_id,
-        event_id: request.channel_context.event_id,
-        chat_id: request.channel_context.chat_id,
-        msg_id: request.channel_context.message_id || request.channel_context.msg_id
+        stage: "permission_request_forwarded",
+        request_id: requestID,
+        chat_id: channelContext.chat_id,
+        msg_id: channelContext.message_id
       });
     } catch (error2) {
       this.logger.error(
-        `permission request dispatch failed request=${request.request_id}: ${String(error2)}`
+        `permission request dispatch failed request=${requestID}: ${String(error2)}`
       );
     }
   }
-  async sendApprovalReply(event, text, bizCard = null) {
-    await this.bridge.sendText({
-      eventID: event.event_id,
-      sessionID: event.session_id,
-      text,
-      quotedMessageID: event.msg_id,
-      clientMsgID: `approval_reply_${event.event_id}`,
-      extra: {
-        reply_source: "claude_channel_approval",
-        ...bizCard ? { biz_card: bizCard } : {}
-      }
-    });
-  }
-  async handleCommandEvent(event) {
-    const parsed = parsePermissionReply(event.content);
-    if (!parsed.matched) {
+  async handleLocalAction(rawPayload) {
+    const resolved = parseInteractionReplyAction(rawPayload);
+    if (!resolved.matched) {
       return {
         handled: false,
         kind: ""
       };
     }
-    if (!this.accessStore.isSenderApprover(event.sender_id)) {
-      const summary = "This sender is not configured as a Claude approval approver.";
-      await this.sendApprovalReply(event, summary, buildApprovalCommandStatusBizCard({
-        summary,
-        status: "warning",
-        referenceID: parsed.request_id
-      }));
-      await this.finalizeEventSafely(
-        event.event_id,
-        buildStatusResult("approval_sender_not_authorized", "sender not configured as approver"),
-        "permission reply unauthorized terminal result failed"
-      );
+    if (resolved.kind && resolved.kind !== "permission") {
+      return {
+        handled: false,
+        kind: ""
+      };
+    }
+    const actionID = normalizeString22(rawPayload?.action_id);
+    const requestID = normalizeString22(resolved.requestID);
+    if (!actionID) {
+      this.logger.error(`permission local_action missing action_id: ${JSON.stringify(rawPayload)}`);
       return {
         handled: true,
         kind: "approval"
       };
     }
-    const request = this.pendingRequests.get(parsed.request_id);
-    if (!request) {
-      const summary = `Approval request ${parsed.request_id} is not open.`;
-      await this.sendApprovalReply(event, summary, buildApprovalCommandStatusBizCard({
-        summary,
-        referenceID: parsed.request_id,
-        status: "warning"
-      }));
-      await this.finalizeEventSafely(
-        event.event_id,
-        buildStatusResult("approval_request_not_open", "approval request is not open"),
-        "permission reply missing terminal result failed"
-      );
+    if (!requestID) {
+      await this.bridge.sendLocalActionResult({
+        actionID,
+        status: localActionResultStatuses.failed,
+        errorCode: interactionReplyErrorCodes.requestIDRequired,
+        errorMsg: "interaction request id is required"
+      });
       return {
         handled: true,
         kind: "approval"
       };
     }
-    if (request.channel_context.chat_id !== event.session_id) {
-      const summary = "This approval request belongs to a different Grix chat.";
-      await this.sendApprovalReply(event, summary, buildApprovalCommandStatusBizCard({
-        summary,
-        referenceID: parsed.request_id,
-        status: "warning"
-      }));
-      await this.finalizeEventSafely(
-        event.event_id,
-        buildStatusResult("approval_chat_mismatch", "approval request belongs to a different chat"),
-        "permission reply chat-mismatch terminal result failed"
-      );
+    if (!this.hasPendingRequest(requestID)) {
+      await this.bridge.sendLocalActionResult({
+        actionID,
+        status: localActionResultStatuses.failed,
+        errorCode: interactionReplyErrorCodes.requestNotPending,
+        errorMsg: `interaction request ${requestID} is not pending`
+      });
+      return {
+        handled: true,
+        kind: "approval"
+      };
+    }
+    if (!resolved.resolution || resolved.resolution.type !== "decision") {
+      await this.bridge.sendLocalActionResult({
+        actionID,
+        status: localActionResultStatuses.failed,
+        errorCode: resolved.errorCode || interactionReplyErrorCodes.resolutionInvalid,
+        errorMsg: resolved.errorMsg || "interaction resolution is invalid"
+      });
       return {
         handled: true,
         kind: "approval"
       };
     }
+    const behavior = resolved.resolution.value === "allow" ? "allow" : "deny";
     try {
-      await this.mcp.notification({
-        method: "notifications/claude/channel/permission",
-        params: {
-          request_id: parsed.request_id,
-          behavior: parsed.behavior
-        }
+      await this.forwardPermissionReply({
+        requestID,
+        behavior
       });
     } catch (error2) {
-      const summary = `Failed to send approval reply for request ${parsed.request_id}.`;
-      await this.sendApprovalReply(event, summary, buildApprovalCommandStatusBizCard({
-        summary,
-        referenceID: parsed.request_id,
-        detailText: String(error2),
-        status: "error"
-      }));
-      await this.finalizeEventSafely(
-        event.event_id,
-        buildStatusResult("approval_forward_failed", "approval verdict send failed"),
-        "permission reply forward terminal result failed"
-      );
+      await this.bridge.sendLocalActionResult({
+        actionID,
+        status: localActionResultStatuses.failed,
+        errorCode: interactionReplyErrorCodes.forwardFailed,
+        errorMsg: String(error2)
+      });
       return {
         handled: true,
         kind: "approval"
       };
     }
-    this.pendingRequests.delete(parsed.request_id);
-    const responseText = buildPermissionRelayVerdictText({
-      requestID: parsed.request_id,
-      behavior: parsed.behavior
+    this.pendingRequests.delete(requestID);
+    await this.bridge.sendLocalActionResult({
+      actionID,
+      status: localActionResultStatuses.ok,
+      result: buildInteractionReplyResult({
+        kind: interactionKinds.permission,
+        requestID
+      })
     });
-    await this.sendApprovalReply(event, responseText, buildPermissionRelaySubmittedBizCard({
-      request,
-      behavior: parsed.behavior,
-      resolvedByID: event.sender_id
-    }));
-    await this.finalizeEventSafely(
-      event.event_id,
-      buildStatusResult("approval_forwarded", "approval verdict sent to Claude"),
-      "permission reply recorded terminal result failed"
-    );
     this.logger.trace?.({
       component: "worker.permission_relay",
-      stage: "permission_reply_forwarded",
-      event_id: event.event_id,
-      session_id: event.session_id,
-      sender_id: event.sender_id,
-      request_id: parsed.request_id,
-      behavior: parsed.behavior
+      stage: "permission_local_action_forwarded",
+      action_id: actionID,
+      request_id: requestID,
+      behavior
     });
     return {
       handled: true,
@@ -25404,8 +24800,8 @@ var WorkerPermissionRelayService = class {
 import { randomUUID as randomUUID4 } from "node:crypto";
 
 // server/attachment-file.js
-import path8 from "node:path";
-import { readFile as readFile2, stat } from "node:fs/promises";
+import path7 from "node:path";
+import { readFile as readFile2, stat as stat2 } from "node:fs/promises";
 var maxReplyFileBytes = 50 * 1024 * 1024;
 var uploadableFileExtensions = /* @__PURE__ */ new Set([
   "pdf",
@@ -25440,15 +24836,15 @@ var uploadableFileExtensions = /* @__PURE__ */ new Set([
   "mkv",
   "avi"
 ]);
-function normalizeString27(value) {
+function normalizeString23(value) {
   return String(value ?? "").trim();
 }
 function extensionOf(fileName) {
-  const extension = path8.extname(normalizeString27(fileName)).toLowerCase();
+  const extension = path7.extname(normalizeString23(fileName)).toLowerCase();
   return extension.startsWith(".") ? extension.slice(1) : extension;
 }
 function resolveAttachmentType(contentType) {
-  const normalized = normalizeString27(contentType).toLowerCase();
+  const normalized = normalizeString23(contentType).toLowerCase();
   if (normalized.startsWith("image/")) {
     return "image";
   }
@@ -25525,14 +24921,14 @@ function resolveContentType(fileName) {
   }
 }
 async function readReplyFile(filePath) {
-  const normalizedPath = normalizeString27(filePath);
+  const normalizedPath = normalizeString23(filePath);
   if (!normalizedPath) {
     throw new Error("reply.files entries must be non-empty absolute paths");
   }
-  if (!path8.isAbsolute(normalizedPath)) {
+  if (!path7.isAbsolute(normalizedPath)) {
     throw new Error(`reply.files requires an absolute path: ${normalizedPath}`);
   }
-  const fileStat = await stat(normalizedPath);
+  const fileStat = await stat2(normalizedPath);
   if (!fileStat.isFile()) {
     throw new Error(`reply.files path is not a file: ${normalizedPath}`);
   }
@@ -25542,7 +24938,7 @@ async function readReplyFile(filePath) {
   if (fileStat.size > maxReplyFileBytes) {
     throw new Error(`reply.files exceeds 50MB: ${normalizedPath}`);
   }
-  const fileName = path8.basename(normalizedPath);
+  const fileName = path7.basename(normalizedPath);
   const extension = extensionOf(fileName);
   if (!extension || !uploadableFileExtensions.has(extension)) {
     throw new Error(`reply.files unsupported file type: ${fileName}`);
@@ -25560,10 +24956,10 @@ async function readReplyFile(filePath) {
 }
 function buildAttachmentExtra({ attachmentType, fileName, accessURL, contentType }) {
   const attachment = {
-    media_url: normalizeString27(accessURL),
-    attachment_type: normalizeString27(attachmentType),
-    file_name: normalizeString27(fileName),
-    content_type: normalizeString27(contentType)
+    media_url: normalizeString23(accessURL),
+    attachment_type: normalizeString23(attachmentType),
+    file_name: normalizeString23(fileName),
+    content_type: normalizeString23(contentType)
   };
   return {
     ...attachment,
@@ -25572,20 +24968,20 @@ function buildAttachmentExtra({ attachmentType, fileName, accessURL, contentType
 }
 
 // server/agent-api-media.js
-function normalizeString28(value) {
+function normalizeString24(value) {
   return String(value ?? "").trim();
 }
 function trimTrailingSlash(value) {
-  return normalizeString28(value).replace(/\/+$/u, "");
+  return normalizeString24(value).replace(/\/+$/u, "");
 }
 function parseJSONResponseBody(text) {
-  if (!normalizeString28(text)) {
+  if (!normalizeString24(text)) {
     return {};
   }
   return JSON.parse(text);
 }
 function resolveAgentAPIPresignURL(wsURL) {
-  const url2 = new URL(normalizeString28(wsURL));
+  const url2 = new URL(normalizeString24(wsURL));
   if (url2.protocol !== "ws:" && url2.protocol !== "wss:") {
     throw new Error("ws_url must start with ws:// or wss://");
   }
@@ -25603,23 +24999,23 @@ async function requestPresign({ wsURL, apiKey, sessionID, fileName, contentType,
   const response = await fetchImpl(resolveAgentAPIPresignURL(wsURL), {
     method: "POST",
     headers: {
-      Authorization: `Bearer ${normalizeString28(apiKey)}`,
+      Authorization: `Bearer ${normalizeString24(apiKey)}`,
       "Content-Type": "application/json"
     },
     body: JSON.stringify({
-      session_id: normalizeString28(sessionID),
-      filename: normalizeString28(fileName),
-      content_type: normalizeString28(contentType)
+      session_id: normalizeString24(sessionID),
+      filename: normalizeString24(fileName),
+      content_type: normalizeString24(contentType)
     })
   });
   const rawBody = await response.text();
   const payload = parseJSONResponseBody(rawBody);
   if (!response.ok || Number(payload?.code ?? -1) !== 0) {
-    const message = normalizeString28(payload?.msg) || response.statusText || "agent media presign failed";
+    const message = normalizeString24(payload?.msg) || response.statusText || "agent media presign failed";
     throw new Error(`agent media presign failed: ${message}`);
   }
-  const uploadURL = normalizeString28(payload?.data?.upload_url);
-  const accessURL = normalizeString28(payload?.data?.media_access_url);
+  const uploadURL = normalizeString24(payload?.data?.upload_url);
+  const accessURL = normalizeString24(payload?.data?.media_access_url);
   if (!uploadURL || !accessURL) {
     throw new Error("agent media presign returned incomplete upload_url/media_access_url");
   }
@@ -25632,7 +25028,7 @@ async function uploadPresignedFile({ uploadURL, contentType, bytes, fetchImpl })
   const response = await fetchImpl(uploadURL, {
     method: "PUT",
     headers: {
-      "Content-Type": normalizeString28(contentType)
+      "Content-Type": normalizeString24(contentType)
     },
     body: bytes
   });
@@ -25721,21 +25117,18 @@ function splitTextForAibotProtocol(text, preferredRunes) {
 }
 
 // server/worker/tool-service.js
-function normalizeString29(value) {
+function normalizeString25(value) {
   return String(value ?? "").trim();
 }
 function normalizeOptionalString7(value) {
-  const normalized = normalizeString29(value);
+  const normalized = normalizeString25(value);
   return normalized || "";
 }
 function normalizeStringArray4(value) {
   if (!Array.isArray(value)) {
     return [];
   }
-  return value.map((item) => normalizeString29(item)).filter((item) => item);
-}
-function mergeRecords(...records) {
-  return Object.assign({}, ...records);
+  return value.map((item) => normalizeString25(item)).filter((item) => item);
 }
 function toolTextResult(value) {
   return {
@@ -25809,7 +25202,7 @@ var toolDefinitions = [
   },
   {
     name: "status",
-    description: "Show grix-claude configuration, access policy, daemon bridge status, and startup hints.",
+    description: "Show grix-claude runtime status, upstream access state, bridge health, and startup hints.",
     inputSchema: {
       type: "object",
       properties: {}
@@ -25817,7 +25210,7 @@ var toolDefinitions = [
   },
   {
     name: "access_pair",
-    description: "Approve a pending sender pairing code and add that sender to the allowlist.",
+    description: "Forward a sender pairing approval code to upstream access control.",
     inputSchema: {
       type: "object",
       properties: {
@@ -25828,7 +25221,7 @@ var toolDefinitions = [
   },
   {
     name: "access_deny",
-    description: "Deny a pending sender pairing code and clear it from pending state.",
+    description: "Forward a sender pairing denial code to upstream access control.",
     inputSchema: {
       type: "object",
       properties: {
@@ -25839,7 +25232,7 @@ var toolDefinitions = [
   },
   {
     name: "allow_sender",
-    description: "Add a sender_id directly to the allowlist.",
+    description: "Ask upstream access control to allow a sender_id.",
     inputSchema: {
       type: "object",
       properties: {
@@ -25850,29 +25243,7 @@ var toolDefinitions = [
   },
   {
     name: "remove_sender",
-    description: "Remove a sender_id from the allowlist.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        sender_id: { type: "string" }
-      },
-      required: ["sender_id"]
-    }
-  },
-  {
-    name: "allow_approver",
-    description: "Add a sender_id to the Claude remote approval allowlist.",
-    inputSchema: {
-      type: "object",
-      properties: {
-        sender_id: { type: "string" }
-      },
-      required: ["sender_id"]
-    }
-  },
-  {
-    name: "remove_approver",
-    description: "Remove a sender_id from the Claude remote approval allowlist.",
+    description: "Ask upstream access control to remove a sender_id.",
     inputSchema: {
       type: "object",
       properties: {
@@ -25883,7 +25254,7 @@ var toolDefinitions = [
   },
   {
     name: "access_policy",
-    description: "Update the sender access policy for this channel.",
+    description: "Ask upstream access control to update the sender access policy.",
     inputSchema: {
       type: "object",
       properties: {
@@ -25898,8 +25269,6 @@ var WorkerToolService = class {
     mcp,
     bridge,
     configStore,
-    accessStore,
-    approvalStore,
     elicitationStore,
     permissionRelayService = null,
     eventState,
@@ -25909,27 +25278,55 @@ var WorkerToolService = class {
     this.mcp = mcp;
     this.bridge = bridge;
     this.configStore = configStore;
-    this.accessStore = accessStore;
-    this.approvalStore = approvalStore;
     this.elicitationStore = elicitationStore;
     this.permissionRelayService = permissionRelayService;
     this.eventState = eventState;
     this.messageRuntime = messageRuntime;
     this.logger = logger;
   }
+  async forwardAccessAction(verb, payload = {}) {
+    const invokeResult = await this.bridge.agentInvoke({
+      invokeID: `${agentInvokeActions.accessControl}_${normalizeString25(verb)}_${randomUUID4()}`,
+      action: agentInvokeActions.accessControl,
+      params: {
+        verb: normalizeString25(verb),
+        payload: payload && typeof payload === "object" && !Array.isArray(payload) ? payload : {}
+      }
+    });
+    const code = Number(invokeResult?.code ?? 5001);
+    if (code !== 0) {
+      throw new Error(normalizeString25(invokeResult?.msg) || `claude access invoke failed: ${verb}`);
+    }
+    return invokeResult?.data ?? {};
+  }
   async buildStatusPayload() {
+    let upstreamAccess = null;
+    try {
+      upstreamAccess = await this.forwardAccessAction(accessControlVerbs.statusRead);
+    } catch (error2) {
+      upstreamAccess = {
+        unavailable: true,
+        error: error2 instanceof Error ? error2.message : String(error2)
+      };
+    }
+    const approvalStatus = this.permissionRelayService?.getStatus?.() ?? {
+      pending_count: 0
+    };
+    const questionStatus = await this.elicitationStore.getStatus();
     return {
       config: this.configStore.getStatus(),
-      access: this.accessStore.getStatus(),
-      approvals: this.permissionRelayService?.getStatus?.() ?? await this.approvalStore.getStatus(),
-      questions: await this.elicitationStore.getStatus(),
+      upstream_access: upstreamAccess,
+      local_bridge: {
+        pending_approval_requests: Number(approvalStatus.pending_count ?? 0),
+        pending_question_requests: Number(questionStatus.pending_count ?? 0)
+      },
       connection: this.bridge.getConnectionStatus(),
       hints: this.bridge.buildStatusHints()
     };
   }
   async handleReplyTool(args) {
-    const chatID = normalizeString29(args.chat_id);
-    const eventID = normalizeString29(args.event_id);
+    const chatID = normalizeString25(args.chat_id);
+    const eventID = normalizeString25(args.event_id);
     const replyTo = normalizeOptionalString7(args.reply_to);
     const text = String(args.text ?? "");
     const files = normalizeStringArray4(args.files);
@@ -25987,10 +25384,7 @@ var WorkerToolService = class {
           sessionID: chatID,
           text: chunk,
           quotedMessageID: replyTo || current.msg_id,
-          clientMsgID: `${randomUUID4()}_${chunkIndex}`,
-          extra: {
-            reply_source: "claude_channel"
-          }
+          clientMsgID: `${randomUUID4()}_${chunkIndex}`
         });
         const messageID = normalizeOptionalString7(ack.msg_id);
         if (messageID) {
@@ -26016,12 +25410,7 @@ var WorkerToolService = class {
           caption: upload.file_name,
           quotedMessageID: replyTo || current.msg_id,
           clientMsgID: `${randomUUID4()}_${chunkIndex}`,
-          extra: mergeRecords(
-            {
-              reply_source: "claude_channel"
-            },
-            upload.extra
-          )
+          extra: upload.extra
         });
         const messageID = normalizeOptionalString7(ack.msg_id);
         if (messageID) {
@@ -26069,8 +25458,8 @@ var WorkerToolService = class {
     return toolTextResult("sent");
   }
   async handleCompleteTool(args) {
-    const eventID = normalizeString29(args.event_id);
-    const status = normalizeString29(args.status);
+    const eventID = normalizeString25(args.event_id);
+    const status = normalizeString25(args.status);
     const code = normalizeOptionalString7(args.code);
     const msg = normalizeOptionalString7(args.msg);
     this.logger.debug(
@@ -26119,8 +25508,8 @@ var WorkerToolService = class {
     return toolTextResult(await this.buildStatusPayload());
   }
   async handleDeleteMessageTool(args) {
-    const chatID = normalizeString29(args.chat_id);
-    const messageID = normalizeString29(args.message_id);
+    const chatID = normalizeString25(args.chat_id);
+    const messageID = normalizeString25(args.message_id);
     this.logger.debug(`tool delete_message chat=${chatID} message=${messageID}`);
     if (!chatID || !messageID) {
       throw new Error("delete_message requires chat_id and message_id");
@@ -26134,89 +25523,46 @@ var WorkerToolService = class {
     await this.bridge.deleteMessage(chatID, messageID);
     return toolTextResult(`deleted (${messageID})`);
   }
-  async notifyApprovedSender(sessionID) {
-    try {
-      await this.messageRuntime.sendAccessStatusMessage(
-        sessionID,
-        "Paired! Say hi to Claude.",
-        `pair_ok_${randomUUID4()}`,
-        buildAccessStatusBizCard({
-          summary: "Paired! Say hi to Claude.",
-          status: "success"
-        })
-      );
-      return true;
-    } catch (error2) {
-      this.logger.error(`pairing confirmation send failed session=${sessionID}: ${String(error2)}`);
-      return false;
-    }
-  }
-  async notifyDeniedSender(sessionID, code) {
-    try {
-      await this.messageRuntime.sendAccessStatusMessage(
-        sessionID,
-        `Pairing request ${code} was denied. Ask the Claude Code user to request a new pairing code if you still need access.`,
-        `pair_denied_${randomUUID4()}`,
-        buildAccessStatusBizCard({
-          summary: `Pairing request ${code} was denied. Ask the Claude Code user to request a new pairing code if you still need access.`,
-          status: "warning",
-          referenceID: code
-        })
-      );
-      return true;
-    } catch (error2) {
-      this.logger.error(`pairing denial send failed session=${sessionID}: ${String(error2)}`);
-      return false;
-    }
-  }
   async handleAccessPairTool(args) {
-    const result = await this.accessStore.approvePairing(args.code);
-    const pairing_notice_sent = await this.notifyApprovedSender(result.session_id);
+    const result = await this.forwardAccessAction(accessControlVerbs.pairApprove, {
+      code: normalizeString25(args.code)
+    });
     return toolTextResult({
       ...result,
-      pairing_notice_sent,
       hints: this.bridge.buildStatusHints()
     });
   }
   async handleAccessDenyTool(args) {
-    const result = await this.accessStore.denyPairing(args.code);
-    const pairing_notice_sent = await this.notifyDeniedSender(result.session_id, result.code);
+    const result = await this.forwardAccessAction(accessControlVerbs.pairDeny, {
+      code: normalizeString25(args.code)
+    });
     return toolTextResult({
       ...result,
-      pairing_notice_sent,
       hints: this.bridge.buildStatusHints()
     });
   }
   async handleAllowSenderTool(args) {
-    const result = await this.accessStore.allowSender(args.sender_id);
-    return toolTextResult({
-      ...result,
-      hints: this.bridge.buildStatusHints()
+    const result = await this.forwardAccessAction(accessControlVerbs.senderAllow, {
+      sender_id: normalizeString25(args.sender_id)
     });
-  }
-  async handleAllowApproverTool(args) {
-    const result = await this.accessStore.allowApprover(args.sender_id);
     return toolTextResult({
       ...result,
       hints: this.bridge.buildStatusHints()
     });
   }
   async handleRemoveSenderTool(args) {
-    const result = await this.accessStore.removeSender(args.sender_id);
-    return toolTextResult({
-      ...result,
-      hints: this.bridge.buildStatusHints()
+    const result = await this.forwardAccessAction(accessControlVerbs.senderRemove, {
+      sender_id: normalizeString25(args.sender_id)
     });
-  }
-  async handleRemoveApproverTool(args) {
-    const result = await this.accessStore.removeApprover(args.sender_id);
     return toolTextResult({
       ...result,
       hints: this.bridge.buildStatusHints()
     });
   }
   async handleAccessPolicyTool(args) {
-    const result = await this.accessStore.setPolicy(args.policy);
+    const result = await this.forwardAccessAction(accessControlVerbs.policySet, {
+      policy: normalizeString25(args.policy)
+    });
     return toolTextResult({
       ...result,
       hints: this.bridge.buildStatusHints()
@@ -26240,7 +25586,7 @@ var WorkerToolService = class {
       };
     });
     this.mcp.setRequestHandler(CallToolRequestSchema, async (request) => {
-      const name = normalizeString29(request.params.name);
+      const name = normalizeString25(request.params.name);
       const args = request.params.arguments ?? {};
       this.logger.trace?.({
         component: "worker.tool",
@@ -26277,12 +25623,6 @@ var WorkerToolService = class {
           case "remove_sender":
             result = await this.handleRemoveSenderTool(args);
             break;
-          case "allow_approver":
-            result = await this.handleAllowApproverTool(args);
-            break;
-          case "remove_approver":
-            result = await this.handleRemoveApproverTool(args);
-            break;
           case "access_policy":
             result = await this.handleAccessPolicyTool(args);
             break;
@@ -26313,11 +25653,11 @@ var WorkerToolService = class {
 };
 
 // server/worker/app.js
-function normalizeString30(value) {
+function normalizeString26(value) {
   return String(value ?? "").trim();
 }
 function normalizeOptionalString8(value) {
-  const normalized = normalizeString30(value);
+  const normalized = normalizeString26(value);
   return normalized || "";
 }
 function parsePositiveInt(value, fallbackValue) {
@@ -26331,6 +25671,7 @@ function buildInstructions() {
   return [
     'Messages arrive as <channel source="grix-claude" chat_id="..." event_id="..." message_id="..." user_id="...">text</channel>.',
     "When present, channel metadata includes msg_type plus JSON strings in attachments_json, biz_card_json, channel_data_json, and extra_json. Use those structured fields directly instead of guessing attachment or card semantics from text.",
+    "When context_messages_json is present, treat it as the visible messages immediately before the current trigger message. Use it as context only, and answer only the current message.",
     'If channel_data_json marks {"grix-claude":{"internal_probe":{"kind":"ping_pong"}}}, reply with exactly pong and nothing else.',
     "If you want to send a visible reply back to the same chat, call the reply tool with chat_id, event_id, and text. You may also pass reply_to when you want to quote a specific message_id.",
     "The reply tool also accepts files as absolute local paths. Files are uploaded through the Agent API media presign endpoint before they are sent back to the chat.",
@@ -26343,11 +25684,6 @@ function createWorkerApp({ env = process4.env } = {}) {
   const logger = createProcessLogger({ env });
   const eventStatesDir = resolveEventStatesDir();
   const configStore = new ConfigStore(resolveConfigPath());
-  const accessStore = new AccessStore(resolveAccessPath());
-  const approvalStore = new ApprovalStore({
-    requestsDir: resolveApprovalRequestsDir(),
-    notificationsDir: resolveApprovalNotificationsDir()
-  });
   const elicitationStore = new ElicitationStore({
     requestsDir: resolveElicitationRequestsDir()
   });
@@ -26390,27 +25726,26 @@ function createWorkerApp({ env = process4.env } = {}) {
     },
     onDeliverRevoke: async (payload) => {
       await interactionService?.handleRevokeEvent(payload);
+    },
+    onDeliverLocalAction: async (payload) => {
+      await interactionService?.handleLocalAction(payload);
     }
   });
   const elicitationRelayService = new WorkerElicitationRelayService({
     elicitationStore,
     bridge,
-    finalizeEvent: async (eventID, result, context) => interactionService?.finalizeEventSafely?.(eventID, result, context) ?? false,
     logger
   });
   const permissionRelayService = new WorkerPermissionRelayService({
     mcp,
     bridge,
-    accessStore,
     eventState,
-    finalizeEvent: async (eventID, result, context) => interactionService?.finalizeEventSafely?.(eventID, result, context) ?? false,
     logger,
     aibotSessionID: normalizeOptionalString8(env.GRIX_CLAUDE_AIBOT_SESSION_ID)
   });
   interactionService = new WorkerInteractionService({
     eventState,
     sessionContextStore,
-    accessStore,
     eventStatesDir,
     mcp,
     bridge,
@@ -26426,8 +25761,6 @@ function createWorkerApp({ env = process4.env } = {}) {
     mcp,
     bridge,
     configStore,
-    accessStore,
-    approvalStore,
     elicitationStore,
     permissionRelayService,
     eventState,
@@ -26440,8 +25773,6 @@ function createWorkerApp({ env = process4.env } = {}) {
     logger,
     async bootstrap() {
       await configStore.load();
-      await accessStore.load();
-      await approvalStore.init();
       await elicitationStore.init();
       await interactionService.restoreEventState();
       await bridge.startControlServer();