@xopcai/xopc 0.0.248 → 0.0.249

package/dist/src/gateway/hono/routes/user-model.js

@@ -0,0 +1,480 @@
+import { createCollaborationRule, getCollaborationRule, listCollaborationRules, setCollaborationRuleStatus } from "../../../storage/sqlite/collaboration-rule-repository.js";
+import { getKnowledgeItem, listKnowledgeItems, searchKnowledgeItems, setKnowledgeStatus } from "../../../knowledge-memory/repository.js";
+import "../../../knowledge-memory/index.js";
+import { createPriorityWindow, createUserGoal, listPriorityWindows, listUserGoals, setUserGoalStatus } from "../../../user-model/goals.js";
+import { getActiveAssertionForSlot, getAssertionSlot, getUserAssertion, listUserAssertions, reconcileAssertion, setAssertionStatus } from "../../../user-model/repository.js";
+import "../../../user-model/index.js";
+import { listMemoryMaintenanceRuns } from "../../../memory-maintenance/service.js";
+import "../../../memory-maintenance/index.js";
+import { getExecutionContextAudit, recordExecutionContextFeedback } from "../../../agent/context/audit.js";
+//#region src/gateway/hono/routes/user-model.ts
+function object(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+async function body(c) {
+	try {
+		return object(await c.req.json());
+	} catch {
+		return;
+	}
+}
+function scope(value) {
+	const input = object(value);
+	if (!input || ![
+		"global",
+		"agent",
+		"workspace",
+		"project",
+		"session"
+	].includes(String(input.type))) return void 0;
+	if (input.type === "global") return { type: "global" };
+	return typeof input.id === "string" && input.id.trim() ? {
+		type: input.type,
+		id: input.id.trim()
+	} : void 0;
+}
+function subject(value) {
+	const input = object(value);
+	if (!input || ![
+		"user",
+		"person",
+		"goal",
+		"project",
+		"topic"
+	].includes(String(input.type)) || typeof input.id !== "string" || !input.id.trim()) return void 0;
+	return {
+		type: input.type,
+		id: input.id.trim()
+	};
+}
+function errorMessage(error) {
+	return error instanceof Error ? error.message : String(error);
+}
+const ASSERTION_STATUSES = new Set([
+	"candidate",
+	"active",
+	"needs_review",
+	"conflicted",
+	"stale",
+	"archived",
+	"rejected"
+]);
+const GOAL_STATUSES = new Set([
+	"proposed",
+	"active",
+	"paused",
+	"achieved",
+	"abandoned"
+]);
+const KNOWLEDGE_STATUSES = new Set([
+	"candidate",
+	"active",
+	"needs_review",
+	"stale",
+	"archived",
+	"rejected"
+]);
+const RULE_CATEGORIES = new Set([
+	"communication",
+	"execution",
+	"boundary",
+	"routine",
+	"proactive"
+]);
+const RULE_STATUSES = new Set([
+	"active",
+	"disabled",
+	"archived"
+]);
+function profileAssertion(predicate) {
+	return getActiveAssertionForSlot({
+		subject: {
+			type: "user",
+			id: "self"
+		},
+		predicate,
+		scope: { type: "global" }
+	});
+}
+function profileValue(predicate) {
+	return profileAssertion(predicate)?.value;
+}
+function profileSnapshot() {
+	return {
+		callName: profileValue("identity.call_name"),
+		pronouns: profileValue("identity.pronouns"),
+		timezone: profileValue("preference.timezone"),
+		locale: profileValue("preference.locale"),
+		role: profileValue("identity.role")
+	};
+}
+const PROFILE_FIELDS = {
+	callName: {
+		predicate: "identity.call_name",
+		kind: "identity",
+		volatility: "stable",
+		importance: .95,
+		statement: (value) => `The user prefers to be called ${value}.`
+	},
+	role: {
+		predicate: "identity.role",
+		kind: "identity",
+		volatility: "slow",
+		importance: .9,
+		statement: (value) => `The user's role is ${value}.`
+	},
+	pronouns: {
+		predicate: "identity.pronouns",
+		kind: "identity",
+		volatility: "stable",
+		importance: .75,
+		statement: (value) => `The user's pronouns are ${value}.`
+	},
+	timezone: {
+		predicate: "preference.timezone",
+		kind: "preference",
+		volatility: "slow",
+		importance: .85,
+		statement: (value) => `The user's timezone is ${value}.`
+	},
+	locale: {
+		predicate: "preference.locale",
+		kind: "preference",
+		volatility: "slow",
+		importance: .85,
+		statement: (value) => `The user's language and locale are ${value}.`
+	}
+};
+function assertionView(assertion) {
+	const slot = getAssertionSlot(assertion.slotId);
+	if (!slot) throw new Error(`Assertion slot not found: ${assertion.slotId}`);
+	return {
+		...assertion,
+		predicate: slot.predicate,
+		subject: slot.subject,
+		scope: slot.scope
+	};
+}
+function registerUserModelRoutes(authenticated, deps) {
+	const write = deps.strictRateLimitMiddleware;
+	authenticated.get("/api/user-model", (c) => {
+		const assertions = listUserAssertions({
+			statuses: [
+				"active",
+				"candidate",
+				"needs_review",
+				"conflicted",
+				"stale"
+			],
+			limit: 1e3
+		}).map(assertionView);
+		const goals = listUserGoals();
+		const priorities = listPriorityWindows();
+		const knowledge = listKnowledgeItems({
+			recordClass: "memory",
+			limit: 1e3
+		});
+		return c.json({
+			assertions,
+			goals,
+			priorities,
+			rules: listCollaborationRules(),
+			knowledge,
+			maintenance: { lastRun: listMemoryMaintenanceRuns(1)[0] ?? null },
+			profile: profileSnapshot(),
+			counts: {
+				activeAssertions: assertions.filter((item) => item.status === "active").length,
+				reviewAssertions: assertions.filter((item) => item.status === "needs_review" || item.status === "conflicted").length,
+				activeGoals: goals.filter((item) => item.status === "active").length,
+				activePriorities: priorities.filter((item) => item.status === "active").length,
+				activeKnowledge: knowledge.filter((item) => item.status === "active").length
+			}
+		});
+	});
+	authenticated.patch("/api/user-model/profile", write, async (c) => {
+		const input = await body(c);
+		if (!input) return c.json({ error: "A profile patch is required" }, 400);
+		const entries = Object.entries(PROFILE_FIELDS).filter(([key]) => Object.hasOwn(input, key));
+		if (!entries.length || entries.some(([key]) => typeof input[key] !== "string")) return c.json({ error: "Profile fields must be strings" }, 400);
+		try {
+			const now = Date.now();
+			for (const [key, field] of entries) {
+				const value = input[key].trim();
+				const current = profileAssertion(field.predicate);
+				if (!value) {
+					if (current) setAssertionStatus(current.id, "archived", {
+						actor: "user",
+						reason: "Profile field cleared by user.",
+						now
+					});
+					continue;
+				}
+				reconcileAssertion({
+					subject: {
+						type: "user",
+						id: "self"
+					},
+					predicate: field.predicate,
+					cardinality: "single",
+					scope: { type: "global" },
+					kind: field.kind,
+					value,
+					normalizedValue: value.toLocaleLowerCase(),
+					statement: field.statement(value),
+					authority: "user_explicit",
+					confidence: 1,
+					declaredImportance: field.importance,
+					inferredImportance: field.importance,
+					consequence: "medium",
+					actionability: .9,
+					volatility: field.volatility,
+					sensitivity: "normal",
+					disclosurePolicy: "referenceable",
+					observedAt: now,
+					createdBy: "user",
+					...current ? { correctionOfAssertionId: current.id } : {}
+				});
+			}
+			return c.json({ profile: profileSnapshot() });
+		} catch (error) {
+			return c.json({ error: errorMessage(error) }, 400);
+		}
+	});
+	authenticated.get("/api/user-model/assertions", (c) => {
+		const requested = c.req.query("status")?.split(",").filter(Boolean);
+		if (requested?.some((status) => !ASSERTION_STATUSES.has(status))) return c.json({ error: "Invalid assertion status" }, 400);
+		return c.json({ assertions: listUserAssertions({
+			...requested ? { statuses: requested } : {},
+			limit: 1e3
+		}).map(assertionView) });
+	});
+	authenticated.get("/api/user-model/assertions/:id", (c) => {
+		const assertion = getUserAssertion(c.req.param("id"));
+		return assertion ? c.json({ assertion: assertionView(assertion) }) : c.json({ error: "Assertion not found" }, 404);
+	});
+	authenticated.post("/api/user-model/assertions", write, async (c) => {
+		const input = await body(c);
+		const assertionScope = scope(input?.scope);
+		if (!input || !assertionScope || typeof input.statement !== "string" || typeof input.predicate !== "string" || typeof input.value === "undefined") return c.json({ error: "statement, predicate, value, and a valid scope are required" }, 400);
+		try {
+			const now = Date.now();
+			const assertionSubject = input.subject === void 0 ? {
+				type: "user",
+				id: "self"
+			} : subject(input.subject);
+			if (!assertionSubject) return c.json({ error: "Invalid assertion subject" }, 400);
+			const candidate = {
+				subject: assertionSubject,
+				predicate: input.predicate,
+				cardinality: input.cardinality === "multiple" ? "multiple" : "single",
+				scope: assertionScope,
+				kind: input.kind ?? "derived_insight",
+				value: input.value,
+				normalizedValue: typeof input.normalizedValue === "string" ? input.normalizedValue : JSON.stringify(input.value).toLocaleLowerCase(),
+				statement: input.statement,
+				authority: "user_explicit",
+				confidence: 1,
+				...typeof input.declaredImportance === "number" ? { declaredImportance: input.declaredImportance } : {},
+				inferredImportance: typeof input.inferredImportance === "number" ? input.inferredImportance : .7,
+				consequence: input.consequence ?? "medium",
+				actionability: typeof input.actionability === "number" ? input.actionability : .7,
+				volatility: input.volatility ?? "stable",
+				sensitivity: input.sensitivity ?? "normal",
+				disclosurePolicy: input.disclosurePolicy ?? "referenceable",
+				...object(input.applicability) ? { applicability: object(input.applicability) } : {},
+				...typeof input.validFrom === "number" ? { validFrom: input.validFrom } : {},
+				...typeof input.validTo === "number" ? { validTo: input.validTo } : {},
+				observedAt: typeof input.observedAt === "number" ? input.observedAt : now,
+				...typeof input.reviewAt === "number" ? { reviewAt: input.reviewAt } : {},
+				createdBy: "user",
+				...typeof input.correctionOfAssertionId === "string" ? { correctionOfAssertionId: input.correctionOfAssertionId } : {}
+			};
+			return c.json(reconcileAssertion(candidate), 201);
+		} catch (error) {
+			return c.json({ error: errorMessage(error) }, 400);
+		}
+	});
+	authenticated.patch("/api/user-model/assertions/:id/status", write, async (c) => {
+		const input = await body(c);
+		const status = input?.status;
+		if (!ASSERTION_STATUSES.has(status)) return c.json({ error: "Invalid assertion status" }, 400);
+		try {
+			return c.json({ assertion: setAssertionStatus(c.req.param("id"), status, {
+				actor: "user",
+				reason: typeof input?.reason === "string" ? input.reason : "Status changed by user."
+			}) });
+		} catch (error) {
+			return c.json({ error: errorMessage(error) }, 404);
+		}
+	});
+	authenticated.patch("/api/user-model/assertions/:id", write, async (c) => {
+		const current = getUserAssertion(c.req.param("id"));
+		const input = await body(c);
+		const statement = typeof input?.statement === "string" ? input.statement.trim() : "";
+		const slot = current ? getAssertionSlot(current.slotId) : void 0;
+		if (!current || !slot) return c.json({ error: "Assertion not found" }, 404);
+		if (!statement) return c.json({ error: "statement is required" }, 400);
+		try {
+			return c.json(reconcileAssertion({
+				subject: slot.subject,
+				predicate: slot.predicate,
+				cardinality: slot.cardinality,
+				scope: slot.scope,
+				kind: current.kind,
+				value: input?.value ?? statement,
+				normalizedValue: typeof input?.normalizedValue === "string" ? input.normalizedValue : String(input?.value ?? statement).trim().toLocaleLowerCase(),
+				statement,
+				authority: "user_explicit",
+				confidence: 1,
+				...current.declaredImportance === void 0 ? {} : { declaredImportance: current.declaredImportance },
+				inferredImportance: current.inferredImportance,
+				consequence: current.consequence,
+				actionability: current.actionability,
+				volatility: current.volatility,
+				sensitivity: current.sensitivity,
+				disclosurePolicy: current.disclosurePolicy,
+				applicability: current.applicability,
+				...current.validFrom === void 0 ? {} : { validFrom: current.validFrom },
+				...current.validTo === void 0 ? {} : { validTo: current.validTo },
+				observedAt: Date.now(),
+				...current.reviewAt === void 0 ? {} : { reviewAt: current.reviewAt },
+				createdBy: "user",
+				correctionOfAssertionId: current.id
+			}));
+		} catch (error) {
+			return c.json({ error: errorMessage(error) }, 400);
+		}
+	});
+	authenticated.get("/api/user-model/goals", (c) => c.json({ goals: listUserGoals() }));
+	authenticated.post("/api/user-model/goals", write, async (c) => {
+		const input = await body(c);
+		const goalScope = scope(input?.scope);
+		if (!input || !goalScope || typeof input.title !== "string" || typeof input.desiredOutcome !== "string") return c.json({ error: "title, desiredOutcome, and a valid scope are required" }, 400);
+		try {
+			return c.json({ goal: createUserGoal({
+				title: input.title,
+				desiredOutcome: input.desiredOutcome,
+				scope: goalScope,
+				...typeof input.declaredImportance === "number" ? { declaredImportance: input.declaredImportance } : {},
+				...typeof input.targetAt === "number" ? { targetAt: input.targetAt } : {}
+			}) }, 201);
+		} catch (error) {
+			return c.json({ error: errorMessage(error) }, 400);
+		}
+	});
+	authenticated.patch("/api/user-model/goals/:id/status", write, async (c) => {
+		const status = (await body(c))?.status;
+		if (!GOAL_STATUSES.has(status)) return c.json({ error: "Invalid goal status" }, 400);
+		const goal = setUserGoalStatus(c.req.param("id"), status);
+		return goal ? c.json({ goal }) : c.json({ error: "Goal not found" }, 404);
+	});
+	authenticated.get("/api/user-model/rules", (c) => c.json({ rules: listCollaborationRules() }));
+	authenticated.post("/api/user-model/rules", write, async (c) => {
+		const input = await body(c);
+		const ruleScope = scope(input?.scope);
+		const category = input?.category;
+		if (!input || !ruleScope || !RULE_CATEGORIES.has(category) || typeof input.statement !== "string" || typeof input.priority !== "number") return c.json({ error: "category, statement, priority, and a valid scope are required" }, 400);
+		try {
+			return c.json({ rule: createCollaborationRule({
+				category,
+				statement: input.statement,
+				priority: input.priority,
+				scope: ruleScope,
+				conditions: object(input.conditions) ?? {}
+			}) }, 201);
+		} catch (error) {
+			return c.json({ error: errorMessage(error) }, 400);
+		}
+	});
+	authenticated.patch("/api/user-model/rules/:id/status", write, async (c) => {
+		const status = (await body(c))?.status;
+		if (!RULE_STATUSES.has(status)) return c.json({ error: "Invalid collaboration rule status" }, 400);
+		const rule = setCollaborationRuleStatus(c.req.param("id"), status);
+		return rule ? c.json({ rule }) : c.json({ error: "Collaboration rule not found" }, 404);
+	});
+	authenticated.get("/api/user-model/priorities", (c) => c.json({ priorities: listPriorityWindows() }));
+	authenticated.post("/api/user-model/priorities", write, async (c) => {
+		const input = await body(c);
+		const priorityScope = scope(input?.scope);
+		if (!input || !priorityScope || typeof input.targetId !== "string" || typeof input.validFrom !== "number" || typeof input.validTo !== "number" || typeof input.urgency !== "number") return c.json({ error: "targetId, urgency, validFrom, validTo, and a valid scope are required" }, 400);
+		try {
+			return c.json({ priority: createPriorityWindow({
+				targetType: input.targetType,
+				targetId: input.targetId,
+				rank: input.rank,
+				urgency: input.urgency,
+				scope: priorityScope,
+				validFrom: input.validFrom,
+				validTo: input.validTo,
+				...typeof input.reviewAt === "number" ? { reviewAt: input.reviewAt } : {},
+				...typeof input.declaredImportance === "number" ? { declaredImportance: input.declaredImportance } : {}
+			}) }, 201);
+		} catch (error) {
+			return c.json({ error: errorMessage(error) }, 400);
+		}
+	});
+	authenticated.get("/api/knowledge-memory", (c) => {
+		const query = c.req.query("q")?.trim();
+		if (!query) return c.json({ items: listKnowledgeItems({
+			recordClass: "memory",
+			limit: 500
+		}) });
+		return c.json({ items: searchKnowledgeItems({
+			query,
+			context: {
+				agentId: c.req.query("agentId") ?? "main",
+				workspaceId: c.req.query("workspaceId") ?? "",
+				sessionId: c.req.query("sessionId") ?? "",
+				...c.req.query("projectId") ? { projectId: c.req.query("projectId") } : {}
+			},
+			recordClass: "memory",
+			limit: 100
+		}) });
+	});
+	authenticated.get("/api/knowledge-memory/:id", (c) => {
+		const item = getKnowledgeItem(c.req.param("id"));
+		return item ? c.json({ item }) : c.json({ error: "Knowledge item not found" }, 404);
+	});
+	authenticated.patch("/api/knowledge-memory/:id/status", write, async (c) => {
+		const input = await body(c);
+		const status = String(input?.status ?? "");
+		if (!KNOWLEDGE_STATUSES.has(status)) return c.json({ error: "Invalid knowledge status" }, 400);
+		const item = setKnowledgeStatus(c.req.param("id"), status);
+		return item ? c.json({ item }) : c.json({ error: "Knowledge item not found" }, 404);
+	});
+	authenticated.get("/api/memory-maintenance/runs", (c) => c.json({ runs: listMemoryMaintenanceRuns(Math.max(1, Math.min(100, Number(c.req.query("limit") ?? 20)))) }));
+	authenticated.get("/api/turns/:turnId/execution-context", (c) => {
+		const audit = getExecutionContextAudit(c.req.param("turnId"));
+		if (!audit) return c.json({ error: "Execution context not found" }, 404);
+		const goals = new Map(listUserGoals().map((item) => [item.id, item]));
+		const priorities = new Map(listPriorityWindows().map((item) => [item.id, item]));
+		const resolvedItems = audit.items.flatMap((item) => {
+			const value = item.objectType === "assertion" ? getUserAssertion(item.objectId) : item.objectType === "knowledge" ? getKnowledgeItem(item.objectId) : item.objectType === "rule" ? getCollaborationRule(item.objectId) : item.objectType === "goal" ? goals.get(item.objectId) : priorities.get(item.objectId);
+			if (!value) return [];
+			const content = "statement" in value ? value.statement : "content" in value ? value.content : "desiredOutcome" in value ? `${value.title}: ${value.desiredOutcome}` : `${value.targetType}: ${value.targetId}`;
+			const origin = item.objectType === "assertion" && "authority" in value ? value.authority === "user_explicit" ? "told_by_user" : value.authority === "system_inferred" ? "inferred" : "observed" : item.objectType === "knowledge" && "originClass" in value && value.originClass === "untrusted" ? "connected_source" : "observed";
+			return [{
+				...item,
+				content,
+				origin,
+				sourceLabel: item.objectType
+			}];
+		});
+		return c.json({
+			audit,
+			resolvedItems
+		});
+	});
+	authenticated.post("/api/turns/:turnId/execution-context/feedback", write, async (c) => {
+		const input = await body(c);
+		const rating = input?.rating;
+		if (rating !== "helpful" && rating !== "irrelevant") return c.json({ error: "Invalid feedback rating" }, 400);
+		return recordExecutionContextFeedback({
+			turnId: c.req.param("turnId"),
+			rating,
+			...typeof input?.reason === "string" ? { reason: input.reason } : {}
+		}) ? c.json({ ok: true }) : c.json({ error: "Execution context not found" }, 404);
+	});
+}
+//#endregion
+export { registerUserModelRoutes };

package/dist/src/gateway/memory-maintenance-automation-reconciler.d.ts

@@ -0,0 +1,11 @@
+import type { AutomationService } from '../automations/index.js';
+import type { Config } from '../config/schema.js';
+export interface MemoryMaintenanceAutomationReconcileResult {
+    created: number;
+    updated: number;
+    disabled: number;
+}
+export declare function reconcileMemoryMaintenanceAutomations(input: {
+    config: Config;
+    automationService: AutomationService;
+}): Promise<MemoryMaintenanceAutomationReconcileResult>;

package/dist/src/gateway/memory-maintenance-automation-reconciler.js

@@ -0,0 +1,72 @@
+import { init_agent_scope, normalizeAgentId, resolveAgentWorkspaceDir, resolveDefaultAgentId } from "../agent/agent-scope.js";
+import { maintenanceInstruction, resolveMemoryMaintenanceSchedules } from "../memory-maintenance/schedule.js";
+import "../memory-maintenance/index.js";
+//#region src/gateway/memory-maintenance-automation-reconciler.ts
+init_agent_scope();
+const AUTOMATION_IDS = [
+	"system-memory-temporal-sweep",
+	"system-memory-daily-reconciliation",
+	"system-memory-weekly-knowledge"
+];
+async function reconcileMemoryMaintenanceAutomations(input) {
+	const result = {
+		created: 0,
+		updated: 0,
+		disabled: 0
+	};
+	const schedules = resolveMemoryMaintenanceSchedules(input.config);
+	const enabledIds = new Set(schedules.map((item) => item.automationId));
+	const agentId = normalizeAgentId(resolveDefaultAgentId(input.config));
+	const workingDirectory = resolveAgentWorkspaceDir(input.config, agentId);
+	for (const id of AUTOMATION_IDS) {
+		if (enabledIds.has(id)) continue;
+		if ((await input.automationService.get(id))?.enabled) {
+			await input.automationService.update(id, { enabled: false });
+			result.disabled += 1;
+		}
+	}
+	for (const schedule of schedules) {
+		const trigger = {
+			kind: "schedule",
+			schedule: {
+				kind: "cron",
+				expr: schedule.cron,
+				tz: schedule.timezone
+			}
+		};
+		const action = {
+			kind: "agent",
+			agentId,
+			instruction: maintenanceInstruction(schedule.jobType),
+			workingDirectory,
+			timeoutSeconds: 300
+		};
+		const next = {
+			name: schedule.name,
+			description: `Run deterministic ${schedule.jobType} without model inference.`,
+			enabled: true,
+			trigger,
+			action,
+			safety: { mode: "auto_apply" },
+			conversationMode: "continuous",
+			notificationPolicy: "none",
+			reliability: { disableAfterConsecutiveFailures: 3 }
+		};
+		const current = await input.automationService.get(schedule.automationId);
+		if (!current) {
+			await input.automationService.create({
+				id: schedule.automationId,
+				...next
+			});
+			result.created += 1;
+			continue;
+		}
+		if (current.name !== next.name || current.description !== next.description || !current.enabled || JSON.stringify(current.trigger) !== JSON.stringify(trigger) || JSON.stringify(current.action) !== JSON.stringify(action) || current.safety?.mode !== "auto_apply" || current.notificationPolicy !== "none") {
+			await input.automationService.update(schedule.automationId, next);
+			result.updated += 1;
+		}
+	}
+	return result;
+}
+//#endregion
+export { reconcileMemoryMaintenanceAutomations };

package/dist/src/gateway/service/agent-runner.d.ts

@@ -30,6 +30,7 @@ import type { UserTurnAttachment, UserTurnInput } from '../user-turn-input.js';
 import type { AgentSourceContext, TurnContextRef } from '../../agent/source-context/types.js';
 import { SessionInputCoordinator, type ReplaceLatestTurnInput, type SubmitSessionInput } from './session-input-coordinator.js';
 export interface GatewayAgentRunnerOptions {
+    validateConnectionResume?: (input: import('../../storage/sqlite/session-input-repository.js').SessionInput) => Promise<boolean>;
     bus: MessageBus;
     sessionIndex: SessionIndex;
     /** Resolved lazily — the runner is constructed before AgentService exists. */
@@ -52,7 +53,10 @@ export declare class GatewayAgentRunner {
     /** Maps webchat session key → active `runId` for `clarify` tool routing. */
     private readonly activeWebchatRunBySession;
     private readonly externalStreamBySession;
+    private readonly externalClarificationTimeouts;
+    private readonly externalClarificationResponses;
     readonly inputs: SessionInputCoordinator;
+    private readonly unsubscribeConnectionWait;
     constructor(opts: GatewayAgentRunnerOptions);
     /** True when a webchat agent run is currently in-flight for `sessionKey`. */
     hasActiveRun(sessionKey: string): boolean;
@@ -64,12 +68,16 @@ export declare class GatewayAgentRunner {
     getClarifyBridge(): ClarifyBridge;
     /** Called from `GatewayService.stop()` so the bridge gets cleaned up. */
     disposeClarifyBridge(): void;
-    registerExternalWebchatRun(sessionKey: string, runId: string, publish: (event: ClarifyStreamEvent) => void): void;
+    registerExternalWebchatRun(sessionKey: string, runId: string, publish: (event: ClarifyStreamEvent) => void, options?: {
+        clarificationTimeoutMs?: number | null;
+        beforeClarificationResponse?: () => boolean;
+    }): void;
     unregisterExternalWebchatRun(sessionKey: string, runId: string): void;
     cancelClarificationForRun(runId: string): void;
     runAgent(message: string, channel: string, chatId: string, origin: TurnOrigin, attachments?: UserTurnAttachment[], thinking?: string, runOptions?: {
         signal?: AbortSignal;
         runId?: string;
+        taskRunId?: string;
         sourceContexts?: AgentSourceContext[];
         presentation?: 'voice';
     }): AsyncGenerator<{

package/dist/src/gateway/service/agent-runner.js

@@ -1,5 +1,6 @@
 import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
+import { onConnectionWaitChanged } from "../../storage/sqlite/connection-wait-repository.js";
 import { listActiveSessionInputRuns } from "../../storage/sqlite/session-input-repository.js";
 import "../../storage/sqlite/index.js";
 import { ClarifyBridge } from "../clarify-bridge.js";
@@ -21,14 +22,30 @@ var GatewayAgentRunner = class {
 	/** Maps webchat session key → active `runId` for `clarify` tool routing. */
 	activeWebchatRunBySession = /* @__PURE__ */ new Map();
 	externalStreamBySession = /* @__PURE__ */ new Map();
+	externalClarificationTimeouts = /* @__PURE__ */ new Map();
+	externalClarificationResponses = /* @__PURE__ */ new Map();
 	inputs;
+	unsubscribeConnectionWait;
 	constructor(opts) {
 		this.opts = opts;
+		this.unsubscribeConnectionWait = onConnectionWaitChanged((sessionKey) => {
+			const revision = this.inputs.snapshot(sessionKey).revision;
+			opts.emit("session.connection-wait.changed", {
+				sessionKey,
+				revision
+			});
+			opts.publishRealtime("sessions", "session.connection-wait.changed", {
+				sessionKey,
+				revision
+			});
+		});
 		this.inputs = new SessionInputCoordinator({
+			beforeExecute: opts.validateConnectionResume,
 			sessionExists: async (sessionKey) => Boolean(await opts.sessionIndex.getSessionMetadata(sessionKey)),
 			execute: async (input) => {
 				const generator = this.runAgent(input.content, "webchat", input.sessionKey, input.origin, input.attachments, input.thinking, {
 					runId: input.runId,
+					taskRunId: input.taskRunId,
 					sourceContexts: input.sourceContexts
 				});
 				let result;
@@ -93,15 +110,20 @@ var GatewayAgentRunner = class {
 	/** Called from `GatewayService.stop()` so the bridge gets cleaned up. */
 	disposeClarifyBridge() {
 		this.clarifyBridge.dispose();
+		this.unsubscribeConnectionWait();
 	}
-	registerExternalWebchatRun(sessionKey, runId, publish) {
+	registerExternalWebchatRun(sessionKey, runId, publish, options) {
 		this.activeWebchatRunBySession.set(sessionKey, runId);
 		this.externalStreamBySession.set(sessionKey, publish);
+		if (options?.clarificationTimeoutMs !== void 0) this.externalClarificationTimeouts.set(sessionKey, options.clarificationTimeoutMs);
+		if (options?.beforeClarificationResponse) this.externalClarificationResponses.set(sessionKey, options.beforeClarificationResponse);
 	}
 	unregisterExternalWebchatRun(sessionKey, runId) {
 		if (this.activeWebchatRunBySession.get(sessionKey) === runId) {
 			this.activeWebchatRunBySession.delete(sessionKey);
 			this.externalStreamBySession.delete(sessionKey);
+			this.externalClarificationTimeouts.delete(sessionKey);
+			this.externalClarificationResponses.delete(sessionKey);
 		}
 	}
 	cancelClarificationForRun(runId) {
@@ -238,6 +260,8 @@ var GatewayAgentRunner = class {
 		} : void 0;
 		if (!runId && !deliver) return Promise.reject(/* @__PURE__ */ new Error("Clarify is not available for this session (use webchat, Telegram, or CLI)"));
 		return this.clarifyBridge.startRequest({
+			timeoutMs: this.externalClarificationTimeouts.get(sessionKey),
+			beforeResponse: this.externalClarificationResponses.get(sessionKey),
 			sessionKey,
 			runId,
 			publishStream,

package/dist/src/gateway/service/config-coordinator.d.ts

@@ -43,8 +43,8 @@ export interface GatewayConfigCoordinatorOptions {
     getExtensionLoader: () => ExtensionLoader | null;
     /** Re-evaluate browser-extension server attachment after agent defaults change. */
     reconcileBrowserExtensionServer: () => Promise<void>;
-    /** Sync the built-in consolidation automation after userContext.dreaming changes. */
-    reconcileDreamingAutomations: () => Promise<void>;
+    /** Sync deterministic user-model maintenance automations after config changes. */
+    reconcileMemoryMaintenanceAutomations: () => Promise<void>;
     /** Latest channel status snapshot for the `channels.status` event. */
     getChannelsStatus: () => unknown;
     /** Realtime emit used for `config.reload` and `channels.status`. */