@velanir/openclaw-pending-context 0.4.0

package/dist/index.js

@@ -0,0 +1,1540 @@
+// src/api.ts
+import { definePluginEntry as defineOpenClawPluginEntry } from "openclaw/plugin-sdk/plugin-entry";
+function definePluginEntry(entry) {
+  return defineOpenClawPluginEntry(entry);
+}
+
+// src/authorization.ts
+var ACTION_TOOLS = /* @__PURE__ */ new Set([
+  "responsibility_select_option",
+  "responsibility_reject",
+  "responsibility_change"
+]);
+function clean(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function cleanIdentity(value) {
+  const cleaned = clean(value);
+  if (!cleaned) return void 0;
+  let normalized = cleaned;
+  for (; ; ) {
+    const next = normalized.replace(/^(?:user|chat|channel|msteams):/i, "");
+    if (next === normalized) return normalized.toLowerCase();
+    normalized = next;
+  }
+}
+function trustedInboundFromHook(event, ctx, receivedAt = Date.now()) {
+  const messageId = clean(event.messageId) ?? clean(ctx.messageId);
+  const senderId = cleanIdentity(event.senderId) ?? cleanIdentity(ctx.senderId) ?? cleanIdentity(event.from);
+  const sessionKey = clean(event.sessionKey) ?? clean(ctx.sessionKey);
+  const runId = clean(event.runId) ?? clean(ctx.runId);
+  if (!messageId || !senderId || !sessionKey) return null;
+  return {
+    messageId,
+    senderId,
+    sessionKey,
+    ...runId ? { runId } : {},
+    ...clean(event.channel) ?? clean(ctx.channelId) ? { channel: clean(event.channel) ?? clean(ctx.channelId) } : {},
+    ...clean(ctx.accountId) ? { accountId: clean(ctx.accountId) } : {},
+    ...clean(ctx.conversationId) ? { conversationId: clean(ctx.conversationId) } : {},
+    receivedAt
+  };
+}
+function createInboundAuthorizationState() {
+  return {
+    byRun: /* @__PURE__ */ new Map(),
+    bySession: /* @__PURE__ */ new Map(),
+    byToolCall: /* @__PURE__ */ new Map(),
+    usedMessageIds: /* @__PURE__ */ new Map()
+  };
+}
+function sharedInboundAuthorizationState() {
+  const runtime = globalThis;
+  runtime.__velanirPendingContextAuthorizationV1 ??= createInboundAuthorizationState();
+  return runtime.__velanirPendingContextAuthorizationV1;
+}
+function createInboundAuthorizationStore(ttlMs, now = Date.now, state = createInboundAuthorizationState()) {
+  const { byRun, bySession, byToolCall, usedMessageIds } = state;
+  const fresh = (record) => record && now() - record.receivedAt <= ttlMs ? record : void 0;
+  const prune = () => {
+    for (const [key, record] of byRun) if (!fresh(record)) byRun.delete(key);
+    for (const [key, record] of bySession) if (!fresh(record)) bySession.delete(key);
+    for (const [key, record] of byToolCall) if (!fresh(record)) byToolCall.delete(key);
+    for (const [key, usedAt] of usedMessageIds) if (now() - usedAt > ttlMs) usedMessageIds.delete(key);
+  };
+  return {
+    recordTrusted(record) {
+      prune();
+      if (!fresh(record)) return false;
+      if (record.runId) byRun.set(record.runId, record);
+      bySession.set(record.sessionKey, record);
+      return true;
+    },
+    recordInbound(event, ctx) {
+      prune();
+      const record = trustedInboundFromHook(event, ctx, now());
+      return record ? this.recordTrusted(record) : false;
+    },
+    bindTool(event, ctx) {
+      prune();
+      const toolName = clean(event.toolName) ?? clean(ctx.toolName);
+      const toolCallId = clean(event.toolCallId) ?? clean(ctx.toolCallId);
+      if (!toolName || !ACTION_TOOLS.has(toolName) || !toolCallId) return false;
+      const runId = clean(event.runId) ?? clean(ctx.runId);
+      const sessionKey = clean(ctx.sessionKey);
+      const record = fresh(runId ? byRun.get(runId) : void 0) ?? fresh(sessionKey ? bySession.get(sessionKey) : void 0);
+      if (!record || sessionKey && record.sessionKey !== sessionKey) return false;
+      byToolCall.set(toolCallId, record);
+      return true;
+    },
+    hasFreshBinding(scope, runId) {
+      prune();
+      const record = fresh(runId ? byRun.get(runId) : void 0) ?? fresh(scope.sessionKey ? bySession.get(scope.sessionKey) : void 0);
+      if (!record || !scope.sessionKey || record.sessionKey !== scope.sessionKey) return false;
+      if (!scope.userId || cleanIdentity(record.senderId) !== cleanIdentity(scope.userId)) return false;
+      return true;
+    },
+    consumeDetailed(toolCallId, scope) {
+      prune();
+      const record = fresh(byToolCall.get(toolCallId));
+      byToolCall.delete(toolCallId);
+      if (!record) {
+        return { authorization: null, error: "missing_binding" };
+      }
+      if (usedMessageIds.has(record.messageId)) {
+        return { authorization: null, error: "message_replayed" };
+      }
+      if (!scope.sessionKey || record.sessionKey !== scope.sessionKey) {
+        return { authorization: null, error: "session_mismatch" };
+      }
+      if (!scope.userId || cleanIdentity(record.senderId) !== cleanIdentity(scope.userId)) {
+        return { authorization: null, error: "user_mismatch" };
+      }
+      usedMessageIds.set(record.messageId, now());
+      return { authorization: record };
+    },
+    consume(toolCallId, scope) {
+      return this.consumeDetailed(toolCallId, scope).authorization;
+    }
+  };
+}
+
+// src/config.ts
+var DEFAULT_TIMEOUT_MS = 5e3;
+var DEFAULT_MAX_OUTPUT_BYTES = 262144;
+var DEFAULT_MAX_INJECTION_CHARS = 1800;
+var DEFAULT_MAX_ITEMS = 6;
+var DEFAULT_COMMAND = ["node", "runner.mjs", "pending"];
+var DEFAULT_ACTION_TIMEOUT_MS = 5e4;
+var DEFAULT_AUTHORIZATION_TTL_MS = 2 * 6e4;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value.trim() : void 0;
+}
+function readPositiveInteger(value, fallback) {
+  return typeof value === "number" && Number.isFinite(value) && value > 0 ? Math.floor(value) : fallback;
+}
+function readBoolean(value, fallback) {
+  return typeof value === "boolean" ? value : fallback;
+}
+function normalizeCommand(value) {
+  if (!Array.isArray(value)) {
+    return [...DEFAULT_COMMAND];
+  }
+  const parts = value.map(readString).filter((entry) => Boolean(entry));
+  return parts.length > 0 ? parts : [...DEFAULT_COMMAND];
+}
+function normalizeActionCommand(value) {
+  if (!Array.isArray(value)) {
+    return void 0;
+  }
+  const parts = value.map(readString).filter((entry) => Boolean(entry));
+  return parts.length > 0 ? parts : void 0;
+}
+function normalizeSource(value, indexHint) {
+  if (!isRecord(value)) {
+    return null;
+  }
+  const workspacePath = readString(value.workspacePath);
+  const responsibilityId = readString(value.responsibilityId);
+  if (!workspacePath || !responsibilityId) {
+    return null;
+  }
+  const id = readString(value.id) ?? `${responsibilityId}#${indexHint}`;
+  const actionCommand = normalizeActionCommand(value.actionCommand);
+  return {
+    id,
+    responsibilityId,
+    ...readString(value.agentId) ? { agentId: readString(value.agentId) } : {},
+    workspacePath,
+    command: normalizeCommand(value.command),
+    ...actionCommand ? { actionCommand } : {},
+    timeoutMs: readPositiveInteger(value.timeoutMs, DEFAULT_TIMEOUT_MS),
+    ...actionCommand ? { actionTimeoutMs: readPositiveInteger(value.actionTimeoutMs, DEFAULT_ACTION_TIMEOUT_MS) } : {},
+    maxOutputBytes: readPositiveInteger(value.maxOutputBytes, DEFAULT_MAX_OUTPUT_BYTES),
+    ...readString(value.channel) ? { channel: readString(value.channel) } : {},
+    ...readString(value.userId) ? { userId: readString(value.userId) } : {},
+    ...readString(value.sessionKey) ? { sessionKey: readString(value.sessionKey) } : {},
+    ...readString(value.accountId) ? { accountId: readString(value.accountId) } : {},
+    ...readString(value.conversationId) ? { conversationId: readString(value.conversationId) } : {}
+  };
+}
+function normalizeConfig(pluginConfig) {
+  const record = isRecord(pluginConfig) ? pluginConfig : {};
+  const loggingRecord = isRecord(record.logging) ? record.logging : {};
+  const rawSources = Array.isArray(record.sources) ? record.sources : [];
+  const sources = [];
+  rawSources.forEach((entry, i) => {
+    const normalized = normalizeSource(entry, i);
+    if (normalized) {
+      sources.push(normalized);
+    }
+  });
+  return {
+    dryRun: readBoolean(record.dryRun, true),
+    maxInjectionChars: readPositiveInteger(record.maxInjectionChars, DEFAULT_MAX_INJECTION_CHARS),
+    maxItemsInInjection: readPositiveInteger(record.maxItemsInInjection, DEFAULT_MAX_ITEMS),
+    strictUserScope: readBoolean(record.strictUserScope, true),
+    strictSessionScope: readBoolean(record.strictSessionScope, true),
+    authorizationTtlMs: readPositiveInteger(record.authorizationTtlMs, DEFAULT_AUTHORIZATION_TTL_MS),
+    suppressNonFinalReplies: readBoolean(record.suppressNonFinalReplies, true),
+    sources,
+    logging: {
+      decisions: loggingRecord.decisions !== false,
+      includeContent: loggingRecord.includeContent === true
+    }
+  };
+}
+
+// src/delivery.ts
+var DELIVERY_ACTION_TOOLS = /* @__PURE__ */ new Set([
+  "responsibility_select_option",
+  "responsibility_reject",
+  "responsibility_change"
+]);
+function clean2(value) {
+  return typeof value === "string" && value.trim() ? value.trim() : void 0;
+}
+function claimsSchedulingSuccess(value) {
+  const text = clean2(value)?.toLowerCase();
+  if (!text) return false;
+  const withoutNegativeClaims = text.replace(
+    /\b(?:no|not)\s+(?:calendar\s+)?(?:meeting|event|invite|booking)\b[^.!?\n]{0,80}\b(?:scheduled|booked|created|sent|confirmed)\b/g,
+    ""
+  ).replace(
+    /\b(?:could(?:n't| not)|did(?:n't| not)|was(?:n't| not)|is(?:n't| not)|has(?:n't| not)|haven(?:'t| not))\b[^.!?\n]{0,80}\b(?:schedule|scheduled|book|booked|create|created|send|sent|confirm|confirmed)\b/g,
+    ""
+  );
+  return /\b(?:done|finished|all set)\b/.test(withoutNegativeClaims) || /\b(?:i|we)(?:'ve|\s+have)?\s+(?:scheduled|booked|created|sent)\b/.test(withoutNegativeClaims) || /\b(?:i|we)(?:'ve|\s+have)?\s+confirmed\s+(?:the\s+)?(?:booking|meeting|slot|invite)\b/.test(withoutNegativeClaims) || /\b(?:meeting|event|invite|booking)\s+(?:(?:has been|is|was)\s+)?(?:scheduled|booked|created|sent|confirmed)\b/.test(
+    withoutNegativeClaims
+  ) || /\b(?:calendar event|meeting invite)\s+(?:was|has been)\s+(?:created|sent)\b/.test(withoutNegativeClaims);
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : void 0;
+}
+function parseToolOutcome(result) {
+  const resultRecord = asRecord(result);
+  if (!resultRecord) return void 0;
+  const details = asRecord(resultRecord.details);
+  if (details) return details;
+  const content = Array.isArray(resultRecord.content) ? resultRecord.content : [];
+  for (const item of content) {
+    const text = clean2(asRecord(item)?.text);
+    if (!text) continue;
+    try {
+      const parsed = asRecord(JSON.parse(text));
+      if (parsed) return parsed;
+    } catch {
+    }
+  }
+  return resultRecord;
+}
+function buildTransactionFailureText(errorCode) {
+  if (errorCode === "dry_run") {
+    return "I checked your selection in dry-run mode. No calendar event, video meeting, or confirmation email was created.";
+  }
+  if (errorCode === "authorization_unavailable") {
+    return "I couldn't complete the scheduling because this action was not securely bound to your latest message. No calendar event was created.";
+  }
+  if (errorCode === "state_version_mismatch" || errorCode === "interaction_version_conflict") {
+    return "I couldn't complete the scheduling because the meeting details changed before the transaction finished. No calendar event was created.";
+  }
+  if (errorCode === "slot_not_offered" || errorCode === "slot_no_longer_available") {
+    return "I couldn't complete the scheduling because that time is no longer one of the available options. No calendar event was created.";
+  }
+  if (errorCode === "slot_in_past") {
+    return "I couldn't complete the scheduling because that meeting time has already passed. No calendar event was created.";
+  }
+  if (errorCode === "zoom_create_failed") {
+    return "I couldn't create the Zoom meeting, so no calendar event or confirmation email was created. I need the Zoom connection fixed before I retry.";
+  }
+  if (errorCode === "action_not_allowed_for_stage") {
+    return "I couldn't confirm that slot because this scheduling request is not currently awaiting your selection. No calendar event or confirmation email was created.";
+  }
+  if (errorCode === "transaction_recovery_required") {
+    return "I couldn't retry this meeting because the previous booking attempt is waiting for recovery. No calendar event or confirmation email was created.";
+  }
+  if (errorCode === "transaction_receipt_invalid") {
+    return "I couldn't verify the complete scheduling receipts, so I won't claim the meeting was completed. Check the calendar and sent mail before retrying.";
+  }
+  return "I couldn't complete the scheduling transaction. No calendar event was created or changed.";
+}
+function buildTransactionSuccessText(outcome) {
+  const explicit = clean2(outcome.userVisibleText);
+  if (explicit) return explicit;
+  const result = asRecord(outcome.result);
+  const counterpart = clean2(result?.counterpart);
+  const display = clean2(result?.display) ?? clean2(result?.start);
+  const replied = result?.replied === true;
+  const subject = counterpart ? ` with ${counterpart}` : "";
+  const when = display ? ` for ${display}` : "";
+  const receipt = replied ? "The calendar event was created and the confirmation was sent." : "The calendar event was created.";
+  return `Done \u2014 I scheduled the meeting${subject}${when}. ${receipt}`;
+}
+function hasCompleteSchedulingReceipts(outcome) {
+  if (outcome?.ok !== true || outcome.dryRun !== false || outcome.action !== "select_option" || outcome.status !== "scheduled") {
+    return false;
+  }
+  const result = asRecord(outcome.result);
+  return Boolean(clean2(result?.eventId) && clean2(result?.joinUrl) && result?.replied === true);
+}
+function createTransactionDeliveryState() {
+  return {
+    byRun: /* @__PURE__ */ new Map(),
+    runByToolCall: /* @__PURE__ */ new Map()
+  };
+}
+function sharedTransactionDeliveryState() {
+  const runtime = globalThis;
+  runtime.__velanirPendingContextDeliveryV1 ??= createTransactionDeliveryState();
+  return runtime.__velanirPendingContextDeliveryV1;
+}
+function createTransactionDeliveryStore(ttlMs, now = Date.now, state = createTransactionDeliveryState()) {
+  const { byRun, runByToolCall } = state;
+  const prune = () => {
+    for (const [runId, record] of byRun) {
+      if (now() - record.updatedAt > ttlMs) byRun.delete(runId);
+    }
+    for (const [toolCallId, runId] of runByToolCall) {
+      if (!byRun.has(runId)) runByToolCall.delete(toolCallId);
+    }
+  };
+  const resolveRun = (event, ctx) => clean2(event.runId) ?? clean2(ctx.runId);
+  return {
+    markPendingTurn(runIdValue, sessionKeyValue) {
+      prune();
+      const runId = clean2(runIdValue);
+      if (!runId) return false;
+      const existing = byRun.get(runId);
+      byRun.set(runId, {
+        runId,
+        ...clean2(sessionKeyValue) ? { sessionKey: clean2(sessionKeyValue) } : {},
+        updatedAt: now(),
+        actionAttempted: existing?.actionAttempted ?? false,
+        actionFinished: existing?.actionFinished ?? false,
+        actionSucceeded: existing?.actionSucceeded ?? false,
+        ...existing?.finalTextClaimed ? { finalTextClaimed: true } : {},
+        ...existing?.userVisibleText ? { userVisibleText: existing.userVisibleText } : {},
+        ...existing?.errorCode ? { errorCode: existing.errorCode } : {},
+        ...existing?.finalDelivered ? { finalDelivered: true } : {}
+      });
+      return true;
+    },
+    beginAction(event, ctx) {
+      prune();
+      const toolName = clean2(event.toolName) ?? clean2(ctx.toolName);
+      if (!toolName || !DELIVERY_ACTION_TOOLS.has(toolName)) {
+        return { tracked: false, duplicate: false };
+      }
+      const runId = resolveRun(event, ctx);
+      const toolCallId = clean2(event.toolCallId) ?? clean2(ctx.toolCallId);
+      if (!runId || !toolCallId) return { tracked: false, duplicate: false };
+      const existing = byRun.get(runId);
+      if (existing?.actionAttempted) {
+        return { tracked: true, duplicate: true };
+      }
+      byRun.set(runId, {
+        runId,
+        ...clean2(ctx.sessionKey) ? { sessionKey: clean2(ctx.sessionKey) } : {},
+        updatedAt: now(),
+        actionAttempted: true,
+        actionFinished: false,
+        actionSucceeded: false
+      });
+      runByToolCall.set(toolCallId, runId);
+      return { tracked: true, duplicate: false };
+    },
+    failAction(event, ctx, errorCode) {
+      prune();
+      const toolCallId = clean2(event.toolCallId) ?? clean2(ctx.toolCallId);
+      const runId = (toolCallId ? runByToolCall.get(toolCallId) : void 0) ?? resolveRun(event, ctx);
+      if (!runId) return false;
+      const record = byRun.get(runId);
+      if (!record) return false;
+      record.updatedAt = now();
+      record.actionFinished = true;
+      record.actionSucceeded = false;
+      record.errorCode = clean2(errorCode) ?? "transaction_failed";
+      return true;
+    },
+    finishAction(event, ctx) {
+      prune();
+      const toolName = clean2(event.toolName) ?? clean2(ctx.toolName);
+      if (!toolName || !DELIVERY_ACTION_TOOLS.has(toolName)) return false;
+      const toolCallId = clean2(event.toolCallId) ?? clean2(ctx.toolCallId);
+      const runId = (toolCallId ? runByToolCall.get(toolCallId) : void 0) ?? resolveRun(event, ctx);
+      if (!runId) return false;
+      const record = byRun.get(runId);
+      if (!record) return false;
+      const outcome = parseToolOutcome(event.result);
+      const succeeded = event.error === void 0 && hasCompleteSchedulingReceipts(outcome);
+      record.updatedAt = now();
+      record.actionFinished = true;
+      record.actionSucceeded = succeeded;
+      if (succeeded && outcome) {
+        record.userVisibleText = buildTransactionSuccessText(outcome);
+        delete record.errorCode;
+      } else {
+        record.errorCode = outcome?.ok === true && outcome?.dryRun === true ? "dry_run" : clean2(outcome?.error) ?? clean2(event.error) ?? (event.error === void 0 && outcome?.ok === true && outcome?.dryRun === false ? "transaction_receipt_invalid" : "transaction_failed");
+        delete record.userVisibleText;
+      }
+      return true;
+    },
+    // After the one authoritative action finished, every OTHER tool call in the
+    // same run is blocked (the action's own toolCallId is allowed through).
+    blockFurtherTool(event, ctx) {
+      prune();
+      const runId = resolveRun(event, ctx);
+      if (!runId) return false;
+      const record = byRun.get(runId);
+      if (!record?.actionFinished) return false;
+      const toolCallId = clean2(event.toolCallId) ?? clean2(ctx.toolCallId);
+      return !toolCallId || runByToolCall.get(toolCallId) !== runId;
+    },
+    suppressNonFinal(event) {
+      prune();
+      if (event.kind === "final") return false;
+      const runId = clean2(event.runId);
+      return Boolean(runId && byRun.has(runId));
+    },
+    expectedFinalText(runIdValue) {
+      prune();
+      const runId = clean2(runIdValue);
+      if (!runId) return void 0;
+      const record = byRun.get(runId);
+      if (!record?.actionAttempted) return void 0;
+      return record.actionSucceeded ? record.userVisibleText : record.userVisibleText ?? buildTransactionFailureText(record.errorCode);
+    },
+    expectedFinalTextForToolCall(toolCallIdValue) {
+      prune();
+      const toolCallId = clean2(toolCallIdValue);
+      const runId = toolCallId ? runByToolCall.get(toolCallId) : void 0;
+      return runId ? this.expectedFinalText(runId) : void 0;
+    },
+    pendingWithoutAction(runIdValue) {
+      prune();
+      const runId = clean2(runIdValue);
+      if (!runId) return false;
+      const record = byRun.get(runId);
+      return Boolean(record && !record.actionAttempted);
+    },
+    claimNoActionFailureForSession(sessionKeyValue) {
+      prune();
+      const sessionKey = clean2(sessionKeyValue);
+      if (!sessionKey) return void 0;
+      const record = [...byRun.values()].filter(
+        (candidate) => candidate.sessionKey === sessionKey && !candidate.actionAttempted && !candidate.finalTextClaimed
+      ).sort((left, right) => right.updatedAt - left.updatedAt)[0];
+      if (!record) return void 0;
+      record.finalTextClaimed = true;
+      record.updatedAt = now();
+      return "I didn't complete a scheduling transaction. No calendar event was created or changed.";
+    },
+    authoritativeFinalForSession(sessionKeyValue, modelClaimsSuccess) {
+      prune();
+      const sessionKey = clean2(sessionKeyValue);
+      if (!sessionKey) return void 0;
+      const record = [...byRun.values()].filter((candidate) => candidate.sessionKey === sessionKey && !candidate.finalDelivered).sort((left, right) => right.updatedAt - left.updatedAt)[0];
+      if (!record) return void 0;
+      if (record.actionAttempted) {
+        return record.actionSucceeded ? record.userVisibleText : record.userVisibleText ?? buildTransactionFailureText(record.errorCode);
+      }
+      return modelClaimsSuccess ? "I didn't complete a scheduling transaction. No calendar event was created or changed." : void 0;
+    },
+    markFinalDelivered(sessionKeyValue) {
+      prune();
+      const sessionKey = clean2(sessionKeyValue);
+      if (!sessionKey) return false;
+      const record = [...byRun.values()].filter((candidate) => candidate.sessionKey === sessionKey).sort((left, right) => right.updatedAt - left.updatedAt)[0];
+      if (!record) return false;
+      record.finalDelivered = true;
+      record.updatedAt = now();
+      return true;
+    },
+    finalAlreadyDelivered(sessionKeyValue) {
+      prune();
+      const sessionKey = clean2(sessionKeyValue);
+      if (!sessionKey) return false;
+      const latest = [...byRun.values()].filter((candidate) => candidate.sessionKey === sessionKey).sort((left, right) => right.updatedAt - left.updatedAt)[0];
+      return latest?.finalDelivered === true;
+    },
+    claimFinalTextForSession(sessionKeyValue) {
+      prune();
+      const sessionKey = clean2(sessionKeyValue);
+      if (!sessionKey) return void 0;
+      const record = [...byRun.values()].filter(
+        (candidate) => candidate.sessionKey === sessionKey && candidate.actionAttempted && !candidate.finalTextClaimed
+      ).sort((left, right) => right.updatedAt - left.updatedAt)[0];
+      if (!record) return void 0;
+      record.finalTextClaimed = true;
+      record.updatedAt = now();
+      return record.actionSucceeded ? record.userVisibleText : record.userVisibleText ?? buildTransactionFailureText(record.errorCode);
+    },
+    finalizeReply(event) {
+      prune();
+      if (event.kind !== "final") return void 0;
+      const runId = clean2(event.runId);
+      if (!runId) return void 0;
+      const record = byRun.get(runId);
+      if (!record) return void 0;
+      byRun.delete(runId);
+      for (const [toolCallId, candidateRunId] of runByToolCall) {
+        if (candidateRunId === runId) runByToolCall.delete(toolCallId);
+      }
+      if (!record.actionAttempted) return {};
+      return {
+        text: record.actionSucceeded ? record.userVisibleText : record.userVisibleText ?? buildTransactionFailureText(record.errorCode)
+      };
+    }
+  };
+}
+
+// src/injection.ts
+var CONVERSATION_ROUTE_PREFIXES = /* @__PURE__ */ new Set([
+  "channel",
+  "chat",
+  "conversation",
+  "direct",
+  "dm",
+  "group",
+  "thread",
+  "user"
+]);
+function canonicalizeConversationId(value, channel) {
+  let current = value?.trim();
+  if (!current) {
+    return void 0;
+  }
+  const normalizedChannel = channel?.trim().toLowerCase();
+  for (let depth = 0; depth < 2; depth += 1) {
+    const separator = current.indexOf(":");
+    if (separator < 0) {
+      break;
+    }
+    const prefix = current.slice(0, separator).trim().toLowerCase();
+    const suffix = current.slice(separator + 1).trim();
+    if (!suffix || !CONVERSATION_ROUTE_PREFIXES.has(prefix) && prefix !== normalizedChannel) {
+      break;
+    }
+    current = suffix;
+  }
+  return current;
+}
+function scopeMatches(itemValue, turnValue) {
+  if (itemValue === void 0) {
+    return true;
+  }
+  return turnValue !== void 0 && itemValue === turnValue;
+}
+function filterForTurn(items, turn, options) {
+  return items.filter((item) => {
+    if (options.strictUserScope && item.userId === void 0) {
+      return false;
+    }
+    if (options.strictSessionScope && item.sessionKey === void 0 && item.conversationId === void 0) {
+      return false;
+    }
+    const exactDestinationMatches = item.sessionKey !== void 0 ? scopeMatches(item.sessionKey, turn.sessionKey) : scopeMatches(
+      canonicalizeConversationId(item.conversationId, item.channel),
+      canonicalizeConversationId(turn.conversationId, turn.channel)
+    );
+    return scopeMatches(item.agentId, turn.agentId) && scopeMatches(item.channel, turn.channel) && scopeMatches(item.userId, turn.userId) && scopeMatches(item.accountId, turn.accountId) && exactDestinationMatches;
+  });
+}
+var HEADER = "[pending responsibility interactions]";
+function itemLine(index, item) {
+  const slots = item.offeredSlots.length ? ` offered: ${item.offeredSlots.map((s, slotIndex) => {
+    const stableId = s.id ?? (s.number ? String(s.number) : `option-${slotIndex + 1}`);
+    return `${stableId}=${s.display}`;
+  }).join("; ")}` : item.stage === "needs_info" ? " awaiting a preferred time" : "";
+  return `${index}. id=${item.interactionId} \xB7 v=${item.stateVersion} \xB7 stage=${item.stage} \xB7 "${item.summary}"${slots}`;
+}
+function buildInjectionBlock(items, options) {
+  if (items.length === 0) {
+    return "";
+  }
+  const intro = `You have ${items.length} pending responsibility interaction${items.length === 1 ? "" : "s"} awaiting this user's reply. Delivery transcript mirrors are best-effort; pending state is authoritative. Before interpreting a scheduling reply, call responsibility_pending and bind it to exactly ONE interactionId. If more than one could match, ask which \u2014 never guess a thread or improvise provider actions. Interpret natural-language choices against the offered labels; when exactly one option matches, pass its stable optionId. If no option or multiple options match, ask one clarification question without invoking an action tool.`;
+  const footer = options.selectionEnabled === false ? "Selection writes are disabled. Use responsibility_pending or responsibility_status only; do not invoke runner effect modes." : "For a uniquely matched natural-language or numeric choice, act only via responsibility_select_option with its exact interactionId and stable optionId. Displayed numbers are also accepted as a compatibility fallback. Authorization and current state are bound internally; never supply a revision, time, message id, or invoke runner effect modes manually. After any typed action returns, stop the turn and give its one result; never retry or call another tool in the same turn.";
+  const shown = Math.min(items.length, Math.max(1, options.maxItems));
+  let lines = items.slice(0, shown).map((it, i) => itemLine(i + 1, it));
+  const hiddenByCount = items.length - shown;
+  const assemble = (bodyLines, hidden) => {
+    const parts = [HEADER, intro, ...bodyLines];
+    if (hidden > 0) {
+      parts.push(`(+${hidden} more \u2014 call responsibility_pending for the full list)`);
+    }
+    parts.push(footer);
+    return parts.join("\n");
+  };
+  let block = assemble(lines, hiddenByCount);
+  if (block.length <= options.maxChars) {
+    return block;
+  }
+  let visible = lines.length;
+  while (visible > 1) {
+    visible -= 1;
+    lines = lines.slice(0, visible);
+    block = assemble(lines, items.length - visible);
+    if (block.length <= options.maxChars) {
+      return block;
+    }
+  }
+  const compact = [
+    HEADER,
+    `(+${items.length} more) responsibility_pending; bind one.`,
+    "Select only via responsibility_select_option(interactionId, optionId); then stop."
+  ].join("\n");
+  return compact.length <= options.maxChars ? compact : "";
+}
+
+// src/runner-exec.ts
+import { execFileSync } from "child_process";
+function createRunnerExec() {
+  return (input) => {
+    const [file, ...args] = input.command;
+    if (!file) {
+      return { ok: false, error: "empty_command" };
+    }
+    try {
+      const stdout = execFileSync(file, args, {
+        cwd: input.cwd,
+        timeout: input.timeoutMs,
+        // Cap captured output; execFileSync throws ENOBUFS past this, which we
+        // surface as a truncation so partial provider payloads are never parsed.
+        maxBuffer: input.maxOutputBytes,
+        encoding: "utf8",
+        input: input.stdin,
+        stdio: [input.stdin === void 0 ? "ignore" : "pipe", "pipe", "ignore"]
+      });
+      if (stdout.length > input.maxOutputBytes) {
+        return { ok: true, stdout: stdout.slice(0, input.maxOutputBytes), truncated: true };
+      }
+      return { ok: true, stdout };
+    } catch (err) {
+      const e = err;
+      if (e.code === "ENOBUFS") {
+        return { ok: false, error: "output_truncated", truncated: true };
+      }
+      const stdout = typeof e.stdout === "string" ? e.stdout : Buffer.isBuffer(e.stdout) ? e.stdout.toString("utf8") : void 0;
+      return {
+        ok: false,
+        ...stdout ? { stdout: stdout.slice(0, input.maxOutputBytes) } : {},
+        error: `runner_exec_failed: ${e.code ?? e.message ?? "unknown"}`
+      };
+    }
+  };
+}
+
+// src/source.ts
+import { createHash } from "crypto";
+
+// src/redaction.ts
+var SENSITIVE_PATTERNS = [
+  // Composio / One action + connection ids seen in the reference runner CONFIG.
+  /conn_mod_def::[A-Za-z0-9_::-]+/g,
+  /live::[A-Za-z0-9_-]+/g,
+  // API-key-ish tokens (ak_..., sk_..., pk_..., ghp_..., xoxb-..., Bearer ...).
+  /\bak_[A-Za-z0-9]{6,}/g,
+  /\b[sp]k_[A-Za-z0-9]{6,}/g,
+  /\bghp_[A-Za-z0-9]{20,}/g,
+  /\bxox[baprs]-[A-Za-z0-9-]{8,}/g,
+  /\bBearer\s+[A-Za-z0-9._-]{8,}/gi,
+  // JWT-shaped triples.
+  /\beyJ[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}\.[A-Za-z0-9_-]{6,}/g,
+  // Reasoning-tag residue (MiniMax mm:think etc.) must never surface.
+  /<\/?think[^>]*>/gi,
+  /\bmm:think\b/gi
+];
+var REDACTED = "[redacted]";
+function redactText(input) {
+  if (input === void 0 || input === null) {
+    return "";
+  }
+  let text = String(input);
+  for (const pattern of SENSITIVE_PATTERNS) {
+    text = text.replace(pattern, REDACTED);
+  }
+  return text.replace(/\s+/g, " ").trim();
+}
+
+// src/source.ts
+function shortHash(parts) {
+  return createHash("sha256").update(parts.map((p) => p ?? "").join("|")).digest("hex").slice(0, 16);
+}
+function normalizeSlots(raw) {
+  const source = raw.offeredSlots ?? raw.numberedSlots ?? raw.candidateSlots ?? raw.options ?? [];
+  const slots = [];
+  for (const entry of source) {
+    if (!entry) {
+      continue;
+    }
+    if (typeof entry === "string") {
+      const value = entry.trim();
+      if (value) {
+        slots.push({ start: value, display: redactText(value) || value });
+      }
+      continue;
+    }
+    const start = typeof entry.start === "string" && entry.start.trim() ? entry.start.trim() : typeof entry.value === "string" && entry.value.trim() ? entry.value.trim() : entry.value && typeof entry.value === "object" && typeof entry.value.startsAt === "string" && entry.value.startsAt.trim() ? entry.value.startsAt.trim() : "";
+    if (!start) {
+      continue;
+    }
+    const slotId = typeof entry.optionId === "string" && entry.optionId.trim() ? entry.optionId.trim() : typeof entry.id === "string" && entry.id.trim() ? entry.id.trim() : entry.number !== void 0 ? String(entry.number) : void 0;
+    const slotNumber = typeof entry.number === "number" && Number.isSafeInteger(entry.number) && entry.number > 0 ? entry.number : typeof entry.number === "string" && /^[1-9]\d*$/.test(entry.number.trim()) && Number.isSafeInteger(Number(entry.number.trim())) ? Number(entry.number.trim()) : void 0;
+    const display = entry.display ?? entry.label ?? start;
+    slots.push({
+      ...slotId ? { id: slotId } : {},
+      ...slotNumber ? { number: slotNumber } : {},
+      start,
+      display: redactText(display) || start
+    });
+  }
+  return slots;
+}
+function mapRawItem(raw, source) {
+  const interactionId = (raw.interactionId ?? raw.id ?? raw.threadKey ?? "").trim();
+  if (!interactionId) {
+    return null;
+  }
+  const stage = (raw.stage ?? "").trim() || "needs_info";
+  const offeredSlots = normalizeSlots(raw);
+  const summary = redactText(raw.summary ?? raw.subject ?? raw.counterpart ?? raw.lastAskedToUser ?? "(no subject)") || "(no subject)";
+  const note = raw.note ? redactText(raw.note) : void 0;
+  const lastAskedToUser = raw.lastAskedToUser ? redactText(raw.lastAskedToUser) : void 0;
+  const stateVersion = raw.stateVersion === void 0 || raw.stateVersion === null ? "" : String(raw.stateVersion).trim();
+  const effectiveStateVersion = stateVersion || shortHash([interactionId, stage, JSON.stringify(offeredSlots), summary, lastAskedToUser]);
+  return {
+    interactionId,
+    stateVersion: effectiveStateVersion,
+    stage,
+    responsibilityId: source.responsibilityId,
+    ...source.agentId ?? raw.agentId ? { agentId: source.agentId ?? raw.agentId } : {},
+    ...source.channel ?? raw.channel ? { channel: source.channel ?? raw.channel } : {},
+    ...source.userId ?? raw.userId ?? raw.managerUserId ? { userId: source.userId ?? raw.userId ?? raw.managerUserId } : {},
+    ...source.sessionKey ?? raw.sessionKey ? { sessionKey: source.sessionKey ?? raw.sessionKey } : {},
+    ...source.accountId ?? raw.accountId ? { accountId: source.accountId ?? raw.accountId } : {},
+    ...source.conversationId ?? raw.conversationId ? { conversationId: source.conversationId ?? raw.conversationId } : {},
+    summary,
+    offeredSlots,
+    ...raw.requestedWindowHint ? { requestedWindowHint: redactText(raw.requestedWindowHint) } : {},
+    ...lastAskedToUser ? { lastAskedToUser } : {},
+    ...raw.deliveryMessageId ?? raw.delivery?.messageId ? { deliveryMessageId: (raw.deliveryMessageId ?? raw.delivery?.messageId ?? "").trim() } : {},
+    ...note ? { note } : {},
+    source: source.id
+  };
+}
+function parsePendingEnvelope(stdout) {
+  const trimmed = stdout.trim();
+  if (!trimmed) {
+    return null;
+  }
+  try {
+    return JSON.parse(trimmed);
+  } catch {
+    const start = trimmed.indexOf("{");
+    const end = trimmed.lastIndexOf("}");
+    if (start >= 0 && end > start) {
+      try {
+        return JSON.parse(trimmed.slice(start, end + 1));
+      } catch {
+        return null;
+      }
+    }
+    return null;
+  }
+}
+function loadPendingFromSource(source, exec) {
+  let result;
+  try {
+    result = exec({
+      command: source.command,
+      cwd: source.workspacePath,
+      timeoutMs: source.timeoutMs,
+      maxOutputBytes: source.maxOutputBytes
+    });
+  } catch (err) {
+    return { items: [], error: `exec_failed: ${err.message}` };
+  }
+  if (!result.ok) {
+    return { items: [], error: result.error ?? "exec_failed" };
+  }
+  if (result.truncated) {
+    return { items: [], error: "output_truncated" };
+  }
+  const envelope = parsePendingEnvelope(result.stdout ?? "");
+  const packagedPending = envelope?.facts?.filter((fact) => fact?.kind === "pending").flatMap((fact) => Array.isArray(fact.payload?.pending) ? fact.payload.pending : []) ?? [];
+  const pending = Array.isArray(envelope?.pending) ? envelope.pending : packagedPending.length > 0 || envelope?.facts?.some((fact) => fact?.kind === "pending") ? packagedPending : null;
+  if (!envelope || envelope.ok === false || !pending) {
+    return { items: [], error: "unparseable_pending_output" };
+  }
+  const items = [];
+  for (const raw of pending) {
+    const mapped = mapRawItem(raw, source);
+    if (mapped) {
+      items.push(mapped);
+    }
+  }
+  return { items };
+}
+function loadPendingFromSources(sources, exec) {
+  const items = [];
+  const errors = {};
+  for (const source of sources) {
+    const res = loadPendingFromSource(source, exec);
+    if (res.error) {
+      errors[source.id] = res.error;
+    }
+    items.push(...res.items);
+  }
+  return { items, errors };
+}
+function actionError(error, message) {
+  return { ok: false, error: { ok: false, error, message } };
+}
+function actionRecordFromOutput(stdout) {
+  if (!stdout) return void 0;
+  const parsed = parsePendingEnvelope(stdout);
+  if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return void 0;
+  const direct = parsed;
+  const facts = Array.isArray(direct.facts) ? direct.facts : [];
+  const fact = facts.find((entry) => {
+    if (!entry || typeof entry !== "object" || Array.isArray(entry)) return false;
+    const kind = entry.kind;
+    return kind === "action" || kind === "transaction" || kind === "result";
+  });
+  if (fact?.payload && typeof fact.payload === "object" && !Array.isArray(fact.payload)) {
+    return fact.payload;
+  }
+  return direct;
+}
+function runnerErrorFromRecord(record) {
+  if (record.ok !== false) return void 0;
+  const error = typeof record.error === "string" ? record.error : typeof record.code === "string" ? record.code : "transaction_failed";
+  const message = typeof record.message === "string" && record.message.trim() ? record.message.trim() : "The responsibility runner rejected this transaction before any success could be confirmed.";
+  return { ok: false, error, message };
+}
+function executeAuthoritativeAction(source, request, exec) {
+  if (!source.actionCommand || source.actionCommand.length === 0) {
+    return actionError(
+      "source_unavailable",
+      "This responsibility has no reviewed action bridge. No scheduling transaction was started."
+    );
+  }
+  let result;
+  try {
+    result = exec({
+      command: source.actionCommand,
+      cwd: source.workspacePath,
+      timeoutMs: source.actionTimeoutMs ?? source.timeoutMs,
+      maxOutputBytes: source.maxOutputBytes,
+      stdin: JSON.stringify(request)
+    });
+  } catch (err) {
+    return actionError("source_unavailable", `The responsibility action bridge could not start: ${err.message}`);
+  }
+  if (result.truncated) {
+    return actionError("source_unavailable", "The responsibility action bridge returned truncated output; no success can be claimed.");
+  }
+  const outcome = actionRecordFromOutput(result.stdout);
+  if (outcome) {
+    const runnerError = runnerErrorFromRecord(outcome);
+    if (runnerError) return { ok: false, error: runnerError };
+    return { ok: true, outcome };
+  }
+  return actionError(
+    "source_unavailable",
+    result.error ? `The responsibility action bridge failed: ${result.error}` : "The responsibility action bridge returned no typed transaction receipt."
+  );
+}
+
+// src/interactions.ts
+function buildIndex(items) {
+  const byId = /* @__PURE__ */ new Map();
+  const order = [];
+  for (const item of items) {
+    if (!byId.has(item.interactionId)) {
+      order.push(item.interactionId);
+    }
+    byId.set(item.interactionId, item);
+  }
+  return { order, byId };
+}
+function listInteractions(index) {
+  return index.order.map((id) => index.byId.get(id)).filter(Boolean);
+}
+var RESPONDABLE_STAGES = /* @__PURE__ */ new Set([
+  "awaiting_confirmation",
+  "awaiting_manager_selection",
+  "needs_info",
+  "needs_information",
+  "proposed"
+]);
+var CONFIRMABLE_STAGES = /* @__PURE__ */ new Set([
+  "awaiting_confirmation",
+  "awaiting_manager_selection",
+  "proposed"
+]);
+function isActionAllowed(interaction, action) {
+  switch (action) {
+    case "status":
+      return true;
+    case "select_option":
+      return CONFIRMABLE_STAGES.has(interaction.stage) && interaction.offeredSlots.length > 0;
+    case "reject":
+    case "change":
+      return RESPONDABLE_STAGES.has(interaction.stage);
+    default:
+      return false;
+  }
+}
+function selectInteraction(index, interactionId) {
+  const id = (interactionId ?? "").trim();
+  if (id) {
+    const interaction = index.byId.get(id);
+    if (!interaction) {
+      return {
+        ok: false,
+        error: "unknown_interaction",
+        message: `No pending interaction with id "${id}". Call responsibility_pending to list current ids.`
+      };
+    }
+    return { ok: true, interaction, autobound: false };
+  }
+  const candidates = index.order;
+  if (candidates.length === 0) {
+    return {
+      ok: false,
+      error: "no_pending_interactions",
+      message: "There are no pending interactions to act on. Check with the user before acting."
+    };
+  }
+  if (candidates.length > 1) {
+    return {
+      ok: false,
+      error: "ambiguous_requires_interaction_id",
+      message: "More than one interaction is pending. Re-issue with an explicit interactionId; do not guess which thread the reply refers to.",
+      candidates: [...candidates]
+    };
+  }
+  return { ok: true, interaction: index.byId.get(candidates[0]), autobound: true };
+}
+
+// src/tools.ts
+var PENDING_CONTRACT = {
+  name: "responsibility_pending",
+  label: "List pending responsibility interactions",
+  readOnly: true,
+  description: "List the responsibility interactions currently visible to THIS authenticated user in THIS exact channel and session. Cron transcript mirrors are best-effort, so call this authoritative scoped-state tool before interpreting any scheduling reply. An empty result proves only that nothing is visible in this scope; never infer that another interaction completed, closed, expired, or timed out. If more than one could match, ask the user which \u2014 never guess.",
+  parameters: {
+    type: "object",
+    properties: {},
+    required: [],
+    additionalProperties: false
+  }
+};
+var SELECT_OPTION_CONTRACT = {
+  name: "responsibility_select_option",
+  label: "Select an offered option",
+  readOnly: false,
+  description: "Select one stable option already offered on a pending interaction. First interpret the user's natural-language reply against the authoritative offered labels. If exactly one option matches, call this tool with the exact interactionId and that option's stable optionId. If no option or multiple options match, ask one clarification question without calling this tool. A displayed option number is also accepted and resolved to a stable optionId internally. The current revision, selected time, sender, and inbound message are resolved from authoritative runtime state; never supply or invent them.",
+  parameters: {
+    type: "object",
+    properties: {
+      interactionId: { type: "string", description: "The interaction to select from responsibility_pending." },
+      optionId: {
+        type: "string",
+        description: "The stable offered option id, or the displayed one-based option number selected by the user."
+      }
+    },
+    required: ["interactionId", "optionId"],
+    additionalProperties: false
+  }
+};
+var REJECT_CONTRACT = {
+  name: "responsibility_reject",
+  label: "Reject a pending interaction",
+  readOnly: false,
+  description: "Record that the user declined a pending interaction. Requires the exact interactionId and current stateVersion and a short reason. Authorization is bound internally to the trusted inbound message. Dry-run by default.",
+  parameters: {
+    type: "object",
+    properties: {
+      interactionId: { type: "string", description: "The interaction to reject (from responsibility_pending)." },
+      stateVersion: { type: "string", description: "The interaction's current stateVersion; a stale value is rejected." },
+      reason: { type: "string", description: "Short user-facing reason for the rejection." }
+    },
+    required: ["interactionId", "stateVersion", "reason"],
+    additionalProperties: false
+  }
+};
+var CHANGE_CONTRACT = {
+  name: "responsibility_change",
+  label: "Request a different window for a pending interaction",
+  readOnly: false,
+  description: "Record that the user wants a different time window for a pending interaction. Requires the exact interactionId and current stateVersion plus the requested window. Authorization is bound internally to the trusted inbound message. Dry-run by default.",
+  parameters: {
+    type: "object",
+    properties: {
+      interactionId: { type: "string", description: "The interaction to change (from responsibility_pending)." },
+      stateVersion: { type: "string", description: "The interaction's current stateVersion; a stale value is rejected." },
+      requestedWindow: { type: "string", description: "The window the user is asking for (free text or ISO range)." }
+    },
+    required: ["interactionId", "stateVersion", "requestedWindow"],
+    additionalProperties: false
+  }
+};
+var STATUS_CONTRACT = {
+  name: "responsibility_status",
+  label: "Read a pending interaction's status",
+  readOnly: true,
+  description: "Read the current stage and offered slots of one pending interaction. Read-only.",
+  parameters: {
+    type: "object",
+    properties: {
+      interactionId: { type: "string", description: "The interaction to inspect (from responsibility_pending)." }
+    },
+    required: ["interactionId"],
+    additionalProperties: false
+  }
+};
+function readParam(params, key) {
+  const value = params[key];
+  return typeof value === "string" ? value.trim() : "";
+}
+var SCOPED_EMPTY_PENDING_TEXT = "No pending scheduling interactions are visible in this authenticated session. This scoped result does not prove that an interaction was completed, closed, expired, or timed out in another session. Check from the intended manager's authenticated channel.";
+function runPendingTool(index) {
+  const items = listInteractions(index);
+  const empty = items.length === 0;
+  return {
+    ok: true,
+    pendingCount: items.length,
+    pending: items.map((it) => ({
+      interactionId: it.interactionId,
+      stateVersion: it.stateVersion,
+      stage: it.stage,
+      summary: it.summary,
+      offeredSlots: it.offeredSlots,
+      ...it.requestedWindowHint ? { requestedWindowHint: it.requestedWindowHint } : {},
+      ...it.lastAskedToUser ? { lastAskedToUser: it.lastAskedToUser } : {},
+      ...it.note ? { note: it.note } : {}
+    })),
+    ...empty ? {
+      visibility: "authenticated_session",
+      absenceProof: "scoped_only",
+      stopAfterThisTool: true,
+      userVisibleText: SCOPED_EMPTY_PENDING_TEXT
+    } : {},
+    hint: empty ? "Return userVisibleText exactly. Do not call another tool, consult session history, or infer completion, closure, expiry, booking, resolution, or timeout." : "Bind the user's reply to exactly one interactionId. If more than one could match, ask which \u2014 do not guess."
+  };
+}
+function runStatusTool(index, params) {
+  const selected = selectInteraction(index, readParam(params, "interactionId"));
+  if (selected.ok === false) {
+    return selected;
+  }
+  const it = selected.interaction;
+  return {
+    ok: true,
+    interactionId: it.interactionId,
+    stateVersion: it.stateVersion,
+    stage: it.stage,
+    summary: it.summary,
+    offeredSlots: it.offeredSlots,
+    ...it.requestedWindowHint ? { requestedWindowHint: it.requestedWindowHint } : {},
+    ...it.lastAskedToUser ? { lastAskedToUser: it.lastAskedToUser } : {},
+    ...it.note ? { note: it.note } : {}
+  };
+}
+function validateAction(index, action, params) {
+  const selected = selectInteraction(index, readParam(params, "interactionId"));
+  if (selected.ok === false) {
+    return selected;
+  }
+  const interaction = selected.interaction;
+  const userMessageId = readParam(params, "userMessageId");
+  if (!userMessageId) {
+    return {
+      ok: false,
+      error: "missing_user_message_id",
+      message: "userMessageId is required so the action is bound to the message that authorized it."
+    };
+  }
+  const stateVersion = readParam(params, "stateVersion");
+  if (stateVersion !== interaction.stateVersion) {
+    return {
+      ok: false,
+      error: "state_version_mismatch",
+      message: `stateVersion "${stateVersion || "(missing)"}" does not match the interaction's current "${interaction.stateVersion}". Re-read responsibility_pending and retry with the current value.`
+    };
+  }
+  if (!isActionAllowed(interaction, action)) {
+    return {
+      ok: false,
+      error: "action_not_allowed_for_stage",
+      message: `Action "${action}" is not allowed while interaction "${interaction.interactionId}" is in stage "${interaction.stage}"${action === "select_option" && interaction.offeredSlots.length === 0 ? " (no slots offered yet)" : ""}.`
+    };
+  }
+  return { interaction };
+}
+function runSelectOptionTool(index, params, dryRun) {
+  const selected = selectInteraction(index, readParam(params, "interactionId"));
+  if (selected.ok === false) return selected;
+  const interaction = selected.interaction;
+  if (!isActionAllowed(interaction, "select_option")) {
+    return {
+      ok: false,
+      error: "action_not_allowed_for_stage",
+      message: `Option selection is not allowed while interaction "${interaction.interactionId}" is in stage "${interaction.stage}"${interaction.offeredSlots.length === 0 ? " (no options offered yet)" : ""}.`
+    };
+  }
+  const userMessageId = readParam(params, "userMessageId");
+  if (!userMessageId) {
+    return {
+      ok: false,
+      error: "missing_user_message_id",
+      message: "A trusted inbound message is required to select an option."
+    };
+  }
+  const optionId = readParam(params, "optionId");
+  if (!optionId) {
+    return { ok: false, error: "missing_option", message: "optionId is required to select an option." };
+  }
+  let offered = interaction.offeredSlots.find((slot) => slot.id === optionId);
+  if (!offered && /^[1-9]\d*$/.test(optionId)) {
+    const displayedNumber = Number(optionId);
+    if (Number.isSafeInteger(displayedNumber)) {
+      const explicitlyNumbered = interaction.offeredSlots.filter(
+        (slot) => slot.number === displayedNumber
+      );
+      if (explicitlyNumbered.length === 1) {
+        offered = explicitlyNumbered[0];
+      } else if (explicitlyNumbered.length === 0 && interaction.offeredSlots.every((slot) => slot.number === void 0)) {
+        offered = interaction.offeredSlots[displayedNumber - 1];
+      }
+    }
+  }
+  if (!offered) {
+    return {
+      ok: false,
+      error: "slot_not_offered",
+      message: `optionId "${optionId}" is not one of interaction "${interaction.interactionId}"'s offered options. To propose a different time, the responsibility must offer new slots first.`
+    };
+  }
+  const canonicalOptionId = offered.id ?? offered.start;
+  return {
+    ok: true,
+    dryRun,
+    action: "select_option",
+    interactionId: interaction.interactionId,
+    stateVersion: interaction.stateVersion,
+    wouldTransitionTo: interaction.stage === "awaiting_manager_selection" ? "awaiting_counterparty" : "scheduled",
+    wouldPerform: `Would record confirmation of ${redactText(offered.display) || offered.start} for "${interaction.summary}" and hand off to the responsibility worker to book + reply.`,
+    accepted: {
+      interactionId: interaction.interactionId,
+      optionId: canonicalOptionId
+    }
+  };
+}
+function runRejectTool(index, params, dryRun) {
+  const validated = validateAction(index, "reject", params);
+  if ("ok" in validated && validated.ok === false) {
+    return validated;
+  }
+  const { interaction } = validated;
+  const reason = readParam(params, "reason");
+  if (!reason) {
+    return { ok: false, error: "missing_reason", message: "reason is required to reject an interaction." };
+  }
+  return {
+    ok: true,
+    dryRun,
+    action: "reject",
+    interactionId: interaction.interactionId,
+    stateVersion: interaction.stateVersion,
+    wouldTransitionTo: interaction.stage === "awaiting_manager_selection" ? "declined" : "closed",
+    wouldPerform: `Would close "${interaction.summary}" as declined (${redactText(reason)}).`,
+    accepted: { interactionId: interaction.interactionId, reason: redactText(reason) }
+  };
+}
+function runChangeTool(index, params, dryRun) {
+  const validated = validateAction(index, "change", params);
+  if ("ok" in validated && validated.ok === false) {
+    return validated;
+  }
+  const { interaction } = validated;
+  const requestedWindow = readParam(params, "requestedWindow");
+  if (!requestedWindow) {
+    return { ok: false, error: "missing_requested_window", message: "requestedWindow is required to request a different time." };
+  }
+  return {
+    ok: true,
+    dryRun,
+    action: "change",
+    interactionId: interaction.interactionId,
+    stateVersion: interaction.stateVersion,
+    wouldTransitionTo: interaction.stage === "awaiting_manager_selection" ? "needs_information" : "needs_info",
+    wouldPerform: `Would ask the responsibility to recompute availability for "${interaction.summary}" around ${redactText(requestedWindow)}.`,
+    accepted: { interactionId: interaction.interactionId, requestedWindow: redactText(requestedWindow) }
+  };
+}
+
+// src/index.ts
+var PLUGIN_ID = "velanir-pending-context";
+var TRUSTED_ACTION_POLICY_ID = "authoritative-pending-action";
+var CACHE_TTL_MS = 3e3;
+function loadItems(config, exec, cache) {
+  const now = Date.now();
+  if (cache.value && now - cache.value.at < CACHE_TTL_MS) {
+    return cache.value.items;
+  }
+  const { items } = loadPendingFromSources(config.sources, exec);
+  cache.value = { at: now, items };
+  return items;
+}
+function turnScopeFromContext(ctx) {
+  const channel = ctx.channel ?? ctx.messageProvider;
+  const conversationId = canonicalizeConversationId(ctx.chatId ?? ctx.channelId, channel);
+  return {
+    ...ctx.agentId ? { agentId: ctx.agentId } : {},
+    ...channel ? { channel } : {},
+    ...ctx.senderId ? { userId: ctx.senderId } : {},
+    ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
+    ...conversationId ? { conversationId } : {}
+  };
+}
+function toolScopeFromContext(ctx) {
+  const channel = ctx.messageChannel ?? ctx.deliveryContext?.channel;
+  const accountId = ctx.agentAccountId ?? ctx.deliveryContext?.accountId;
+  const conversationId = canonicalizeConversationId(ctx.deliveryContext?.to, channel);
+  return {
+    ...ctx.agentId ? { agentId: ctx.agentId } : {},
+    ...channel ? { channel } : {},
+    ...ctx.requesterSenderId ? { userId: ctx.requesterSenderId } : {},
+    ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {},
+    ...accountId ? { accountId } : {},
+    ...conversationId ? { conversationId } : {}
+  };
+}
+function toolResult(payload) {
+  return { content: [{ type: "text", text: JSON.stringify(payload) }], details: payload };
+}
+function scopedItems(config, exec, cache, scope) {
+  return filterForTurn(loadItems(config, exec, cache), scope, {
+    strictUserScope: config.strictUserScope,
+    strictSessionScope: config.strictSessionScope
+  });
+}
+function makeReadToolFactory(contract, config, exec, cache, run) {
+  return (ctx) => {
+    const scope = toolScopeFromContext(ctx);
+    return {
+      name: contract.name,
+      label: contract.label,
+      description: contract.description,
+      parameters: contract.parameters,
+      execute: async (_toolCallId, params) => toolResult(run(scopedItems(config, exec, cache, scope), params ?? {}))
+    };
+  };
+}
+function authorizationError(error) {
+  return {
+    ok: false,
+    error: "authorization_unavailable",
+    message: error === "message_replayed" ? "This inbound message has already authorized an action. No retry was started." : "This action was not securely bound to the current inbound message. No transaction was started."
+  };
+}
+function actionRequestFromOutcome(outcome, params, authorization) {
+  const request = {
+    action: outcome.action,
+    interactionId: outcome.interactionId,
+    stateVersion: outcome.stateVersion,
+    userMessageId: authorization.messageId,
+    authorization: {
+      senderId: authorization.senderId,
+      sessionKey: authorization.sessionKey,
+      messageId: authorization.messageId
+    }
+  };
+  if (outcome.action === "select_option") request.optionId = outcome.accepted.optionId;
+  if (outcome.action === "reject") request.reason = typeof params.reason === "string" ? params.reason : void 0;
+  if (outcome.action === "change") {
+    request.requestedWindow = typeof params.requestedWindow === "string" ? params.requestedWindow : void 0;
+  }
+  return request;
+}
+function makeActionToolFactory(contract, config, exec, cache, authorizationStore, deliveryStore, run) {
+  return (ctx) => {
+    const scope = toolScopeFromContext(ctx);
+    return {
+      name: contract.name,
+      label: contract.label,
+      description: contract.description,
+      parameters: contract.parameters,
+      execute: async (toolCallId, params) => {
+        const hookContext = {
+          toolName: contract.name,
+          toolCallId,
+          ...ctx.sessionKey ? { sessionKey: ctx.sessionKey } : {}
+        };
+        const consumed = authorizationStore.consumeDetailed(toolCallId, scope);
+        if (!consumed.authorization) {
+          const error = authorizationError(consumed.error);
+          deliveryStore.finishAction({ toolName: contract.name, toolCallId, result: error }, hookContext);
+          return toolResult(error);
+        }
+        const internalParams = {
+          ...params ?? {},
+          userMessageId: consumed.authorization.messageId
+        };
+        const items = scopedItems(config, exec, cache, scope);
+        const outcome = run(items, internalParams, config.dryRun);
+        if (!outcome.ok) {
+          deliveryStore.finishAction({ toolName: contract.name, toolCallId, result: outcome }, hookContext);
+          return toolResult(outcome);
+        }
+        if (config.dryRun) {
+          deliveryStore.finishAction({ toolName: contract.name, toolCallId, result: outcome }, hookContext);
+          const finalText = deliveryStore.expectedFinalTextForToolCall(toolCallId);
+          return toolResult({ ...outcome, userVisibleText: finalText });
+        }
+        const interaction = items.find((candidate) => candidate.interactionId === outcome.interactionId);
+        const source = interaction ? config.sources.find((candidate) => candidate.id === interaction.source) : void 0;
+        if (!source) {
+          const error = {
+            ok: false,
+            error: "source_unavailable",
+            message: "The authoritative responsibility source is no longer available. No transaction was started."
+          };
+          deliveryStore.finishAction({ toolName: contract.name, toolCallId, result: error }, hookContext);
+          return toolResult(error);
+        }
+        const execution = executeAuthoritativeAction(
+          source,
+          actionRequestFromOutcome(outcome, internalParams, consumed.authorization),
+          exec
+        );
+        const result = execution.ok ? execution.outcome : execution.error;
+        deliveryStore.finishAction({
+          toolName: contract.name,
+          toolCallId,
+          result,
+          ...execution.ok ? {} : { error: execution.error.error }
+        }, hookContext);
+        if (execution.ok && hasCompleteSchedulingReceipts(execution.outcome)) {
+          return toolResult({
+            ok: true,
+            dryRun: false,
+            action: outcome.action,
+            interactionId: outcome.interactionId,
+            stateVersion: outcome.stateVersion,
+            userVisibleText: deliveryStore.expectedFinalTextForToolCall(toolCallId)
+          });
+        }
+        return toolResult(execution.ok ? {
+          ok: false,
+          error: "transaction_receipt_invalid",
+          message: "The runner did not return the complete receipt required to claim scheduling success."
+        } : execution.error);
+      }
+    };
+  };
+}
+function replyPayloadText(event) {
+  const text = event.payload?.text;
+  return typeof text === "string" && text.trim() ? text : void 0;
+}
+function replaceReplyPayloadText(event, text) {
+  if (!event.payload) return void 0;
+  return { payload: { ...event.payload, text } };
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function assistantMessageText(message) {
+  if (message.role !== "assistant") return void 0;
+  if (typeof message.content === "string") return message.content;
+  if (!Array.isArray(message.content)) return void 0;
+  return message.content.filter((part) => isRecord2(part) && part.type === "text" && typeof part.text === "string").map((part) => part.text).join("\n");
+}
+function withAssistantMessageText(message, text) {
+  if (typeof message.content === "string") return { ...message, content: text };
+  if (!Array.isArray(message.content)) return message;
+  let replaced = false;
+  const content = message.content.flatMap((part) => {
+    if (isRecord2(part) && part.type === "text" && typeof part.text === "string") {
+      if (replaced) return [];
+      replaced = true;
+      return [{ ...part, text }];
+    }
+    return [part];
+  });
+  return replaced ? { ...message, content } : message;
+}
+function registerPendingContextPlugin(api, exec, runtime = {}) {
+  const config = normalizeConfig(api.pluginConfig);
+  const cache = { value: null };
+  const authorizationStore = runtime.authorization ?? createInboundAuthorizationStore(config.authorizationTtlMs, Date.now, sharedInboundAuthorizationState());
+  const deliveryStore = runtime.delivery ?? createTransactionDeliveryStore(config.authorizationTtlMs, Date.now, sharedTransactionDeliveryState());
+  api.registerTool(makeReadToolFactory(
+    PENDING_CONTRACT,
+    config,
+    exec,
+    cache,
+    (items) => runPendingTool(buildIndex(items))
+  ));
+  api.registerTool(makeActionToolFactory(
+    SELECT_OPTION_CONTRACT,
+    config,
+    exec,
+    cache,
+    authorizationStore,
+    deliveryStore,
+    (items, params, dryRun) => runSelectOptionTool(buildIndex(items), params, dryRun)
+  ));
+  api.registerTool(makeActionToolFactory(
+    REJECT_CONTRACT,
+    config,
+    exec,
+    cache,
+    authorizationStore,
+    deliveryStore,
+    (items, params, dryRun) => runRejectTool(buildIndex(items), params, dryRun)
+  ));
+  api.registerTool(makeActionToolFactory(
+    CHANGE_CONTRACT,
+    config,
+    exec,
+    cache,
+    authorizationStore,
+    deliveryStore,
+    (items, params, dryRun) => runChangeTool(buildIndex(items), params, dryRun)
+  ));
+  api.registerTool(makeReadToolFactory(
+    STATUS_CONTRACT,
+    config,
+    exec,
+    cache,
+    (items, params) => runStatusTool(buildIndex(items), params)
+  ));
+  api.registerTrustedToolPolicy({
+    id: TRUSTED_ACTION_POLICY_ID,
+    description: "Binds pending responsibility actions to one trusted inbound message and blocks post-action retries.",
+    evaluate: (event, ctx) => {
+      const toolEvent = event;
+      const toolContext = ctx;
+      if (deliveryStore.blockFurtherTool(toolEvent, toolContext)) {
+        return { block: true, blockReason: "pending_context_action_already_finished" };
+      }
+      const toolName = toolEvent.toolName ?? toolContext.toolName;
+      if (!toolName || !ACTION_TOOLS.has(toolName)) return void 0;
+      const action = deliveryStore.beginAction(toolEvent, toolContext);
+      if (!action.tracked) {
+        return { block: true, blockReason: "pending_context_missing_run_identity" };
+      }
+      if (action.duplicate) {
+        return { block: true, blockReason: "pending_context_duplicate_action" };
+      }
+      if (!authorizationStore.bindTool(toolEvent, toolContext)) {
+        deliveryStore.failAction(toolEvent, toolContext, "authorization_unavailable");
+        return { block: true, blockReason: "pending_context_authorization_unavailable" };
+      }
+      return void 0;
+    }
+  });
+  api.on("message_received", (event, ctx) => {
+    authorizationStore.recordInbound(event, ctx);
+    return void 0;
+  });
+  api.on("agent_turn_prepare", (event, ctx) => {
+    void event;
+    if (config.sources.length === 0) return void 0;
+    const turnContext = ctx ?? {};
+    const scope = turnScopeFromContext(turnContext);
+    const items = scopedItems(config, exec, cache, scope);
+    if (items.length === 0) return void 0;
+    if (authorizationStore.hasFreshBinding(scope, turnContext.runId)) {
+      deliveryStore.markPendingTurn(turnContext.runId, scope.sessionKey);
+    }
+    const block = buildInjectionBlock(items, {
+      maxChars: config.maxInjectionChars,
+      maxItems: config.maxItemsInInjection
+    });
+    if (!block) return void 0;
+    if (config.logging.decisions) {
+      api.logger?.info?.(
+        `[${PLUGIN_ID}] injected ${items.length} pending interaction(s) for session=${scope.sessionKey ?? "?"}`
+      );
+    }
+    return { appendContext: block };
+  });
+  api.on("reply_payload_sending", (event, ctx) => {
+    const reply = event;
+    const messageContext = ctx;
+    const runId = reply.runId ?? messageContext.runId;
+    const sessionKey = reply.sessionKey ?? messageContext.sessionKey;
+    if (config.suppressNonFinalReplies && reply.kind !== "final" && deliveryStore.suppressNonFinal({ ...reply, runId })) {
+      return { cancel: true, reason: "pending_context_suppressed_non_final" };
+    }
+    if (reply.kind !== "final" || !sessionKey) return void 0;
+    if (deliveryStore.finalAlreadyDelivered(sessionKey)) {
+      return { cancel: true, reason: "pending_context_duplicate_final" };
+    }
+    const modelText = replyPayloadText(reply);
+    const replacement = deliveryStore.authoritativeFinalForSession(
+      sessionKey,
+      claimsSchedulingSuccess(modelText)
+    );
+    const delivered = deliveryStore.markFinalDelivered(sessionKey);
+    if (replacement) return replaceReplyPayloadText(reply, replacement);
+    if (!delivered) return void 0;
+    return void 0;
+  });
+  api.on("before_message_write", (event, ctx) => {
+    const write = event;
+    const messageContext = ctx;
+    const sessionKey = write.sessionKey ?? messageContext.sessionKey;
+    if (!sessionKey || !isRecord2(write.message)) return void 0;
+    const current = assistantMessageText(write.message);
+    if (!current) return void 0;
+    const replacement = deliveryStore.authoritativeFinalForSession(sessionKey, claimsSchedulingSuccess(current));
+    if (!replacement || replacement === current) return void 0;
+    return { message: withAssistantMessageText(write.message, replacement) };
+  });
+}
+var index_default = definePluginEntry({
+  id: PLUGIN_ID,
+  name: "Velanir Pending Responsibility Context",
+  description: "Injects scoped pending responsibility context and finalizes scheduling claims from trusted runner receipts.",
+  register(api) {
+    registerPendingContextPlugin(api, createRunnerExec());
+  }
+});
+export {
+  PLUGIN_ID,
+  TRUSTED_ACTION_POLICY_ID,
+  index_default as default,
+  registerPendingContextPlugin,
+  toolScopeFromContext,
+  turnScopeFromContext
+};