@xopcai/xopc 0.0.146 → 0.0.147

package/dist/src/gateway/hono/routes/you.js

@@ -1,28 +1,30 @@
 import { runSqliteWriteTransaction } from "../../../storage/sqlite/transaction.js";
 import { deleteMemoryRecord, getMemoryRecord, listMemoryRecords, upsertMemoryRecord } from "../../../storage/sqlite/memory-records-repository.js";
 import { listKnowledgeSourceItems, listKnowledgeSyncRuns } from "../../../storage/sqlite/knowledge-repository.js";
+import { getConnectorConnection, listConnectorConnections } from "../../../storage/sqlite/connector-repository.js";
 import { USER_TRUST_LEVELS, isUserTrustLevel } from "../../../user-context/trust-policy.js";
 import { getUserTrustPolicy, setUserTrustPolicy } from "../../../storage/sqlite/user-trust-repository.js";
+import { decideMemoryReferenceConsent, listMemoryReferenceConsents, revokeMemoryReferenceConsent } from "../../../storage/sqlite/memory-reference-consent-repository.js";
 import { getUserProfilePromptState, setUserProfilePromptState } from "../../../storage/sqlite/user-profile-setup-repository.js";
 import "../../../storage/sqlite/index.js";
-import { MemoryPolicySchema, init_schema } from "../../../agent-manifest/schema.js";
+import { UserContextConfigSchema, init_config } from "../../../user-context/config.js";
 import { init_agent_scope, resolveDefaultAgentId } from "../../../agent/agent-scope.js";
-import { resolveEffectiveAgentManifestForAgent } from "../../../config/agent-profile.js";
 import { GoalService } from "../../../goals/goal-service.js";
 import { draftGoalContract } from "../../../goals/goal-contract-draft.js";
 import "../../../goals/index.js";
+import { revokeComposioConnection } from "../../../connectors/composio.js";
 import { listConnectorCatalog } from "../../../connectors/catalog.js";
 import { nextMemoryReviewAt, resolveMemoryStability } from "../../../agent/memory/lifecycle.js";
 import { listConnectorInstances } from "../../../connectors/instances.js";
 import { uninstallConnector } from "../../../connectors/install.js";
-import { prepareUpdateAgent, readUserProfileFile, writeUserProfileFile } from "../../agents-admin.js";
-import { isUserContextRecord, projectPersonalContextSources, projectUserContextRecord, recordsDerivedFromPersonalContextSource } from "../../../user-context/projection.js";
+import { readUserProfileFile, writeUserProfileFile } from "../../agents-admin.js";
+import { isUserContextMemoryKind, isUserContextRecord, projectPersonalContextSources, projectUserContextRecord, recordsDerivedFromPersonalContextSource } from "../../../user-context/projection.js";
 import { prepareUserContextImport } from "../../../user-context/import.js";
 import { buildUserProfileSetup, parseUserProfileMarkdown, patchUserProfileMarkdown } from "../../../user-context/profile.js";
 import { buildGoalSourceRecommendations } from "../../../user-context/source-recommendations.js";
 //#region src/gateway/hono/routes/you.ts
 init_agent_scope();
-init_schema();
+init_config();
 const VISIBLE_STATUSES = new Set([
 	"active",
 	"candidate",
@@ -42,6 +44,8 @@ const PLAYBOOK_IDS = [
 	"execution",
 	"routines"
 ];
+const PLAYBOOK_DISABLED_TAG = "playbook:disabled";
+const PLAYBOOK_ORDER_PREFIX = "playbook:order:";
 const PROFILE_FIELD_LIMITS = {
 	callName: 80,
 	pronouns: 80,
@@ -57,13 +61,28 @@ const ALL_MEMORY_STATUSES = [
 	"archived",
 	"rejected"
 ];
-function listAllAgentMemoryRecords(agentId, statuses) {
+const MEMORY_SENSITIVITIES = new Set([
+	"normal",
+	"personal",
+	"secret",
+	"regulated"
+]);
+const MEMORY_DURABILITIES = new Set([
+	"ephemeral",
+	"durable",
+	"recurring"
+]);
+const MEMORY_DISCLOSURE_POLICIES = new Set([
+	"silent",
+	"referenceable",
+	"ask_before_reference"
+]);
+function listAllUserContextRecords(statuses) {
 	return statuses.flatMap((status) => {
 		const records = [];
 		let offset = 0;
 		while (true) {
 			const page = listMemoryRecords({
-				agentId,
 				status,
 				limit: 500,
 				offset
@@ -75,6 +94,38 @@ function listAllAgentMemoryRecords(agentId, statuses) {
 		return records;
 	});
 }
+function projectReferenceConsent(consent, record) {
+	return {
+		id: consent.id,
+		recordId: consent.recordId,
+		sessionKey: consent.sessionKey,
+		purpose: consent.purpose,
+		statement: record.content,
+		sourceName: record.source.provider ?? "local",
+		status: consent.status,
+		grantScope: consent.grantScope,
+		expiresAt: consent.expiresAt,
+		createdAt: consent.createdAt,
+		updatedAt: consent.updatedAt
+	};
+}
+function buildConflictGroups(records) {
+	const groups = /* @__PURE__ */ new Map();
+	for (const record of records) {
+		if (!record.conflictGroupId) continue;
+		const group = groups.get(record.conflictGroupId) ?? [];
+		group.push(record);
+		groups.set(record.conflictGroupId, group);
+	}
+	return [...groups.entries()].filter(([, group]) => group.length > 1 && group.some((record) => VISIBLE_STATUSES.has(record.status))).map(([id, group]) => ({
+		id,
+		records: group.sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt)).map((record) => ({
+			...projectUserContextRecord(record),
+			storedStatus: record.status
+		})),
+		unresolved: group.filter((record) => VISIBLE_STATUSES.has(record.status)).length > 1
+	}));
+}
 async function readProfileBundle(config) {
 	const result = await readUserProfileFile();
 	const profileContent = result.ok ? result.data.content : "";
@@ -107,20 +158,33 @@ function playbookForRecord(record) {
 	if (record.kind === "task_lesson" || record.kind === "derived_insight") return "execution";
 	if (record.kind === "routine") return "routines";
 }
+function playbookRuleOrder(record) {
+	const tag = record.tags?.find((value) => value.startsWith(PLAYBOOK_ORDER_PREFIX));
+	const parsed = tag ? Number.parseInt(tag.slice(15), 10) : NaN;
+	return Number.isFinite(parsed) ? parsed : 1e3;
+}
+function patchPlaybookRuleTags(record, patch) {
+	let tags = (record.tags ?? []).filter((tag) => !tag.startsWith(PLAYBOOK_ORDER_PREFIX));
+	if (patch.enabled === true) tags = tags.filter((tag) => tag !== PLAYBOOK_DISABLED_TAG);
+	if (patch.enabled === false) tags.push(PLAYBOOK_DISABLED_TAG);
+	if (patch.order !== void 0) tags.push(`${PLAYBOOK_ORDER_PREFIX}${patch.order}`);
+	return [...new Set(tags)];
+}
 function buildPersonalPlaybooks(records) {
-	return PLAYBOOK_IDS.flatMap((id) => {
-		const rules = records.filter((record) => playbookForRecord(record) === id);
-		if (rules.length === 0) return [];
-		return [{
+	return PLAYBOOK_IDS.map((id) => {
+		const rules = records.filter((record) => playbookForRecord(record) === id).sort((left, right) => playbookRuleOrder(left) - playbookRuleOrder(right) || left.updatedAt.localeCompare(right.updatedAt));
+		return {
 			id,
-			enabled: rules.some((record) => record.status === "active"),
+			enabled: rules.some((record) => !record.tags?.includes(PLAYBOOK_DISABLED_TAG)),
 			rules: rules.map((record) => ({
 				id: record.id,
 				statement: record.content,
-				origin: record.explicitness
+				origin: record.explicitness,
+				enabled: !record.tags?.includes(PLAYBOOK_DISABLED_TAG),
+				order: playbookRuleOrder(record)
 			})),
 			updatedAt: rules.map((record) => record.updatedAt).sort().at(-1)
-		}];
+		};
 	});
 }
 function buildInsightSuggestions(records) {
@@ -137,12 +201,19 @@ function buildInsightSuggestions(records) {
 		sourceName: record.source.provider ?? "local"
 	}));
 }
+function buildRoutineAutomationDraftHref(record) {
+	return `/automations?${new URLSearchParams({
+		draft: record.content,
+		autogenerate: "1",
+		insight: record.id
+	}).toString()}`;
+}
 function selectedAgentId(config) {
 	return resolveDefaultAgentId(config);
 }
-function editableRecord(recordId, config) {
+function editableRecord(recordId) {
 	const record = getMemoryRecord(recordId);
-	if (!record || record.scope.agentId !== selectedAgentId(config) || !VISIBLE_STATUSES.has(record.status) || !isUserContextRecord(record)) return null;
+	if (!record || !VISIBLE_STATUSES.has(record.status) || !isUserContextRecord(record)) return null;
 	return record;
 }
 function preserveRecord(record, patch) {
@@ -150,7 +221,7 @@ function preserveRecord(record, patch) {
 		id: record.id,
 		providerId: record.source.provider ?? "local",
 		kind: record.kind,
-		agentId: record.scope.agentId,
+		sourceAgentId: record.provenance.sourceAgentId,
 		workspaceId: record.scope.workspaceId,
 		sessionKey: record.scope.sessionKey,
 		projectId: record.scope.projectId,
@@ -180,20 +251,17 @@ function registerYouRoutes(authenticated, deps) {
 		const config = deps.service.currentConfig;
 		const agentId = selectedAgentId(config);
 		const profileBundle = await readProfileBundle(config);
-		const allUserContextRecords = listAllAgentMemoryRecords(agentId, ALL_MEMORY_STATUSES).filter(isUserContextRecord);
+		const allUserContextRecords = listAllUserContextRecords(ALL_MEMORY_STATUSES).filter(isUserContextRecord);
 		const records = allUserContextRecords.filter((record) => VISIBLE_STATUSES.has(record.status));
-		const pausedPlaybookRecords = listMemoryRecords({
-			agentId,
-			status: "archived",
-			limit: 200
-		}).filter(isUserContextRecord).filter((record) => record.tags?.some((tag) => tag.startsWith("playbook:paused:")));
-		const manifest = resolveEffectiveAgentManifestForAgent(config, agentId);
+		const recordById = new Map(allUserContextRecords.map((record) => [record.id, record]));
+		const consents = listMemoryReferenceConsents();
 		const trustPolicy = getUserTrustPolicy();
 		const sourceDefinitions = listConnectorCatalog();
 		const sourceInstances = listConnectorInstances(config);
 		const sources = projectPersonalContextSources(sourceDefinitions, sourceInstances, allUserContextRecords, {
 			sourceItems: listKnowledgeSourceItems({ limit: 500 }),
-			syncRuns: listKnowledgeSyncRuns({ limit: 500 })
+			syncRuns: listKnowledgeSyncRuns({ limit: 500 }),
+			connections: listConnectorConnections({ principalId: "local-owner" })
 		});
 		const activeGoals = new GoalService().list({
 			agentId,
@@ -206,23 +274,29 @@ function registerYouRoutes(authenticated, deps) {
 			limit: 20
 		});
 		return c.json({
-			agentId,
 			scope: {
 				profile: "global",
-				memory: "agent",
-				trust: "global",
-				agentId
+				memory: "global",
+				trust: "global"
 			},
 			...profileBundle,
 			understanding: records.map(projectUserContextRecord),
+			consentRequests: consents.filter((consent) => consent.status === "pending").flatMap((consent) => {
+				const record = recordById.get(consent.recordId);
+				return record ? [projectReferenceConsent(consent, record)] : [];
+			}),
+			referenceGrants: consents.filter((consent) => consent.status === "granted" && (!consent.expiresAt || Date.parse(consent.expiresAt) > Date.now())).flatMap((consent) => {
+				const record = recordById.get(consent.recordId);
+				return record ? [projectReferenceConsent(consent, record)] : [];
+			}),
+			conflictGroups: buildConflictGroups(allUserContextRecords),
 			insights: buildInsightSuggestions(records),
-			playbooks: buildPersonalPlaybooks([...records.filter((record) => record.status === "active"), ...pausedPlaybookRecords]),
+			playbooks: buildPersonalPlaybooks(records.filter((record) => record.status === "active")),
 			sources,
 			sourceRecommendations: buildGoalSourceRecommendations(sourceDefinitions.filter((definition) => definition.capabilities.includes("context") || definition.capabilities.includes("memory_source")), new Set(sourceInstances.map((instance) => instance.connectorId)), activeGoals),
 			controls: {
-				mode: manifest.memory.mode,
-				sensitiveWritePolicy: manifest.memory.privacy?.sensitiveWritePolicy ?? "confirm",
-				crossAgentSharing: manifest.memory.privacy?.crossAgentSharing ?? "deny"
+				mode: config.userContext.memory.mode,
+				sensitiveWritePolicy: config.userContext.privacy.sensitiveWritePolicy
 			},
 			trust: {
 				defaultActionLevel: trustPolicy.defaultActionLevel,
@@ -236,39 +310,37 @@ function registerYouRoutes(authenticated, deps) {
 	});
 	authenticated.get("/api/you/export", async (c) => {
 		const config = deps.service.currentConfig;
-		const agentId = selectedAgentId(config);
 		const profileBundle = await readProfileBundle(config);
-		const understanding = listAllAgentMemoryRecords(agentId, ALL_MEMORY_STATUSES).filter(isUserContextRecord).map((record) => ({
+		const understanding = listAllUserContextRecords(ALL_MEMORY_STATUSES).filter(isUserContextRecord).map((record) => ({
 			statement: record.content,
 			kind: record.kind,
 			status: record.status,
 			sensitivity: record.sensitivity ?? "normal",
 			durability: record.durability,
-			canReference: record.disclosurePolicy !== "silent",
+			disclosurePolicy: record.disclosurePolicy,
 			sourceName: record.source.provider ?? "local",
 			updatedAt: record.updatedAt
 		}));
 		return c.json({
-			version: 1,
+			version: 2,
 			exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
-			agentId,
 			profile: profileBundle.profile,
 			understanding
 		});
 	});
 	authenticated.post("/api/you/import", deps.strictRateLimitMiddleware, async (c) => {
 		const body = await c.req.json().catch(() => null);
-		if (!body || typeof body !== "object" || Array.isArray(body) || body.version !== 1 || !Array.isArray(body.understanding)) return c.json({ error: "Invalid About You export" }, 400);
+		if (!body || typeof body !== "object" || Array.isArray(body) || body.version !== 2 || !Array.isArray(body.understanding)) return c.json({ error: "Invalid About You export" }, 400);
 		if (body.understanding.length > 500) return c.json({ error: "Import is limited to 500 understandings" }, 400);
 		const config = deps.service.currentConfig;
 		const agentId = selectedAgentId(config);
-		const existingStatements = listAllAgentMemoryRecords(agentId, ALL_MEMORY_STATUSES).filter(isUserContextRecord).map((record) => record.content);
+		const existingStatements = listAllUserContextRecords(ALL_MEMORY_STATUSES).filter(isUserContextRecord).map((record) => record.content);
 		const { imports, skippedCount } = prepareUserContextImport(body.understanding, existingStatements);
 		runSqliteWriteTransaction(() => {
 			for (const item of imports) upsertMemoryRecord({
 				providerId: "local",
 				kind: item.kind,
-				agentId,
+				sourceAgentId: agentId,
 				content: item.statement,
 				source: {
 					provider: "local",
@@ -281,7 +353,7 @@ function registerYouRoutes(authenticated, deps) {
 				explicitness: "explicit",
 				durability: item.durability,
 				importance: .7,
-				disclosurePolicy: item.canReference ? "referenceable" : "silent"
+				disclosurePolicy: item.disclosurePolicy
 			});
 		});
 		return c.json({
@@ -290,6 +362,114 @@ function registerYouRoutes(authenticated, deps) {
 			skippedCount
 		});
 	});
+	authenticated.post("/api/you/understanding", deps.strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const content = typeof body.content === "string" ? body.content.trim() : "";
+		const kind = isUserContextMemoryKind(body.kind) ? body.kind : void 0;
+		if (!content || content.length > 5e3) return c.json({ error: "Understanding content must be 1-5000 characters" }, 400);
+		if (!kind) return c.json({ error: "A valid user understanding kind is required" }, 400);
+		const duplicate = listAllUserContextRecords(ALL_MEMORY_STATUSES).filter(isUserContextRecord).find((record) => record.content.trim().toLocaleLowerCase() === content.toLocaleLowerCase());
+		if (duplicate) return c.json({
+			error: "This understanding already exists",
+			understanding: projectUserContextRecord(duplicate)
+		}, 409);
+		const sensitivity = MEMORY_SENSITIVITIES.has(body.sensitivity) ? body.sensitivity : "normal";
+		const durability = MEMORY_DURABILITIES.has(body.durability) ? body.durability : "durable";
+		const disclosurePolicy = MEMORY_DISCLOSURE_POLICIES.has(body.disclosurePolicy) ? body.disclosurePolicy : "referenceable";
+		const config = deps.service.currentConfig;
+		const created = upsertMemoryRecord({
+			providerId: "local",
+			kind,
+			sourceAgentId: selectedAgentId(config),
+			content,
+			source: {
+				provider: "local",
+				path: "you://manual"
+			},
+			confidence: 1,
+			tags: ["user-understanding", "explicit-user-memory"],
+			status: "active",
+			sensitivity,
+			explicitness: "explicit",
+			durability,
+			importance: .8,
+			disclosurePolicy,
+			reviewAfter: nextMemoryReviewAt({
+				durability,
+				explicitness: "explicit"
+			})
+		});
+		return c.json({ understanding: projectUserContextRecord(created) }, 201);
+	});
+	authenticated.get("/api/you/understanding/:id/history", (c) => {
+		const all = listAllUserContextRecords(ALL_MEMORY_STATUSES).filter(isUserContextRecord);
+		const target = all.find((record) => record.id === c.req.param("id"));
+		if (!target) return c.json({ error: "Understanding not found" }, 404);
+		const relatedIds = new Set([target.id]);
+		let changed = true;
+		while (changed) {
+			changed = false;
+			for (const record of all) if (record.supersedesRecordId && relatedIds.has(record.supersedesRecordId) || record.supersedesRecordId && relatedIds.has(record.id)) {
+				if (!relatedIds.has(record.id)) {
+					relatedIds.add(record.id);
+					changed = true;
+				}
+				if (record.supersedesRecordId && !relatedIds.has(record.supersedesRecordId)) {
+					relatedIds.add(record.supersedesRecordId);
+					changed = true;
+				}
+			}
+		}
+		const history = all.filter((record) => relatedIds.has(record.id)).sort((left, right) => Date.parse(right.updatedAt) - Date.parse(left.updatedAt)).map((record) => ({
+			...projectUserContextRecord(record),
+			storedStatus: record.status
+		}));
+		return c.json({ history });
+	});
+	authenticated.post("/api/you/understanding/batch", deps.strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const ids = Array.isArray(body.ids) ? [...new Set(body.ids.filter((id) => typeof id === "string" && id.trim().length > 0).slice(0, 100))] : [];
+		const action = body.action === "confirm" || body.action === "reject" || body.action === "forget" ? body.action : void 0;
+		if (!ids.length || !action) return c.json({ error: "ids and a valid action are required" }, 400);
+		let updatedCount = 0;
+		runSqliteWriteTransaction(() => {
+			for (const id of ids) {
+				const record = editableRecord(id);
+				if (!record) continue;
+				if (action === "forget") deleteMemoryRecord(id);
+				else preserveRecord(record, {
+					status: action === "confirm" ? "active" : "rejected",
+					...action === "confirm" ? { reviewAfter: nextMemoryReviewAt(record) } : {}
+				});
+				updatedCount += 1;
+			}
+		});
+		return c.json({
+			ok: true,
+			updatedCount
+		});
+	});
+	authenticated.post("/api/you/conflicts/:id/resolve", deps.strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const winnerId = typeof body.winnerId === "string" ? body.winnerId : "";
+		const group = listAllUserContextRecords(ALL_MEMORY_STATUSES).filter(isUserContextRecord).filter((record) => record.conflictGroupId === c.req.param("id"));
+		const winner = group.find((record) => record.id === winnerId && VISIBLE_STATUSES.has(record.status));
+		if (group.length < 2 || !winner) return c.json({ error: "Conflict group or winner not found" }, 404);
+		const now = (/* @__PURE__ */ new Date()).toISOString();
+		runSqliteWriteTransaction(() => {
+			for (const record of group) preserveRecord(record, record.id === winnerId ? {
+				status: "active",
+				reviewAfter: nextMemoryReviewAt(record)
+			} : {
+				status: "archived",
+				validTo: record.validTo ?? now
+			});
+		});
+		return c.json({
+			ok: true,
+			understanding: projectUserContextRecord(getMemoryRecord(winnerId))
+		});
+	});
 	authenticated.patch("/api/you/profile", deps.strictRateLimitMiddleware, async (c) => {
 		const config = deps.service.currentConfig;
 		const parsed = parseProfilePatch(await c.req.json().catch(() => null));
@@ -338,38 +518,87 @@ function registerYouRoutes(authenticated, deps) {
 		if (!PLAYBOOK_IDS.includes(id)) return c.json({ error: "Playbook not found" }, 404);
 		const enabled = (await c.req.json().catch(() => ({}))).enabled;
 		if (typeof enabled !== "boolean") return c.json({ error: "enabled must be a boolean" }, 400);
-		const config = deps.service.currentConfig;
-		const agentId = selectedAgentId(config);
-		const pauseTag = `playbook:paused:${id}`;
 		const active = listMemoryRecords({
-			agentId,
 			status: "active",
 			limit: 500
 		}).filter(isUserContextRecord).filter((record) => playbookForRecord(record) === id);
-		const paused = listMemoryRecords({
-			agentId,
-			status: "archived",
-			limit: 500
-		}).filter(isUserContextRecord).filter((record) => record.tags?.includes(pauseTag));
-		const targets = enabled ? paused : active;
 		runSqliteWriteTransaction(() => {
-			for (const record of targets) preserveRecord(record, {
-				status: enabled ? "active" : "archived",
-				tags: enabled ? (record.tags ?? []).filter((tag) => tag !== pauseTag) : [...new Set([...record.tags ?? [], pauseTag])]
-			});
+			for (const record of active) preserveRecord(record, { tags: patchPlaybookRuleTags(record, { enabled }) });
 		});
-		const current = active.concat(paused);
+		const current = active.map((record) => ({
+			...record,
+			tags: patchPlaybookRuleTags(record, { enabled })
+		}));
 		return c.json({
 			ok: true,
-			playbook: buildPersonalPlaybooks(current.map((record) => ({
-				...record,
-				status: enabled ? "active" : "archived"
-			})))[0]
+			playbook: buildPersonalPlaybooks(current).find((playbook) => playbook.id === id)
+		});
+	});
+	authenticated.post("/api/you/playbooks/:id/rules", deps.strictRateLimitMiddleware, async (c) => {
+		const id = c.req.param("id");
+		if (!PLAYBOOK_IDS.includes(id)) return c.json({ error: "Playbook not found" }, 404);
+		const body = await c.req.json().catch(() => ({}));
+		const statement = typeof body.statement === "string" ? body.statement.trim() : "";
+		if (!statement || statement.length > 5e3) return c.json({ error: "Rule statement is required" }, 400);
+		const record = upsertMemoryRecord({
+			providerId: "local",
+			kind: id === "communication" ? "preference" : id === "execution" ? "task_lesson" : "routine",
+			sourceAgentId: selectedAgentId(deps.service.currentConfig),
+			content: statement,
+			source: {
+				provider: "local",
+				path: "you://playbook"
+			},
+			confidence: 1,
+			tags: [
+				"user-understanding",
+				"playbook:explicit",
+				`${PLAYBOOK_ORDER_PREFIX}${Number.isInteger(body.order) ? body.order : 1e3}`
+			],
+			status: "active",
+			sensitivity: "normal",
+			explicitness: "explicit",
+			durability: id === "routines" ? "recurring" : "durable",
+			importance: .85,
+			disclosurePolicy: "referenceable"
 		});
+		return c.json({
+			ok: true,
+			rule: buildPersonalPlaybooks([record]).find((playbook) => playbook.id === id)?.rules[0]
+		}, 201);
+	});
+	authenticated.patch("/api/you/playbooks/:id/rules/:recordId", deps.strictRateLimitMiddleware, async (c) => {
+		const id = c.req.param("id");
+		const record = editableRecord(c.req.param("recordId"));
+		if (!PLAYBOOK_IDS.includes(id) || !record || playbookForRecord(record) !== id) return c.json({ error: "Playbook rule not found" }, 404);
+		const body = await c.req.json().catch(() => ({}));
+		const content = body.statement === void 0 ? record.content : typeof body.statement === "string" ? body.statement.trim() : "";
+		if (!content || content.length > 5e3) return c.json({ error: "Rule statement is required" }, 400);
+		if (body.enabled !== void 0 && typeof body.enabled !== "boolean") return c.json({ error: "enabled must be boolean" }, 400);
+		if (body.order !== void 0 && (!Number.isInteger(body.order) || body.order < 0 || body.order > 1e4)) return c.json({ error: "order must be an integer between 0 and 10000" }, 400);
+		const updated = preserveRecord(record, {
+			content,
+			tags: patchPlaybookRuleTags(record, {
+				enabled: body.enabled,
+				order: body.order
+			}),
+			explicitness: body.statement === void 0 ? record.explicitness : "explicit"
+		});
+		return c.json({
+			ok: true,
+			rule: buildPersonalPlaybooks([updated]).find((playbook) => playbook.id === id)?.rules[0]
+		});
+	});
+	authenticated.delete("/api/you/playbooks/:id/rules/:recordId", deps.strictRateLimitMiddleware, (c) => {
+		const id = c.req.param("id");
+		const record = editableRecord(c.req.param("recordId"));
+		if (!PLAYBOOK_IDS.includes(id) || !record || playbookForRecord(record) !== id) return c.json({ error: "Playbook rule not found" }, 404);
+		deleteMemoryRecord(record.id);
+		return c.json({ ok: true });
 	});
 	authenticated.patch("/api/you/insights/:id", deps.strictRateLimitMiddleware, async (c) => {
 		const config = deps.service.currentConfig;
-		const existing = editableRecord(c.req.param("id"), config);
+		const existing = editableRecord(c.req.param("id"));
 		if (!existing || existing.status !== "active" || !ACTIONABLE_INSIGHT_KINDS.has(existing.kind)) return c.json({ error: "Insight not found" }, 404);
 		const body = await c.req.json().catch(() => ({}));
 		const action = typeof body.action === "string" ? body.action : "";
@@ -380,7 +609,19 @@ function registerYouRoutes(authenticated, deps) {
 				status: "dismissed"
 			});
 		}
-		if (action !== "apply") return c.json({ error: "Action must be apply or dismiss" }, 400);
+		if (action === "complete" && existing.kind === "routine") {
+			preserveRecord(existing, { tags: [...new Set([...existing.tags ?? [], INSIGHT_ACCEPTED_TAG])] });
+			return c.json({
+				ok: true,
+				status: "saved"
+			});
+		}
+		if (action !== "apply") return c.json({ error: "Action must be apply, complete, or dismiss" }, 400);
+		if (existing.kind === "routine") return c.json({
+			ok: true,
+			status: "drafting",
+			href: buildRoutineAutomationDraftHref(existing)
+		});
 		const title = existing.content.trim().split(/\r?\n/)[0].slice(0, 72);
 		const uiLocale = body.uiLocale === "zh" ? "zh" : "en";
 		const contractDraft = await draftGoalContract({
@@ -422,51 +663,79 @@ function registerYouRoutes(authenticated, deps) {
 	});
 	authenticated.patch("/api/you/controls", deps.strictRateLimitMiddleware, async (c) => {
 		const config = deps.service.currentConfig;
-		const agentId = selectedAgentId(config);
-		const manifest = resolveEffectiveAgentManifestForAgent(config, agentId);
 		const body = await c.req.json().catch(() => ({}));
-		const parsed = MemoryPolicySchema.safeParse({
-			...manifest.memory,
-			mode: body.mode,
+		const parsed = UserContextConfigSchema.safeParse({
+			...config.userContext,
+			memory: {
+				...config.userContext.memory,
+				mode: body.mode
+			},
 			privacy: {
-				...manifest.memory.privacy,
-				sensitiveWritePolicy: body.sensitiveWritePolicy,
-				crossAgentSharing: body.crossAgentSharing
+				...config.userContext.privacy,
+				sensitiveWritePolicy: body.sensitiveWritePolicy
 			}
 		});
 		if (!parsed.success) return c.json({ error: parsed.error.issues[0]?.message ?? "Invalid personal context controls" }, 400);
-		const prep = prepareUpdateAgent(config, agentId, { memory: parsed.data });
-		if (prep.ok === false) return c.json({ error: prep.error }, prep.status ?? 400);
-		const saved = await deps.service.saveConfig(prep.data.nextConfig);
+		const saved = await deps.service.saveConfig({
+			...config,
+			userContext: parsed.data
+		});
 		if (!saved.saved) return c.json({ error: saved.error ?? "save failed" }, 500);
-		const updated = resolveEffectiveAgentManifestForAgent(deps.service.currentConfig, agentId);
+		const updated = deps.service.currentConfig.userContext;
 		return c.json({ controls: {
 			mode: updated.memory.mode,
-			sensitiveWritePolicy: updated.memory.privacy?.sensitiveWritePolicy ?? "confirm",
-			crossAgentSharing: updated.memory.privacy?.crossAgentSharing ?? "deny"
+			sensitiveWritePolicy: updated.privacy.sensitiveWritePolicy
 		} });
 	});
+	authenticated.patch("/api/you/consents/:id", deps.strictRateLimitMiddleware, async (c) => {
+		const body = await c.req.json().catch(() => ({}));
+		const decision = typeof body.decision === "string" ? body.decision : "";
+		if (![
+			"once",
+			"session",
+			"always",
+			"deny"
+		].includes(decision)) return c.json({ error: "Decision must be once, session, always, or deny" }, 400);
+		const consent = decideMemoryReferenceConsent(c.req.param("id"), decision);
+		if (!consent) return c.json({ error: "Pending consent not found" }, 404);
+		return c.json({
+			ok: true,
+			consent
+		});
+	});
+	authenticated.delete("/api/you/consents/:id", deps.strictRateLimitMiddleware, (c) => {
+		const consent = revokeMemoryReferenceConsent(c.req.param("id"));
+		if (!consent) return c.json({ error: "Active reference grant not found" }, 404);
+		return c.json({
+			ok: true,
+			consent
+		});
+	});
 	authenticated.delete("/api/you/sources/:instanceId", deps.strictRateLimitMiddleware, async (c) => {
 		const config = deps.service.currentConfig;
 		const instanceId = c.req.param("instanceId");
 		const installedInstances = listConnectorInstances(config);
+		const connection = getConnectorConnection(instanceId);
 		const instance = installedInstances.find((item) => item.instanceId === instanceId);
-		const definition = instance ? listConnectorCatalog().find((item) => item.id === instance.connectorId) : void 0;
-		if (!instance || !definition || !definition.capabilities.some((capability) => capability === "context" || capability === "memory_source")) return c.json({ error: "Personal context source not found" }, 404);
+		const connectorId = connection?.connectorId ?? instance?.connectorId;
+		const definition = connectorId ? listConnectorCatalog().find((item) => item.id === connectorId) : void 0;
+		if (!instance && !connection || !definition || !definition.capabilities.some((capability) => capability === "context" || capability === "memory_source")) return c.json({ error: "Personal context source not found" }, 404);
 		const body = await c.req.json().catch(() => ({}));
 		if (typeof body.deleteDerivedUnderstanding !== "boolean") return c.json({ error: "deleteDerivedUnderstanding must be a boolean" }, 400);
 		try {
-			const sourceInstances = installedInstances.filter((item) => item.connectorId === instance.connectorId);
-			for (const sourceInstance of sourceInstances) uninstallConnector(config, sourceInstance.instanceId);
-			const saved = await deps.service.saveConfig(config);
-			if (!saved.saved) return c.json({ error: saved.error ?? "save failed" }, 500);
+			if (connection) await revokeComposioConnection(connection.id);
+			else if (instance) {
+				uninstallConnector(config, instance.instanceId);
+				const saved = await deps.service.saveConfig(config);
+				if (!saved.saved) return c.json({ error: saved.error ?? "save failed" }, 500);
+			}
 		} catch (error) {
 			return c.json({ error: error instanceof Error ? error.message : String(error) }, 400);
 		}
 		let deletedUnderstandingCount = 0;
 		if (body.deleteDerivedUnderstanding) {
-			const agentId = selectedAgentId(config);
-			const targets = recordsDerivedFromPersonalContextSource(listAllAgentMemoryRecords(agentId, ALL_MEMORY_STATUSES), agentId, instance.connectorId);
+			const sourceInstanceId = connection ? `composio:${connection.connectorId}:${connection.id}` : instanceId;
+			const targets = recordsDerivedFromPersonalContextSource(listAllUserContextRecords(ALL_MEMORY_STATUSES), sourceInstanceId);
 			runSqliteWriteTransaction(() => {
 				for (const record of targets) deleteMemoryRecord(record.id);
 			});
@@ -478,8 +747,7 @@ function registerYouRoutes(authenticated, deps) {
 		});
 	});
 	authenticated.patch("/api/you/understanding/:id", deps.strictRateLimitMiddleware, async (c) => {
-		const config = deps.service.currentConfig;
-		const existing = editableRecord(c.req.param("id"), config);
+		const existing = editableRecord(c.req.param("id"));
 		if (!existing) return c.json({ error: "Understanding not found" }, 404);
 		const body = await c.req.json().catch(() => ({}));
 		const action = typeof body.action === "string" ? body.action : "";
@@ -494,7 +762,7 @@ function registerYouRoutes(authenticated, deps) {
 			const replacement = upsertMemoryRecord({
 				providerId: "local",
 				kind: existing.kind,
-				agentId: existing.scope.agentId,
+				sourceAgentId: existing.provenance.sourceAgentId,
 				workspaceId: existing.scope.workspaceId,
 				sessionKey: existing.scope.sessionKey,
 				projectId: existing.scope.projectId,
@@ -529,14 +797,13 @@ function registerYouRoutes(authenticated, deps) {
 		return c.json({ error: "Action must be confirm, reject, or update" }, 400);
 	});
 	authenticated.delete("/api/you/understanding/:id", deps.strictRateLimitMiddleware, (c) => {
-		const config = deps.service.currentConfig;
-		const existing = editableRecord(c.req.param("id"), config);
+		const existing = editableRecord(c.req.param("id"));
 		if (!existing) return c.json({ error: "Understanding not found" }, 404);
 		deleteMemoryRecord(existing.id);
 		return c.json({ ok: true });
 	});
 }
 //#endregion
-export { buildInsightSuggestions, buildPersonalPlaybooks, registerYouRoutes };
+export { buildInsightSuggestions, buildPersonalPlaybooks, buildRoutineAutomationDraftHref, registerYouRoutes };
 
 //# sourceMappingURL=you.js.map