@segmentstream/agent 0.8.5 → 0.8.7

package/README.md

@@ -606,3 +606,33 @@ HTTP 503 with a correlation reference before durable queue admission. Telegram
 can redeliver the same source; the hook and attachment reservation must preserve
 idempotent source membership, storage results and the single acknowledgement.
 Such a failure must not become an HTTP success with no queued work.
+
+### Legacy held approvals
+
+Deferred mode supplies four eager tools: `segmentstream__ontology_discover`,
+`segmentstream__ontology_describe`, `segmentstream__ontology_inspect` and `segmentstream__ontology_call`. Registration
+does not fetch the full ontology catalog. Discovery and descriptions remain
+permission-filtered reads; descriptions provide the exact `tool_name` and input
+schema for execution. Calls retain the same member-bound deferred confirmation
+boundary. Metadata failures are reported by the tool instead of removing the
+entire ontology surface from the turn.
+The inspector exposes the full member-permitted input schemas for ordinary record
+find/get/history operations on demand. Describe/discover accept `expected_hash`
+to reject mixed ontology versions.
+
+With `attachmentLifecycle.contextVersion: 2`, lifecycle data includes `source_at` when Telegram provides its
+original message timestamp, so a workspace can group related uploads despite
+serial webhook delivery delays. A completion hook receives the model's `reply`
+alongside its intake key, allowing workspace-owned status copy to retain an
+actionable explanation. Reply delivery carries the owning turn's reply anchor
+explicitly after restore. Omitting the version preserves existing closed lifecycle
+data schemas; workspaces opt in only after their hook accepts the additional fields.
+
+Explicit `confirmations.mode: "held"` overrides the deferred default. Switching a package version
+does not migrate already-running held turns. In deferred mode the Telegram adapter reads the owning session's
+recorded approval inputs and requests cancellation of that exact turn before admitting a new
+addressed message. It never approves the old call or reuses the old member's authorization.
+Cancellation failure requests webhook replay; terminal/resolved approvals are left alone.
+Deferred mode retains its ten-minute database deadline and minute expiry sweep. Runtime health
+reports the effective confirmation mode and attachment-lifecycle presence behind its existing
+runtime authentication; source pins and public health alone are not settings-adoption proof.

package/dist/_chunks/{build-metadata-BYl-5kFi.mjs → build-metadata-CR18wzcH.mjs}

@@ -4,7 +4,7 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-var version = "0.8.5";
+var version = "0.8.7";
 function agentBuild(environment = process.env) {
 	return {
 		agent: version,

package/dist/extension/config.mjs

@@ -95,13 +95,25 @@ function telegramSettings(value, issues) {
 	const lifecycle = section({
 		value: telegram.attachmentLifecycle,
 		path: [...path, "attachmentLifecycle"],
-		allowed: ["entity", "action"],
+		allowed: [
+			"entity",
+			"action",
+			"contextVersion"
+		],
 		issues
 	});
 	if (lifecycle !== void 0 && ["entity", "action"].some((key) => typeof lifecycle[key] !== "string" || !/^(?:[a-z][a-zA-Z0-9]*|[a-z][a-z0-9]*(?:_[a-z0-9]+)*)$/.test(String(lifecycle[key])))) issues.push({
 		message: "must name a valid ontology entity and action",
 		path: [...path, "attachmentLifecycle"]
 	});
+	if (lifecycle?.contextVersion !== void 0 && lifecycle.contextVersion !== 2) issues.push({
+		message: "must be 2 when specified",
+		path: [
+			...path,
+			"attachmentLifecycle",
+			"contextVersion"
+		]
+	});
 	return typeof connection === "string" && isTelegramPolicy(policy) ? {
 		connection,
 		policy,
@@ -109,7 +121,8 @@ function telegramSettings(value, issues) {
 		additionalOwnOrigins,
 		...lifecycle === void 0 ? {} : { attachmentLifecycle: {
 			entity: String(lifecycle.entity),
-			action: String(lifecycle.action)
+			action: String(lifecycle.action),
+			...lifecycle.contextVersion === 2 ? { contextVersion: 2 } : {}
 		} }
 	} : null;
 }

package/dist/extension/instructions.md

@@ -3,7 +3,15 @@
 You are the workspace's agent on SegmentStream. Every conversation runs as the member who is
 talking to you, and you act with exactly their permissions.
 
-- The company's records live in the ontology, reached through `segmentstream__ontology`.
+- The company's records live in the ontology. With deferred confirmations, use
+  `segmentstream__ontology_discover` to search permitted definitions,
+  `segmentstream__ontology_describe` to inspect their refs and schemas, and
+  `segmentstream__ontology_call` to run their exact `tool_name` with schema-matching arguments.
+  For record reads (find/get/history), use `segmentstream__ontology_inspect` to discover
+  exact MCP names and input schemas. Pass returned ontology hashes as `expected_hash`
+  on subsequent describe/discover requests so a redeployment cannot mix definitions.
+  These tools are directly available; do not search a connection namespace to find them.
+  With held confirmations the same operations are reached through `segmentstream__ontology`.
   Call `me` when you need to check whom you act for. For an unfamiliar task, call `describe`
   without a ref for a compact entity index, or `discover` to search names and descriptions.
   Inspect relevant `entity:`, `action:`, or `measure:` refs with `describe` for their complete

package/dist/extension/lib/attachment-tables.mjs

@@ -115,8 +115,9 @@ function present(value) {
 }
 function detectedHeader(rows) {
 	const candidates = rows.slice(0, 50);
-	const width = candidates.reduce((maximum, row) => Math.max(maximum, row.length), 0);
-	const labels = candidates.findIndex((row) => row.length >= Math.max(1, width - 1) && row.some(present) && row.filter(present).every((value) => typeof value === "string" && numeric(value) === null && dateValue(value, "day_first") === null && dateValue(value, "month_first") === null));
+	const width = candidates.reduce((maximum, row) => Math.max(maximum, row.findLastIndex(present) + 1), 0);
+	const minimumLabels = Math.min(width, 2);
+	const labels = candidates.findIndex((row) => row.filter(present).length >= minimumLabels && row.some(present) && row.filter(present).every((value) => typeof value === "string" && numeric(value) === null && dateValue(value, "day_first") === null && dateValue(value, "month_first") === null));
 	if (labels >= 0) return labels;
 	return -1;
 }

package/dist/extension/lib/build-metadata.mjs

@@ -4,5 +4,5 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { t as agentBuild } from "../../_chunks/build-metadata-BYl-5kFi.mjs";
+import { t as agentBuild } from "../../_chunks/build-metadata-CR18wzcH.mjs";
 export { agentBuild };

package/dist/extension/lib/ontology-gateway.d.ts

@@ -0,0 +1,20 @@
+import type { ToolContext } from "eve/tools";
+import { ontologyTools } from "./ontology-tools.js";
+type Options = Omit<NonNullable<Parameters<typeof ontologyTools>[0]>, "principal">;
+/** Metadata is requested only when the model uses it, never while registering its tools. */
+export declare function ontologyMetadata(memberId: string, operation: "describe" | "discover", input: Record<string, unknown>, context: ToolContext, options?: Options): Promise<Record<string, unknown>>;
+/** Ordinary record operations are not part of entity/action discovery. Inspect their
+ * real member-filtered MCP schemas on demand, never during dynamic registration. */
+export declare function ontologyInspect(memberId: string, input: {
+    name?: string;
+    query?: string;
+    after?: string;
+    limit?: number;
+}, context: ToolContext, options?: Options): Promise<{
+    next_after?: string | undefined;
+    tools: {
+        name: string;
+        description: string;
+    }[];
+}>;
+export {};

package/dist/extension/lib/ontology-gateway.mjs

@@ -0,0 +1,44 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import { memberIdOf } from "./telegram/principal.mjs";
+import { object } from "./confirmation-description.mjs";
+import { ontologyTools } from "./ontology-tools.mjs";
+async function ontologyMetadata(memberId, operation, input, context, options = {}) {
+	const principal = context.session.auth.current;
+	if (memberIdOf(principal) !== memberId) throw new Error("The ontology tool belongs to another member.");
+	const result = await ontologyTools({
+		...options,
+		principal
+	}).rpc(memberId, "tools/call", {
+		name: operation,
+		arguments: input
+	});
+	return result.structuredContent === void 0 ? result : object(result.structuredContent);
+}
+async function ontologyInspect(memberId, input, context, options = {}) {
+	const principal = context.session.auth.current;
+	if (memberIdOf(principal) !== memberId) throw new Error("The ontology tool belongs to another member.");
+	const tools = (await ontologyTools({
+		...options,
+		principal
+	}).list(memberId)).flatMap((tool) => typeof tool.name === "string" ? [{
+		...tool,
+		name: tool.name,
+		description: String(tool.description ?? "")
+	}] : []);
+	const words = input.query?.toLowerCase().split(/\s+/u).filter(Boolean) ?? [];
+	const matched = tools.filter((tool) => input.name !== void 0 ? tool.name === input.name : words.every((word) => `${tool.name} ${tool.description}`.toLowerCase().includes(word))).sort((a, b) => a.name.localeCompare(b.name));
+	if (input.name !== void 0 && matched.length === 0) throw new Error("The requested operation is not available to the current member.");
+	const remaining = matched.filter((tool) => input.after === void 0 || tool.name.localeCompare(input.after) > 0);
+	const limit = Math.min(50, Math.max(1, input.limit ?? 20));
+	const page = remaining.slice(0, limit);
+	return {
+		tools: page,
+		...remaining.length > limit ? { next_after: page.at(-1).name } : {}
+	};
+}
+export { ontologyInspect, ontologyMetadata };

package/dist/extension/lib/telegram/adapter.mjs

@@ -8,7 +8,7 @@ import { manifestOf } from "../../config.mjs";
 import { appOrigin, channelsEnabled, proxyEnvironment, runtimeIdentityEnvironment, webhookSecret } from "../environment.mjs";
 import { conversationLanguage, telegramPrincipal } from "./principal.mjs";
 import { chooseModel } from "../../model.mjs";
-import { t as agentBuild } from "../../../_chunks/build-metadata-BYl-5kFi.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-CR18wzcH.mjs";
 import { confirmationLocale } from "./confirmation-text.mjs";
 import { telegramSendScope } from "./send-queue.mjs";
 import { d as failureText, h as withDeliveryLocale, i as withReplacedText, m as safeTelegramFetch, n as currentInboundRequest, p as reportTelegramError, r as runInboundRequest, t as InboundRequest } from "../../../_chunks/inbound-request-B98tr4Pd.mjs";
@@ -166,6 +166,7 @@ function segmentstreamTelegram(options) {
 					request: currentInboundRequest(),
 					dependencies: {
 						policy: settings().policy,
+						recoverHeldApprovals: options.confirmationMode?.() === "deferred",
 						...settings().attachmentLifecycle === void 0 ? {} : { lifecycle: (principal, memberId, message) => attachmentLifecycle({
 							configuration: settings().attachmentLifecycle,
 							principal,
@@ -252,7 +253,7 @@ function segmentstreamTelegram(options) {
 			} catch (error) {
 				recordGateDecision("inbound_message_failed");
 				const errorId = reportTelegramError("inbound_message_failed", error, { chatId: message.chat.id });
-				if (inbound?.lifecycleKey !== void 0) inbound.retryReference = errorId;
+				if (inbound?.retryReference !== void 0 || inbound?.lifecycleKey !== void 0) inbound.retryReference = errorId;
 				else await context.telegram.post(failureText(errorId));
 				return null;
 			} finally {
@@ -318,7 +319,10 @@ function segmentstreamTelegram(options) {
 							messageThreadId: channel.telegram.messageThreadId,
 							from: { id: principal.subject ?? "" }
 						}
-					})("completed", { key: taskId });
+					})("completed", {
+						key: taskId,
+						...configuration.contextVersion === 2 ? { reply: event.message } : {}
+					});
 					if (result.message !== void 0 || result.complete === false) event = {
 						...event,
 						message: result.message ?? ""
@@ -394,7 +398,11 @@ function segmentstreamTelegram(options) {
 			chats,
 			enabled: () => channelsEnabled(environment),
 			configured: () => options.settings() !== null,
-			verify: () => verify ??= runtimeTokenVerifier(runtimeIdentityEnvironment(environment))
+			verify: () => verify ??= runtimeTokenVerifier(runtimeIdentityEnvironment(environment)),
+			configuration: () => ({
+				confirmationMode: options.confirmationMode?.() ?? null,
+				attachmentLifecycle: options.settings()?.attachmentLifecycle !== void 0
+			})
 		})]
 	};
 }
@@ -466,7 +474,7 @@ function gatedRoute(input) {
 					await Promise.all(pending);
 				}
 				if (inbound.retryReference !== void 0) return Response.json({
-					error: "attachment_intake_retry",
+					error: "telegram_turn_retry",
 					reference: inbound.retryReference
 				}, {
 					status: 503,

package/dist/extension/lib/telegram/confirmation-text.d.ts

@@ -11,6 +11,7 @@ export interface ConfirmationCopy {
     readonly cancelled: string;
     readonly failed: string;
     readonly expired?: string;
+    readonly interrupted?: string;
     readonly edit?: string;
 }
 export interface ConfirmationText {
@@ -23,6 +24,7 @@ export interface ConfirmationText {
     readonly completed: string;
     readonly failed: string;
     readonly expired: string;
+    readonly interrupted: string;
     readonly edit: string;
 }
 export declare function confirmationLocale(principal: SessionAuthContext | null, fallback?: string): string;

package/dist/extension/lib/telegram/confirmation-text.mjs

@@ -38,7 +38,11 @@ function confirmationCopy(value) {
 		"cancelled",
 		"failed"
 	];
-	const optional = ["expired", "edit"];
+	const optional = [
+		"expired",
+		"interrupted",
+		"edit"
+	];
 	const valid = (key) => {
 		const text = copy[key];
 		return typeof text === "string" && text === text.trim() && (key === "question" || !/[✅❌⌛⚠❓✏]/u.test(text)) && humanText(text, key === "question" ? 300 : 24) === text;
@@ -72,6 +76,7 @@ function renderConfirmation(description, copy) {
 		completed: copy === void 0 ? "✅" : `✅ ${copy.done}`,
 		failed: copy === void 0 ? "⚠️" : `⚠️ ${copy.failed}`,
 		expired: copy?.expired === void 0 ? "⌛" : `⌛ ${copy.expired}`,
+		interrupted: copy?.interrupted === void 0 ? "⏸" : `⏸ ${copy.interrupted}`,
 		edit: copy?.edit === void 0 ? "✏️" : `✏️ ${copy.edit}`
 	};
 }

package/dist/extension/lib/telegram/confirmations.mjs

@@ -70,7 +70,7 @@ function routingConfirmationState(events, prompt, at) {
 			}
 		}
 		if (event.type === "input.resolved" && Array.isArray(data.resolutions)) {
-			for (const resolution of data.resolutions) if (object(resolution).requestId === prompt.requestId) state = object(resolution).outcome === "approved" ? "approved" : "cancelled";
+			for (const resolution of data.resolutions) if (object(resolution).requestId === prompt.requestId) state = object(resolution).outcome === "approved" ? "approved" : object(resolution).outcome === "ignored" ? "interrupted" : "cancelled";
 		}
 		if (event.type === "action.result" && callId !== void 0 && object(data.result).callId === callId) state = data.status === "completed" ? "completed" : "failed";
 	}
@@ -361,7 +361,7 @@ function telegramConfirmationEvents(archive, observed, deferredOptions) {
 				const [callId, message] = entry;
 				const copy = message.copy ?? renderConfirmation();
 				const reason = confirmations.get()[callId]?.cancellationReason;
-				const status = resolution.outcome === "approved" ? copy.executing : reason === "expired" ? copy.expired : copy.cancelled;
+				const status = resolution.outcome === "approved" ? copy.executing : reason === "expired" ? copy.expired : resolution.outcome === "ignored" ? copy.interrupted : copy.cancelled;
 				const text = message.exactPost ? chatPostCardStatus(message.text, status) : `${message.text}\n\n${status}`;
 				const edit = () => channel.telegram.editMessageText({
 					messageId: message.messageId,
@@ -370,7 +370,7 @@ function telegramConfirmationEvents(archive, observed, deferredOptions) {
 				});
 				const prompt = {
 					...messagePrompt(message),
-					state: resolution.outcome === "approved" ? "approved" : reason === "expired" ? "expired" : "cancelled"
+					state: resolution.outcome === "approved" ? "approved" : reason === "expired" ? "expired" : resolution.outcome === "ignored" ? "interrupted" : "cancelled"
 				};
 				message.prompt = prompt;
 				await withConfirmationPrompt(prompt, () => message.exactPost ? withChatPostCard(text, edit, [...message.previewLinks ?? [], ...telegramTextLinks(status)]) : withConfirmationText(text, edit));

package/dist/extension/lib/telegram/health.d.ts

@@ -9,4 +9,8 @@ export declare function healthRoute(input: {
     readonly enabled: () => boolean;
     readonly configured: () => boolean;
     readonly verify: () => RuntimeTokenVerifier;
+    readonly configuration?: () => {
+        readonly confirmationMode: "deferred" | "held" | null;
+        readonly attachmentLifecycle: boolean;
+    };
 }): RouteDefinition<TelegramChannelState>;

package/dist/extension/lib/telegram/health.mjs

@@ -4,7 +4,7 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { t as agentBuild } from "../../../_chunks/build-metadata-BYl-5kFi.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-CR18wzcH.mjs";
 import { runtimeRequestFailure } from "./runtime-request.mjs";
 import { GET } from "eve/channels";
 const HEALTH_ROUTE = "/eve/v1/telegram/health";
@@ -16,7 +16,8 @@ function healthRoute(input) {
 		return Response.json({
 			status: registry.degraded ? "degraded" : "ok",
 			registry,
-			runtime: agentBuild()
+			runtime: agentBuild(),
+			...input.configuration === void 0 ? {} : { configuration: input.configuration() }
 		}, {
 			status: registry.degraded ? 503 : 200,
 			headers: { "cache-control": "no-store" }

package/dist/extension/lib/telegram/held-approvals.d.ts

@@ -0,0 +1,27 @@
+import type { CancelTurnResult } from "eve/channels";
+import type { RecordedEvent } from "./sessions.js";
+/** An approval is an input barrier, never permission to execute it while recovering a chat. */
+export declare function heldApprovals(events: readonly RecordedEvent[]): {
+    requestId: string;
+    callId: string;
+    action: string;
+    turnId: string;
+    at: string;
+}[];
+/** Cancel the exact parked turn; never steer a new member into its permissions or old task. */
+export declare function releaseHeldApproval(input: {
+    readonly events: readonly RecordedEvent[];
+    readonly addressed: boolean;
+    readonly now: number;
+    readonly cancel: (options: {
+        readonly turnId: string;
+    }) => Promise<CancelTurnResult>;
+}): Promise<{
+    status: string;
+    reason: string;
+    turnId: string;
+    startedAt: string;
+    actions: string[];
+    cancellation: "accepted";
+    executionRequested: boolean;
+} | undefined>;

package/dist/extension/lib/telegram/held-approvals.mjs

@@ -0,0 +1,51 @@
+import { fileURLToPath as __eveFileURLToPath } from "node:url";
+import { dirname as __eveDirname } from "node:path";
+import { createRequire as __eveCreateRequire } from "node:module";
+const __filename = __eveFileURLToPath(import.meta.url);
+__eveDirname(__filename);
+__eveCreateRequire(import.meta.url);
+import { object } from "../confirmation-description.mjs";
+import { CONFIRMATION_TTL_MS } from "../confirmations.mjs";
+function heldApprovals(events) {
+	const pending = new Map();
+	for (const event of events) {
+		const data = object(event.data);
+		if (event.type === "context.cleared" || event.type === "session.started") pending.clear();
+		if (event.type === "input.requested" && Array.isArray(data.requests)) for (const item of data.requests) {
+			const request = object(item);
+			const action = object(request.action);
+			if (request.kind === "tool-approval" && typeof request.requestId === "string" && typeof action.callId === "string" && typeof data.turnId === "string") pending.set(request.requestId, {
+				requestId: request.requestId,
+				callId: action.callId,
+				action: String(action.toolName ?? ""),
+				turnId: data.turnId,
+				at: event.meta.at
+			});
+		}
+		for (const [id, approval] of pending) if (event.type === "input.resolved" && Array.isArray(data.resolutions) && data.resolutions.some((item) => object(item).requestId === id) || event.type === "action.result" && object(data.result).callId === approval.callId || [
+			"turn.completed",
+			"turn.failed",
+			"turn.cancelled"
+		].includes(event.type) && data.turnId === approval.turnId) pending.delete(id);
+	}
+	return [...pending.values()];
+}
+async function releaseHeldApproval(input) {
+	const pending = heldApprovals(input.events);
+	if (new Set(pending.map((approval) => approval.turnId)).size !== 1) return;
+	const expired = pending.some((approval) => input.now - Date.parse(approval.at) >= CONFIRMATION_TTL_MS);
+	if (!input.addressed && !expired) return;
+	const turnId = pending[0].turnId;
+	const result = await input.cancel({ turnId });
+	if (result.status === "no_active_turn") return;
+	return {
+		status: "cancellation_requested",
+		reason: expired ? "expired" : "addressed",
+		turnId,
+		startedAt: pending[0].at,
+		actions: pending.map((approval) => approval.action),
+		cancellation: result.status,
+		executionRequested: false
+	};
+}
+export { heldApprovals, releaseHeldApproval };

package/dist/extension/lib/telegram/inbound-request.d.ts

@@ -37,7 +37,7 @@ export declare class InboundRequest {
     stopTyping: (() => void) | undefined;
     lifecycle: ReturnType<typeof import("./lifecycle.js").attachmentLifecycle> | undefined;
     lifecycleKey: string | undefined;
-    /** An admitted task must be redelivered if processing did not reach durable queue admission. */
+    /** A routed task must be redelivered if recovery or intake did not reach durable admission. */
     retryReference: string | undefined;
     lifecycleContext: string | undefined;
     monitor: ((session: Awaited<ReturnType<ChannelSource<unknown>["send"]>>, marker: string) => void) | undefined;

package/dist/extension/lib/telegram/inbound.d.ts

@@ -39,6 +39,8 @@ import type { PdfTextExtractor } from "./pdf-text.js";
  */
 export interface InboundDependencies {
     readonly policy: TelegramPolicy;
+    /** Recover old held sessions only when the workspace has chosen non-blocking confirmations. */
+    readonly recoverHeldApprovals?: boolean;
     readonly lifecycle?: (principal: import("eve/context").SessionAuthContext, memberId: string, message: TelegramMessage) => ReturnType<typeof attachmentLifecycle>;
     readonly admission: () => AdmissionSettings;
     readonly sessions: () => SessionSettings;

package/dist/extension/lib/telegram/inbound.mjs

@@ -22,6 +22,7 @@ import { recordGateDecision, recordInboundContent, recordRouteDecision } from ".
 import { chatContext } from "./chats.mjs";
 import { admitMessage, localizedText } from "../admission.mjs";
 import { attachmentsContext, inboundAttachments, stageFiles } from "./files.mjs";
+import { heldApprovals, releaseHeldApproval } from "./held-approvals.mjs";
 import { voiceOf, voiceText } from "./voice.mjs";
 const UNKNOWN_PRIVATE = "🔗";
 const UNKNOWN_IN_GROUP = "🔒";
@@ -367,7 +368,8 @@ async function handleInboundMessage(input) {
 	if (input.request !== void 0 && sent.attachments.length > 0 && dependencies.lifecycle !== void 0 && await admitTurn(true)) {
 		const principal = telegramPrincipal({
 			message: sent,
-			member
+			member,
+			conversationLanguage: conversationLanguage([sent.text || sent.caption, ...dependencies.observed.recent(chat).map((message) => message.text).reverse()])
 		});
 		input.request.lifecycle = dependencies.lifecycle(principal, member.id, sent);
 		input.request.stopTyping = startTypingHeartbeat(context.telegram);
@@ -721,6 +723,38 @@ async function handleInboundMessage(input) {
 		recordGateDecision("message_already_handled");
 		return null;
 	}
+	if (dependencies.recoverHeldApprovals === true && operations !== void 0 && dependencies.history !== void 0) {
+		let recoverySessionId;
+		try {
+			const session = await operations.resolveSession(address);
+			if (session !== void 0) {
+				recoverySessionId = session.id;
+				const previous = session.id === owner?.id ? questionHistory : await dependencies.history(session.id);
+				const recovery = heldApprovals(previous).length === 0 ? void 0 : await releaseHeldApproval({
+					events: await dependencies.history(session.id),
+					addressed: addressed !== void 0,
+					now: Date.now(),
+					cancel: (options) => {
+						if (session.cancel === void 0) throw new Error("The parked session does not support turn cancellation.");
+						return session.cancel(options);
+					}
+				});
+				if (recovery !== void 0) {
+					recordGateDecision("held_approval_cancellation_requested", "reply");
+					notes.push(`<approval_recovery>${JSON.stringify(recovery)}</approval_recovery>`);
+				}
+			}
+		} catch (error) {
+			if (input.request !== void 0) {
+				input.request.retryReference = reportTelegramError("held_approval_release_failed", error, {
+					sessionId: recoverySessionId,
+					messageId: sent.messageId
+				});
+				await input.request.finishClaim?.(false);
+			}
+			throw error;
+		}
+	}
 	if (voice !== void 0 && input.request !== void 0) input.request.text = text;
 	else if (voice !== void 0) notes.push(text);
 	if (answering && pending !== void 0 && input.request !== void 0) {

package/dist/extension/lib/telegram/lifecycle.d.ts

@@ -6,6 +6,8 @@ import type { RuntimeToken } from "../runtime-token.js";
 export interface AttachmentLifecycle {
     readonly entity: string;
     readonly action: string;
+    /** Opt into provider timestamps and completion replies in lifecycle data. Omit for the legacy data contract. */
+    readonly contextVersion?: 2;
 }
 export interface LifecycleResult {
     readonly key?: string;
@@ -35,6 +37,7 @@ export declare function attachmentLifecycle(options: {
         readonly from?: {
             readonly id: string;
         };
+        readonly raw?: Record<string, unknown>;
     };
     readonly environment?: Environment;
     readonly token?: RuntimeToken;

package/dist/extension/lib/telegram/lifecycle.mjs

@@ -4,7 +4,7 @@ import { createRequire as __eveCreateRequire } from "node:module";
 const __filename = __eveFileURLToPath(import.meta.url);
 __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
-import { t as agentBuild } from "../../../_chunks/build-metadata-BYl-5kFi.mjs";
+import { t as agentBuild } from "../../../_chunks/build-metadata-CR18wzcH.mjs";
 import { object } from "../confirmation-description.mjs";
 import { n as currentInboundRequest, p as reportTelegramError } from "../../../_chunks/inbound-request-B98tr4Pd.mjs";
 import { needsConfirmation } from "../confirmations.mjs";
@@ -32,7 +32,10 @@ function attachmentLifecycle(options) {
 				sender: options.message.from.id,
 				locale: String(options.principal.attributes.conversationLanguage ?? options.principal.attributes.locale ?? "en")
 			},
-			data
+			data: {
+				...data,
+				...options.configuration.contextVersion === 2 && typeof options.message.raw?.date === "number" && Number.isSafeInteger(options.message.raw.date) && options.message.raw.date > 0 ? { source_at: options.message.raw.date * 1e3 } : {}
+			}
 		};
 		if (needsConfirmation(await tools.labels(options.memberId, action, input))) throw new Error("An attachment lifecycle hook must be a permitted routine action.");
 		const raw = await tools.rpc(options.memberId, "tools/call", {

package/dist/extension/lib/telegram/observed.d.ts

@@ -62,7 +62,7 @@ export interface AgentMessage extends ObservedMessage {
 }
 /** Presentation only; no tool inputs, credential values or member identifiers. */
 export interface PendingConfirmation {
-    readonly state?: "pending" | "approved" | "cancelled" | "expired" | "completed" | "failed";
+    readonly state?: "pending" | "approved" | "cancelled" | "interrupted" | "expired" | "completed" | "failed";
     readonly action: string;
     readonly requestedBy: string | null;
     readonly at: string;

package/dist/extension/lib/telegram/sessions.d.ts

@@ -1,4 +1,5 @@
 import type { TelegramMessage } from "eve/channels/telegram";
+import type { CancelTurnResult } from "eve/channels";
 import type { SessionSettings } from "../../config.js";
 /**
  * Session policy for the Telegram channel (`agent-design.md`, section 4, and docs/agent.md,
@@ -56,6 +57,9 @@ export declare function historyOf(events: ReadonlyArray<RecordedEvent>): Session
 export interface SessionOperations {
     readonly resolveSession: (address: string) => Promise<{
         readonly id: string;
+        readonly cancel?: (options: {
+            readonly turnId: string;
+        }) => Promise<CancelTurnResult>;
     } | undefined>;
     readonly from: (address: string) => {
         compact(): Promise<unknown>;

package/dist/extension/lib/telegram/silent.mjs

@@ -24,11 +24,20 @@ function replyDelivery(observed, scope = () => "telegram") {
 	return async (event, channel, context) => {
 		if (completionKind(event.message, event.finishReason) !== "reply") return;
 		const message = customerMessage(event.message, confirmationLocale(context.session?.auth.current ?? null, currentLocale()));
+		const principal = context.session?.auth.current;
+		const replyTo = principal?.attributes.replyToMessageId;
+		const replyParameters = typeof replyTo === "string" && /^[1-9]\d*$/u.test(replyTo) ? { reply_parameters: {
+			message_id: Number(replyTo),
+			allow_sending_without_reply: true
+		} } : {};
 		const deliveredIds = await inTelegramSendQueue(scope(), channel.telegram.chatId, async () => {
 			const messageIds = [];
 			try {
 				for (const part of splitTelegramText(message)) {
-					const result = await channel.telegram.post(part);
+					const result = await channel.telegram.post({
+						...part,
+						...replyParameters
+					});
 					if (!/^[1-9]\d*$/u.test(result.id)) throw new Error("Telegram did not acknowledge the reply with a message id.");
 					messageIds.push(Number(result.id));
 				}
@@ -40,7 +49,6 @@ function replyDelivery(observed, scope = () => "telegram") {
 		});
 		const text = message.text;
 		if (observed === void 0 || channel.telegram.chatType === "private") return;
-		const principal = context.session.auth.current;
 		const sender = principal?.authenticator === "segmentstream-telegram" ? principal.subject : void 0;
 		const username = principal?.attributes.username;
 		const name = principal?.attributes.memberName;

package/dist/extension/tools/ontology.d.ts

@@ -1,4 +1,27 @@
 declare const _default: import("eve").DynamicSentinel<{
-    [k: string]: import("eve/tools").ToolDefinition<Record<string, unknown>, Record<string, unknown>>;
+    ontology_discover: import("eve/tools").ToolDefinition<Record<string, unknown>, Record<string, unknown>> & {
+        execute(input: Record<string, unknown>, ctx: import("eve/tools").ToolContext): Promise<Record<string, unknown>>;
+    };
+    ontology_describe: import("eve/tools").ToolDefinition<Record<string, unknown>, Record<string, unknown>> & {
+        execute(input: Record<string, unknown>, ctx: import("eve/tools").ToolContext): Promise<Record<string, unknown>>;
+    };
+    ontology_inspect: import("eve/tools").ToolDefinition<Record<string, unknown>, {
+        next_after?: string | undefined;
+        tools: {
+            name: string;
+            description: string;
+        }[];
+    }> & {
+        execute(input: Record<string, unknown>, ctx: import("eve/tools").ToolContext): Promise<{
+            next_after?: string | undefined;
+            tools: {
+                name: string;
+                description: string;
+            }[];
+        }>;
+    };
+    ontology_call: import("eve/tools").ToolDefinition<Record<string, unknown>, Record<string, unknown>> & {
+        execute(input: Record<string, unknown>, ctx: import("eve/tools").ToolContext): Promise<Record<string, unknown>>;
+    };
 } | null>;
 export default _default;

package/dist/extension/tools/ontology.mjs

@@ -6,25 +6,125 @@ __eveDirname(__filename);
 __eveCreateRequire(import.meta.url);
 import { memberIdOf } from "../lib/telegram/principal.mjs";
 import segmentstream from "../extension.mjs";
-import { ontologyTools } from "../lib/ontology-tools.mjs";
 import { executeDeferredTool } from "../lib/deferred-confirmations.mjs";
+import { ontologyInspect, ontologyMetadata } from "../lib/ontology-gateway.mjs";
 import { defineDynamic, defineTool } from "eve/tools";
 var ontology_default = defineDynamic({ events: { "turn.started": async (_event, context) => {
 	const memberId = memberIdOf(context.session.auth.current);
 	if (!segmentstream.config.ontology.connection || segmentstream.config.confirmations.mode !== "deferred" || memberId === void 0) return null;
-	return Object.fromEntries((await ontologyTools().list(memberId)).map((tool) => {
-		const action = String(tool.name);
-		const schema = tool.inputSchema;
-		const properties = Object.fromEntries(Object.entries(schema.properties ?? {}).filter(([key]) => key !== "_segmentstream"));
-		return [`ontology__${action}`, defineTool({
-			deferred: true,
-			description: String(tool.description ?? tool.title ?? action),
+	return {
+		ontology_discover: defineTool({
+			description: "Search the permitted ontology's entities, actions and measures by words. Inspect returned refs with ontology_describe before calling ontology_call.",
 			inputSchema: {
-				...schema,
-				properties
+				type: "object",
+				properties: {
+					query: {
+						type: "string",
+						minLength: 1,
+						maxLength: 512
+					},
+					kind: {
+						type: "string",
+						enum: [
+							"entity",
+							"action",
+							"measure"
+						]
+					},
+					entity: { type: "string" },
+					mode: {
+						type: "string",
+						enum: [
+							"auto",
+							"literal",
+							"fuzzy"
+						]
+					},
+					after: { type: "string" },
+					expected_hash: {
+						type: "string",
+						pattern: "^sha256:[a-f0-9]{64}$"
+					},
+					limit: {
+						type: "integer",
+						minimum: 1,
+						maximum: 50
+					}
+				},
+				required: ["query"],
+				additionalProperties: false
 			},
-			execute: (input, ctx) => executeDeferredTool(memberId, action, input, ctx)
-		})];
-	}));
+			execute: (input, ctx) => ontologyMetadata(memberId, "discover", input, ctx)
+		}),
+		ontology_describe: defineTool({
+			description: "Inspect an ontology entity:, action: or measure: ref, including its exact operation names and schemas. Omit ref for the entity index. Follow next_cursor with after.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					ref: {
+						type: "string",
+						minLength: 1,
+						maxLength: 256
+					},
+					after: { type: "string" },
+					expected_hash: {
+						type: "string",
+						pattern: "^sha256:[a-f0-9]{64}$"
+					},
+					limit: {
+						type: "integer",
+						minimum: 1,
+						maximum: 100
+					}
+				},
+				additionalProperties: false
+			},
+			execute: (input, ctx) => ontologyMetadata(memberId, "describe", input, ctx)
+		}),
+		ontology_inspect: defineTool({
+			description: "Find permission-filtered MCP operation names and complete input schemas, including entity find/get/history reads. Supply name for an exact definition, query for words, or omit both for a paged tool index. Use next_after as after. This reads metadata only.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					name: {
+						type: "string",
+						minLength: 1
+					},
+					query: {
+						type: "string",
+						minLength: 1,
+						maxLength: 512
+					},
+					after: { type: "string" },
+					limit: {
+						type: "integer",
+						minimum: 1,
+						maximum: 50
+					}
+				},
+				additionalProperties: false
+			},
+			execute: (input, ctx) => ontologyInspect(memberId, input, ctx)
+		}),
+		ontology_call: defineTool({
+			description: "Run a permitted ontology operation by the exact MCP tool name from its inspected definition, with arguments matching that schema. Reads and routine actions run immediately; consequential actions retain native deferred confirmation. An awaiting_confirmation result means the action has not run.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					name: {
+						type: "string",
+						minLength: 1
+					},
+					arguments: {
+						type: "object",
+						additionalProperties: true
+					}
+				},
+				required: ["name"],
+				additionalProperties: false
+			},
+			execute: (input, ctx) => executeDeferredTool(memberId, input.name, input.arguments ?? {}, ctx)
+		})
+	};
 } } });
 export { ontology_default as default };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@segmentstream/agent",
-  "version": "0.8.5",
+  "version": "0.8.7",
   "description": "Mount a SegmentStream workspace's agent on eve: the ontology as tools, acting as the member who writes, and Telegram through the workspace's connection.",
   "license": "Apache-2.0",
   "author": "SegmentStream",
@@ -62,7 +62,7 @@
   },
   "dependencies": {
     "@chat-adapter/telegram": "4.41.0",
-    "@segmentstream-cloud/ontology": "0.34.1",
+    "@segmentstream-cloud/ontology": "0.35.0",
     "@vercel/oidc": "^3.8.4",
     "ai": "^7.0.128",
     "csv-parse": "^7.0.3",