@kynver-app/openclaw-agent-os 0.1.31 → 0.1.35

package/dist/index.js

@@ -63,6 +63,11 @@ var pluginConfigSchema = {
       default: true,
       description: "Inject a system-context block telling OpenClaw turns to use AgentOS (get_context, search_memory, write_memory, sessions, projects, goals) as the primary continuity store and to treat local markdown memory as fallback only."
     },
+    enableTelegramReplyContext: {
+      type: "boolean",
+      default: true,
+      description: "Preserve Telegram reply-thread context on visible outbound messages via reply_dispatch + message_sending hooks (reply_to tags and Re: subject prefixes)."
+    },
     runtimeSkillManifestTtlMs: {
       type: "number",
       default: 6e4,
@@ -86,6 +91,11 @@ var pluginConfigSchema = {
     harnessRepo: {
       type: "string",
       description: "Default git repo path for harness run create/dispatch. Required when enableHarnessTools is true. Falls back to KYNVER_HARNESS_REPO."
+    },
+    enableTelegramToolErrorFilter: {
+      type: "boolean",
+      default: true,
+      description: "When true, suppress raw failed exec/tool/worktree lines on Telegram and webchat direct chat (OpenClaw message_sending hook)."
     }
   }
 };
@@ -106,11 +116,13 @@ function resolvePluginConfig(rawEntry) {
     enableSessionLifecycle: typeof raw?.enableSessionLifecycle === "boolean" ? raw.enableSessionLifecycle : true,
     enableRuntimeSkillManifest: typeof raw?.enableRuntimeSkillManifest === "boolean" ? raw.enableRuntimeSkillManifest : true,
     enableContinuityGuidance: typeof raw?.enableContinuityGuidance === "boolean" ? raw.enableContinuityGuidance : true,
+    enableTelegramReplyContext: typeof raw?.enableTelegramReplyContext === "boolean" ? raw.enableTelegramReplyContext : true,
     runtimeSkillManifestTtlMs: typeof raw?.runtimeSkillManifestTtlMs === "number" && Number.isFinite(raw.runtimeSkillManifestTtlMs) && raw.runtimeSkillManifestTtlMs > 0 ? raw.runtimeSkillManifestTtlMs : 6e4,
     runtimeSkillManifestTimeoutMs: typeof raw?.runtimeSkillManifestTimeoutMs === "number" && Number.isFinite(raw.runtimeSkillManifestTimeoutMs) && raw.runtimeSkillManifestTimeoutMs > 0 ? raw.runtimeSkillManifestTimeoutMs : 1e4,
     runtimeSkillManifestMaxSkills: typeof raw?.runtimeSkillManifestMaxSkills === "number" && Number.isFinite(raw.runtimeSkillManifestMaxSkills) && raw.runtimeSkillManifestMaxSkills > 0 ? Math.floor(raw.runtimeSkillManifestMaxSkills) : 25,
     enableHarnessTools: typeof raw?.enableHarnessTools === "boolean" ? raw.enableHarnessTools : false,
-    harnessRepo: typeof raw?.harnessRepo === "string" && raw.harnessRepo.trim() ? raw.harnessRepo.trim() : process.env.KYNVER_HARNESS_REPO?.trim() || void 0
+    harnessRepo: typeof raw?.harnessRepo === "string" && raw.harnessRepo.trim() ? raw.harnessRepo.trim() : process.env.KYNVER_HARNESS_REPO?.trim() || void 0,
+    enableTelegramToolErrorFilter: typeof raw?.enableTelegramToolErrorFilter === "boolean" ? raw.enableTelegramToolErrorFilter : true
   };
 }
 
@@ -729,6 +741,14 @@ function directRequestForTool(toolName2, params, resolvedSlug) {
         method: "GET",
         path: `/command-center${queryString(params, ["since", "limit", "harnessLimit"])}`
       };
+    case "agent_os_command_center_dashboard_contract_get":
+      return {
+        route: "by-id",
+        agentOsId: stringParam(params.agentOsId),
+        slug,
+        method: "GET",
+        path: `/command-center/dashboard-contract${queryString(params, ["since", "limit"])}`
+      };
     case "agent_os_task_next_action": {
       const taskId = requiredString(params.taskId, "taskId");
       return {
@@ -933,8 +953,20 @@ function buildAgentOsContinuityGuidanceContext(config) {
     "Local markdown memory (CLAUDE.md, AGENTS.md, /memory, scratch notes) is a fallback and a cache. Use it when AgentOS is unreachable or for in-conversation scratch; do not treat it as authoritative when AgentOS is available.",
     "Tool surface: this OpenClaw plugin registers only AgentOS tools (agent_os_*). The Kynver in-app chat agent separately scopes MCP domain tools via MARM hybrid search over McpTool \u2014 it does not inject the full ~200+ tool catalog each turn. Do not paste full MCP JSON schemas into local files; call the tools you need.",
     "Privacy: AgentOS context is personal to the signed-in account. Do not expose AgentOS identity, goals, projects, contacts, or memory excerpts in shared, broadcast, group, or multi-tenant contexts unless the user explicitly asks for it. If you cannot determine the channel scope, withhold AgentOS specifics by default.",
+    "",
+    "Telegram reply-thread UX:",
+    "- When Conversation info (untrusted metadata) includes reply_to_id or has_reply_context, or the turn includes a Reply target / Current message [Replying to: \u2026] block, treat that quoted/status text as the subject of the user's question.",
+    '- Visible replies must make the target obvious: either send as a threaded reply (message tool / native delivery with reply_to) or open the answer by naming what you are addressing (e.g. Re: "<short quote from the reply target>").',
+    "- Do not answer a reply-thread/status question with a generic paragraph that ignores the quoted message \u2014 that reads like a memory failure to the operator.",
     "If an AgentOS call fails or returns unavailable, say so explicitly, fall back to local markdown or conversation memory for that turn, and ask the user before persisting anything that would normally go to AgentOS.",
     "",
+    "AgentTask priority (board create \u2014 checklist):",
+    "- Default agent_os_task_create to priority normal (low for routine cleanup). Omit priority to use normal.",
+    "- Do NOT copy a plan's or goal's priority onto a new task \u2014 a critical plan still gets normal-priority implementation tasks.",
+    "- Use high/critical only when Will explicitly said so in this turn (quote him in priorityEscalationReason) or there is a live production/security incident.",
+    "- When worker capacity is available, important work stays normal \u2014 escalate priority only for capacity constraints or explicit user emergency language.",
+    "- The API downgrades unsolicited high/critical to normal; blocked tasks are already treated as critical by dispatch/graph logic.",
+    "",
     "Command Center (operational control plane):",
     "- For the same unified rollup the browser Command Center uses (projects, plans, action-required, DQ inbox, harness summaries, runtime capacity, packageVersionHealth for @kynver-app/runtime), call agent_os_command_center_get. Omit slug to resolve the account primary workspace; pass agentOsId when you already have it from a prior identity fetch. When packageVersionHealth shows use_repo_source, run from the monorepo checkout (sourceVersionEvidence.consumeCommands) \u2014 never npm publish and never block on operator publish. install_needed/reload_needed may use global installs only when an operator directs it.",
     "",
@@ -1131,6 +1163,243 @@ function sanitizeRuntimeSkillError(error) {
   return raw.replace(/(Bearer\s+)[A-Za-z0-9._~+\/-]+/gi, "$1[redacted]").slice(0, 240);
 }
 
+// src/telegram-reply-context.ts
+var REPLY_TAG_RE = /\[\[reply_to(?:_current)?(?::[^\]]+)?\]\]/i;
+function parseTelegramMessageId(value) {
+  if (typeof value === "number" && Number.isFinite(value) && value > 0) {
+    return Math.trunc(value);
+  }
+  if (typeof value === "string") {
+    const trimmed = value.trim();
+    if (!trimmed) return void 0;
+    const parsed = Number.parseInt(trimmed, 10);
+    if (Number.isFinite(parsed) && parsed > 0) return parsed;
+  }
+  return void 0;
+}
+function hasInboundReplyMetadata(meta) {
+  if (!meta) return false;
+  if (meta.has_reply_context === true) return true;
+  if (parseTelegramMessageId(meta.reply_to_id) !== void 0) return true;
+  if (typeof meta.reply_to_body === "string" && meta.reply_to_body.trim().length > 0) return true;
+  return false;
+}
+function summarizeReplySubject(quote, maxLen = 120) {
+  const collapsed = quote.replace(/\s+/g, " ").trim();
+  if (!collapsed) return "";
+  if (collapsed.length <= maxLen) return collapsed;
+  return `${collapsed.slice(0, Math.max(0, maxLen - 1)).trimEnd()}\u2026`;
+}
+function formatReplySubjectPrefix(quote) {
+  const subject = summarizeReplySubject(quote);
+  if (!subject) return "";
+  return `Re: "${subject}"
+
+`;
+}
+function visibleTextReferencesReplyTarget(text, quote) {
+  if (!quote.trim() || !text.trim()) return false;
+  if (REPLY_TAG_RE.test(text)) return true;
+  const subject = summarizeReplySubject(quote, 80).toLowerCase();
+  if (!subject) return false;
+  return text.toLowerCase().includes(subject);
+}
+function applyInboundReplyContextToVisibleReply(input) {
+  const baseText = input.text ?? "";
+  const explicitReply = parseTelegramMessageId(input.replyToMessageId);
+  if (explicitReply !== void 0) {
+    return { text: baseText, replyToMessageId: explicitReply };
+  }
+  const inbound = input.inbound;
+  if (!hasInboundReplyMetadata(inbound)) {
+    return { text: baseText };
+  }
+  const threadTarget = parseTelegramMessageId(inbound?.message_id) ?? parseTelegramMessageId(inbound?.reply_to_id);
+  const quote = typeof inbound?.reply_to_body === "string" && inbound.reply_to_body.trim() ? inbound.reply_to_body : "";
+  if (threadTarget !== void 0 && !REPLY_TAG_RE.test(baseText)) {
+    const tag = `[[reply_to:${threadTarget}]]`;
+    const withTag = baseText.startsWith(tag) ? baseText : `${tag}${baseText}`;
+    return { text: withTag, replyToMessageId: threadTarget };
+  }
+  if (quote && !visibleTextReferencesReplyTarget(baseText, quote)) {
+    return { text: `${formatReplySubjectPrefix(quote)}${baseText}` };
+  }
+  return { text: baseText };
+}
+function normalizeOptionalString(value) {
+  if (typeof value !== "string") return void 0;
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function extractInboundReplyContextFromOpenClawCtx(ctx) {
+  const replyToBody = normalizeOptionalString(ctx.ReplyToBody) ?? normalizeOptionalString(ctx.ReplyToQuoteText);
+  const replyToId = normalizeOptionalString(ctx.ReplyToId);
+  const messageId = normalizeOptionalString(ctx.MessageSid) ?? normalizeOptionalString(ctx.MessageSidFull);
+  const replyChain = ctx.ReplyChain;
+  const hasChain = Array.isArray(replyChain) && replyChain.length > 0;
+  const inbound = {
+    reply_to_id: replyToId,
+    reply_to_body: replyToBody,
+    message_id: messageId,
+    has_reply_context: Boolean(replyToBody || replyToId || hasChain) ? true : void 0
+  };
+  return hasInboundReplyMetadata(inbound) ? inbound : null;
+}
+function conversationKeyForOpenClawInbound(ctx) {
+  const channel = normalizeOptionalString(ctx.OriginatingChannel) ?? normalizeOptionalString(ctx.Surface) ?? normalizeOptionalString(ctx.Provider);
+  const chatId = normalizeOptionalString(ctx.OriginatingTo);
+  if (!channel || !chatId) return void 0;
+  return `${channel.toLowerCase()}:${chatId}`;
+}
+function isTelegramOpenClawInbound(ctx) {
+  return [ctx.OriginatingChannel, ctx.Surface, ctx.Provider].some(
+    (value) => normalizeOptionalString(value)?.toLowerCase() === "telegram"
+  );
+}
+
+// src/telegram-reply-hooks.ts
+var STASH_TTL_MS = 15 * 6e4;
+function pruneStash(stash) {
+  const cutoff = Date.now() - STASH_TTL_MS;
+  for (const [key, entry] of stash) {
+    if (entry.stashedAt < cutoff) stash.delete(key);
+  }
+}
+function stashKeyFromSession(sessionKey, conversationKey) {
+  if (sessionKey?.trim()) return `session:${sessionKey.trim()}`;
+  if (conversationKey) return `conv:${conversationKey}`;
+  return void 0;
+}
+function registerTelegramReplyContextHooks({
+  api,
+  config
+}) {
+  if (!config.enableTelegramReplyContext || typeof api?.on !== "function") {
+    return false;
+  }
+  const stash = /* @__PURE__ */ new Map();
+  api.on(
+    "reply_dispatch",
+    async (event) => {
+      const record = event;
+      const ctx = record.ctx;
+      if (!ctx || !isTelegramOpenClawInbound(ctx)) return;
+      const inbound = extractInboundReplyContextFromOpenClawCtx(ctx);
+      if (!inbound) return;
+      const conversationKey = conversationKeyForOpenClawInbound(ctx);
+      const key = stashKeyFromSession(record.sessionKey, conversationKey);
+      if (!key) return;
+      pruneStash(stash);
+      stash.set(key, {
+        conversationKey: conversationKey ?? key,
+        inbound,
+        stashedAt: Date.now()
+      });
+    },
+    { priority: 6, timeoutMs: 500 }
+  );
+  api.on(
+    "message_sending",
+    async (event, channelCtx) => {
+      const sending = event;
+      const ctx = channelCtx;
+      if (ctx.channelId !== "telegram") return;
+      const text = typeof sending.content === "string" ? sending.content : "";
+      if (!text.trim()) return;
+      pruneStash(stash);
+      const convKey = ctx.conversationId ? `telegram:${ctx.conversationId}` : void 0;
+      const stashed = (ctx.sessionKey ? stash.get(`session:${ctx.sessionKey}`) : void 0) ?? (convKey ? stash.get(`conv:${convKey}`) : void 0);
+      if (!stashed) return;
+      const explicitReply = parseTelegramMessageId(sending.replyToId);
+      const adjusted = applyInboundReplyContextToVisibleReply({
+        text,
+        inbound: stashed.inbound,
+        replyToMessageId: explicitReply
+      });
+      if (adjusted.text === text) return { content: text };
+      return { content: adjusted.text };
+    },
+    { priority: 6, timeoutMs: 2e3 }
+  );
+  return true;
+}
+
+// src/telegram-tool-error-filter.ts
+var DIRECT_CHAT_CHANNEL_IDS = /* @__PURE__ */ new Set(["telegram", "webchat"]);
+var RAW_TOOL_ERROR_WARNING_RE = /^⚠️\s*🛠️\s*.+\bfailed\b/ui;
+var INTERNAL_TRACE_LINE_RE = /^(?:>\s*)?(?:📊|🛠️|📖|📝|🔍|🔎|⚙️)\s*(?:Session Status|Exec|Read|Edit|Write|Patch|Search|Open|Click|Find|Screenshot|Update Plan|Tool Call|Tool Result|Function Call|Shell|Command)\s*:/i;
+var COMPACT_TOOL_COMMAND_LINE_RE = /^(?:>\s*)?🛠️\s*(?:(?:(?:elevated|pty)\b\s*(?:·|,)\s*)+)?(?:`{1,2}\s*\S|(?:run|check|fetch|pull|push|view|show|list|switch|create|merge|rebase|stage|restore|reset|stash|search|find|print|copy|move|remove|install|start|cd|git|worktree|pnpm|npm|yarn|bun|node|python|python3|bash|sh)\b)/i;
+var TOOL_AGENT_SCOPE_RE = /\(in\s+[~\/]|\(agent\)/i;
+function isDirectChatChannel(channelId) {
+  if (!channelId) return false;
+  const normalized = channelId.trim().toLowerCase();
+  return DIRECT_CHAT_CHANNEL_IDS.has(normalized);
+}
+function isRawInternalToolFailureLine(line) {
+  const trimmed = line.trim();
+  if (!trimmed) return false;
+  if (RAW_TOOL_ERROR_WARNING_RE.test(trimmed)) return true;
+  if (INTERNAL_TRACE_LINE_RE.test(trimmed)) return true;
+  if (COMPACT_TOOL_COMMAND_LINE_RE.test(trimmed)) {
+    if (/\bfailed\b/i.test(trimmed)) return true;
+    if (TOOL_AGENT_SCOPE_RE.test(trimmed)) return true;
+  }
+  if (/^🛠️\s+/u.test(trimmed) && /\bfailed\b/i.test(trimmed) && TOOL_AGENT_SCOPE_RE.test(trimmed)) {
+    return true;
+  }
+  return false;
+}
+function filterDirectChatOutboundContent(content) {
+  if (!content.trim()) return { action: "pass", content };
+  const lines = content.split(/\r?\n/);
+  const kept = [];
+  let suppressedAny = false;
+  for (const line of lines) {
+    if (isRawInternalToolFailureLine(line)) {
+      suppressedAny = true;
+      continue;
+    }
+    kept.push(line);
+  }
+  const next = kept.join("\n").replace(/\n{3,}/g, "\n\n").trim();
+  if (!next) {
+    return suppressedAny ? { action: "suppress", reason: "kynver_suppressed_raw_internal_tool_failure" } : { action: "pass", content: "" };
+  }
+  if (suppressedAny && next !== content.trim()) {
+    return { action: "pass", content: next };
+  }
+  return { action: "pass", content };
+}
+
+// src/telegram-tool-error-hook.ts
+function registerTelegramToolErrorFilterHook({
+  api,
+  config
+}) {
+  if (config.enableTelegramToolErrorFilter === false) return false;
+  if (typeof api?.on !== "function") return false;
+  api.on(
+    "message_sending",
+    async (event, ctx) => {
+      if (!isDirectChatChannel(ctx?.channelId)) return;
+      const content = typeof event?.content === "string" ? event.content : "";
+      if (!content.trim()) return;
+      const filtered = filterDirectChatOutboundContent(content);
+      if (filtered.action === "suppress") {
+        return {
+          cancel: true,
+          cancelReason: filtered.reason
+        };
+      }
+      if (filtered.content !== content) {
+        return { content: filtered.content };
+      }
+    },
+    { priority: 8, timeoutMs: 500 }
+  );
+  return true;
+}
+
 // src/schemas/common.ts
 var stringArray = {
   type: "array",
@@ -2326,7 +2595,15 @@ var taskExecutorValues = ["inline", "harness", "acp", "manual"];
 var taskEventTypeValues = ["created", "started", "worker_update", "blocked", "steer", "artifact", "review", "done", "failed"];
 var artifactVisibilityValues = ["internal", "telegram_safe", "public_pr_safe"];
 var taskStatus = { type: "string", enum: taskStatusValues };
-var taskPriority = { type: "string", enum: taskPriorityValues };
+var taskPriority = {
+  type: "string",
+  enum: taskPriorityValues,
+  description: "Default normal. Do not inherit plan/goal priority. high/critical only with priorityEscalationReason (Will quoted or live prod/security incident) \u2014 else server downgrades to normal."
+};
+var priorityEscalationReason = {
+  type: "string",
+  description: "When priority is high/critical: cite Will's words or the incident. Required for escalation unless title/description already do."
+};
 var taskExecutor = { type: "string", enum: taskExecutorValues };
 var taskEventType = { type: "string", enum: taskEventTypeValues };
 var artifactVisibility = { type: "string", enum: artifactVisibilityValues };
@@ -2347,6 +2624,7 @@ var createTaskSchema = {
     title: { type: "string", description: "Short task title." },
     description: { type: "string" },
     priority: taskPriority,
+    priorityEscalationReason,
     executor: taskExecutor,
     executorRef: { type: "string" },
     parentTaskId: { type: "string" },
@@ -2667,6 +2945,26 @@ var slugField = {
   type: "string",
   description: "AgentOS workspace slug. Omit to use the account's primary AgentOS workspace."
 };
+var commandCenterDashboardContractSchema = {
+  type: "object",
+  properties: {
+    slug: slugField,
+    agentOsId: {
+      type: "string",
+      description: "Optional AgentOS row id. When omitted, resolved from slug."
+    },
+    since: {
+      type: "string",
+      description: "ISO timestamp \u2014 only include tasks updated after this instant."
+    },
+    limit: {
+      type: "number",
+      description: "Max tasks to load when building counts (server cap 10000)."
+    }
+  },
+  additionalProperties: false,
+  $schema: "http://json-schema.org/draft-07/schema#"
+};
 var commandCenterGetSchema = {
   type: "object",
   properties: {
@@ -2816,9 +3114,14 @@ function createCommandCenterTools(config) {
   return [
     mk(
       "agent_os_command_center_get",
-      "Fetch the unified Command Center rollup for the AgentOS workspace: plan rollups, project hierarchy, action-required items, DQ inbox, goals, review lanes, and harness summaries \u2014 the same aggregate the browser Command Center uses.",
+      "Fetch the unified Command Center rollup (includes countSnapshot \u2014 canonical badge counts). Same aggregate as the browser Command Center.",
       commandCenterGetSchema
     ),
+    mk(
+      "agent_os_command_center_dashboard_contract_get",
+      "Slim dashboard contract for runtime verification: countSnapshot, packageVersionHealth, runtime capacity, activePlanRollups \u2014 no graph/hierarchy.",
+      commandCenterDashboardContractSchema
+    ),
     mk(
       "agent_os_task_next_action",
       "Route the deterministic next harness action after a worker, reviewer, or landing lane completes (dispatch review/fix/landing, close, or await human). Same POST surface as the production harness completion hook.",
@@ -2873,7 +3176,9 @@ var plugin = {
       api.registerTool(tool);
     }
     registerAgentOsContinuityGuidanceHook({ api, config });
+    registerTelegramReplyContextHooks({ api, config });
     registerRuntimeSkillManifestHook({ api, config });
+    registerTelegramToolErrorFilterHook({ api, config });
     if (config.enableSessionLifecycle && typeof api.on === "function") {
       const sessionIds = /* @__PURE__ */ new Map();
       const keyFor = (event, ctx) => String(event?.sessionKey || ctx?.sessionKey || event?.sessionId || ctx?.sessionId || "");