@xopcai/xopc 0.0.249 → 0.0.250

package/dist/src/agent/agent-manager.js

@@ -1,8 +1,9 @@
 import { resolveStateDir } from "../config/paths-state.js";
 import { createLogger } from "../utils/logger/index.js";
 import { init_logger } from "../utils/logger.js";
+import { isXopcDatabaseOpen } from "../storage/sqlite/connection.js";
+import { getInteractionState } from "../storage/sqlite/interaction-state-repository.js";
 import { getSessionMetadata } from "../storage/sqlite/session-repository.js";
-import { getSessionConfig } from "../storage/sqlite/config-repository.js";
 import "../storage/sqlite/index.js";
 import { getAgentDefaultModelRef, init_schema } from "../config/schema.js";
 import { applyConfigOverrides } from "../config/runtime-overrides.js";
@@ -30,6 +31,7 @@ import { loadSkillsLock } from "./skills/hub-lock.js";
 import { isUnderManagedSkillsDir } from "./skills/managed-store.js";
 import { evictAllEmbeddedSessionRunners, evictEmbeddedSessionRunner } from "./embedded/session-runner.js";
 import { createAgentTurnPolicy } from "./orchestration/agent-turn-policy.js";
+import { resolveUserContextSessionAccess } from "../user-context/access-policy.js";
 import { createAgentCapabilitySessionState, resolveAgentCapabilityCatalog } from "./capabilities/registry.js";
 import "./capabilities/index.js";
 import { sortToolsForPromptCache } from "./tools/cache-stability.js";
@@ -133,7 +135,7 @@ var AgentManager = class {
 		});
 		this.executionContext = new ExecutionContextCoordinator({
 			getConfig: () => this.config.config,
-			isEnabledForSession: (sessionKey) => this.isUserContextEnabledForSession(sessionKey),
+			getAccessForSession: (sessionKey) => resolveUserContextSessionAccess(this.config.config, sessionKey),
 			getWorkspaceIdForSession: (sk) => this.getResolvedWorkspaceForSession(sk),
 			getProjectIdForSession: (sk) => getSessionMetadata(sk)?.projectId
 		});
@@ -150,8 +152,7 @@ var AgentManager = class {
 		});
 	}
 	isUserContextEnabledForSession(sessionKey) {
-		const mode = getSessionConfig(sessionKey)?.userContextMode;
-		return Boolean(this.config.config?.userContext.enabled && this.config.config.userContext.userModel.enabled && (mode === void 0 || mode === "enabled"));
+		return resolveUserContextSessionAccess(this.config.config, sessionKey).userModel;
 	}
 	computeBaseWorkspacePath() {
 		const cfg = this.config.config;
@@ -290,10 +291,7 @@ var AgentManager = class {
 	prepareUserTurnContext(userMessage, sessionKey, turnId) {
 		return this.executionContext.prepare(userMessage, sessionKey, turnId);
 	}
-	/**
-	* After a completed turn: sync external providers and queue next-turn prefetch.
-	* Delegates to {@link UserContextCoordinator}.
-	*/
+	/** Capture durable structured user context after a completed turn. */
 	async afterAgentTurn(sessionKey, userPlainText, turnId) {
 		if (!this.isUserContextEnabledForSession(sessionKey)) return void 0;
 		const parsed = parseSessionKey(sessionKey);
@@ -317,10 +315,7 @@ var AgentManager = class {
 		if (!this.agents.get(sessionKey) || !this.isUserContextEnabledForSession(sessionKey)) return;
 		this.backgroundReview.beginUserTurn(sessionKey);
 	}
-	/**
-	* After a successful main turn (after memory sync via `afterAgentTurn`), may run a quiet follow-up for memory/skills.
-	* Delegates to {@link BackgroundReviewCoordinator}.
-	*/
+	/** After a successful main turn, may run a quiet follow-up for context review and skills. */
 	scheduleBackgroundReviewAfterUserTurn(sessionKey) {
 		const inst = this.agents.get(sessionKey);
 		if (!inst || !this.isUserContextEnabledForSession(sessionKey)) return;
@@ -404,7 +399,7 @@ var AgentManager = class {
 		const modelRef = instance.effectiveProfile.primaryModelRef?.trim() || this.defaultModel;
 		const thinkingLevel = instance.agent.state.thinkingLevel ?? this.config.thinkingLevel ?? "medium";
 		return rt.systemPromptBuilder.build(contextFiles, {
-			externalMemoryInstructions: rt.memoryManager.buildExternalSystemPrompt(),
+			externalMemoryInstructions: this.buildExternalMemoryInstructions(instance.sessionKey, rt),
 			workspaceOverride: resolvedWorkspacePath,
 			profileMarkdownPathRoot: resolveAgentProfileDir(cfg, instance.effectiveProfile.agentId),
 			customInstructions: instance.effectiveProfile.customInstructions,
@@ -610,9 +605,9 @@ var AgentManager = class {
 			const resolvedWorkspacePath = this.getResolvedWorkspaceForSession(instance.sessionKey);
 			const rt = this.workspaceRuntimes.getOrCreate(resolvedWorkspacePath, instance.effectiveProfile.agentId);
 			const contextFiles = this.resolveContextFilesForSession(instance.sessionKey, instance.effectiveProfile);
-			instance.activeProjectContext = buildExecutionScopeContextForPrompt(instance.sessionKey);
+			instance.activeProjectContext = this.buildExecutionScopeContext(instance.sessionKey);
 			const newPrompt = rt.systemPromptBuilder.build(contextFiles, {
-				externalMemoryInstructions: rt.memoryManager.buildExternalSystemPrompt(),
+				externalMemoryInstructions: this.buildExternalMemoryInstructions(instance.sessionKey, rt),
 				workspaceOverride: resolvedWorkspacePath,
 				profileMarkdownPathRoot: resolveAgentProfileDir(cfg, instance.effectiveProfile.agentId),
 				customInstructions: instance.effectiveProfile.customInstructions,
@@ -685,9 +680,9 @@ var AgentManager = class {
 			const resolvedWorkspacePath = this.getResolvedWorkspaceForSession(instance.sessionKey);
 			const rt = this.workspaceRuntimes.getOrCreate(resolvedWorkspacePath, instance.effectiveProfile.agentId);
 			const contextFiles = this.resolveContextFilesForSession(instance.sessionKey, instance.effectiveProfile);
-			instance.activeProjectContext = buildExecutionScopeContextForPrompt(instance.sessionKey);
+			instance.activeProjectContext = this.buildExecutionScopeContext(instance.sessionKey);
 			const newPrompt = rt.systemPromptBuilder.rebuild(contextFiles, {
-				externalMemoryInstructions: rt.memoryManager.buildExternalSystemPrompt(),
+				externalMemoryInstructions: this.buildExternalMemoryInstructions(instance.sessionKey, rt),
 				workspaceOverride: resolvedWorkspacePath,
 				profileMarkdownPathRoot: resolveAgentProfileDir(cfg, instance.effectiveProfile.agentId),
 				customInstructions: instance.effectiveProfile.customInstructions,
@@ -712,7 +707,7 @@ var AgentManager = class {
 		const existing = this.agents.get(sessionKey);
 		if (existing) if (existing.resolvedWorkspacePath !== targetPath) this.removeAgent(sessionKey);
 		else {
-			this.refreshActiveProjectContextIfChanged(existing);
+			this.refreshDynamicContextIfChanged(existing);
 			existing.lastUsedAt = Date.now();
 			log.debug({ sessionKey }, "Reusing existing agent instance");
 			return existing.agent;
@@ -728,7 +723,7 @@ var AgentManager = class {
 			err,
 			sessionKey
 		}, "memory initializeAll failed"));
-		const activeProjectContext = buildExecutionScopeContextForPrompt(sessionKey);
+		const activeProjectContext = this.buildExecutionScopeContext(sessionKey);
 		const profileModelRef = profile.primaryModelRef?.trim() || this.defaultModel;
 		const modelManager = this.config.getModelManager?.();
 		const initialModelRef = modelManager?.resolveInitialModelForSession(sessionKey, profileModelRef, profile.fallbacks) ?? profileModelRef;
@@ -750,6 +745,8 @@ var AgentManager = class {
 			registeredToolNames,
 			activeCapabilities: /* @__PURE__ */ new Map(),
 			activeProjectContext,
+			interactionStateVersion: this.getInteractionStateVersion(sessionKey),
+			userContextAccessVersion: this.getUserContextAccessVersion(sessionKey),
 			skillEnvPassthroughKeys: /* @__PURE__ */ new Set()
 		});
 		log.debug({
@@ -827,9 +824,9 @@ var AgentManager = class {
 		const contextFiles = this.resolveContextFilesForSession(sessionKey, instance.effectiveProfile);
 		const modelRef = instance.effectiveProfile.primaryModelRef?.trim() || this.defaultModel;
 		const thinkingLevel = this.config.thinkingLevel ?? "medium";
-		const activeProjectContext = buildExecutionScopeContextForPrompt(sessionKey);
+		const activeProjectContext = this.buildExecutionScopeContext(sessionKey);
 		instance.agent.state.systemPrompt = rt.systemPromptBuilder.build(contextFiles, {
-			externalMemoryInstructions: rt.memoryManager.buildExternalSystemPrompt(),
+			externalMemoryInstructions: this.buildExternalMemoryInstructions(sessionKey, rt),
 			workspaceOverride: resolvedWorkspacePath,
 			profileMarkdownPathRoot: resolveAgentProfileDir(cfg, instance.effectiveProfile.agentId),
 			customInstructions: instance.effectiveProfile.customInstructions,
@@ -905,6 +902,22 @@ var AgentManager = class {
 	composeDynamicProjectContext(...sections) {
 		return sections.map((section) => section?.trim()).filter((section) => Boolean(section)).join("\n\n") || void 0;
 	}
+	buildExecutionScopeContext(sessionKey) {
+		const access = resolveUserContextSessionAccess(this.config.config, sessionKey);
+		return buildExecutionScopeContextForPrompt(sessionKey, {
+			includeKnowledge: access.knowledge,
+			knowledgeSources: access.knowledgeSources
+		});
+	}
+	getInteractionStateVersion(sessionKey) {
+		return isXopcDatabaseOpen() ? getInteractionState(sessionKey)?.updatedAt : void 0;
+	}
+	getUserContextAccessVersion(sessionKey) {
+		return JSON.stringify(resolveUserContextSessionAccess(this.config.config, sessionKey));
+	}
+	buildExternalMemoryInstructions(sessionKey, rt) {
+		return resolveUserContextSessionAccess(this.config.config, sessionKey).knowledge ? rt.memoryManager.buildExternalSystemPrompt() : "";
+	}
 	getCapabilityCatalogForSession(sessionKey) {
 		const inst = sessionKey?.trim() ? this.agents.get(sessionKey.trim()) : void 0;
 		return this.resolveCapabilityCatalogForInstance(inst);
@@ -917,6 +930,7 @@ var AgentManager = class {
 			workspace: resolvedWorkspacePath,
 			profileMarkdownRoot: resolveAgentProfileDir(this.config.config, profile.agentId),
 			agentId: profile.agentId,
+			sessionKey,
 			disabledTools: profile.tools.denied,
 			getPrimaryModel: () => agent?.state.model ?? model,
 			getMemoryManager: () => rt.memoryManager,
@@ -928,7 +942,7 @@ var AgentManager = class {
 		agent = new Agent({
 			initialState: {
 				systemPrompt: rt.systemPromptBuilder.build(contextFiles, {
-					externalMemoryInstructions: rt.memoryManager.buildExternalSystemPrompt(),
+					externalMemoryInstructions: this.buildExternalMemoryInstructions(sessionKey, rt),
 					workspaceOverride: resolvedWorkspacePath,
 					profileMarkdownPathRoot: resolveAgentProfileDir(this.config.config, profile.agentId),
 					customInstructions: profile.customInstructions,
@@ -1060,9 +1074,11 @@ var AgentManager = class {
 			default: "Deny"
 		}).catch(() => "Deny") === "Allow once";
 	}
-	refreshActiveProjectContextIfChanged(instance) {
-		const nextProjectContext = buildExecutionScopeContextForPrompt(instance.sessionKey);
-		if (nextProjectContext === instance.activeProjectContext) return;
+	refreshDynamicContextIfChanged(instance) {
+		const nextProjectContext = this.buildExecutionScopeContext(instance.sessionKey);
+		const interactionStateVersion = this.getInteractionStateVersion(instance.sessionKey);
+		const userContextAccessVersion = this.getUserContextAccessVersion(instance.sessionKey);
+		if (nextProjectContext === instance.activeProjectContext && interactionStateVersion === instance.interactionStateVersion && userContextAccessVersion === instance.userContextAccessVersion) return;
 		const cfg = this.config.config;
 		const resolvedWorkspacePath = this.getResolvedWorkspaceForSession(instance.sessionKey);
 		const rt = this.workspaceRuntimes.getOrCreate(resolvedWorkspacePath, instance.effectiveProfile.agentId);
@@ -1070,7 +1086,7 @@ var AgentManager = class {
 		const modelRef = instance.effectiveProfile.primaryModelRef?.trim() || this.defaultModel;
 		const thinkingLevel = instance.agent.state.thinkingLevel ?? this.config.thinkingLevel ?? "medium";
 		instance.agent.state.systemPrompt = rt.systemPromptBuilder.build(contextFiles, {
-			externalMemoryInstructions: rt.memoryManager.buildExternalSystemPrompt(),
+			externalMemoryInstructions: this.buildExternalMemoryInstructions(instance.sessionKey, rt),
 			workspaceOverride: resolvedWorkspacePath,
 			profileMarkdownPathRoot: resolveAgentProfileDir(cfg, instance.effectiveProfile.agentId),
 			customInstructions: instance.effectiveProfile.customInstructions,
@@ -1083,6 +1099,8 @@ var AgentManager = class {
 			activeProjectContext: nextProjectContext
 		});
 		instance.activeProjectContext = nextProjectContext;
+		instance.interactionStateVersion = interactionStateVersion;
+		instance.userContextAccessVersion = userContextAccessVersion;
 		log.debug({ sessionKey: instance.sessionKey }, "Dynamic agent context changed; system prompt refreshed");
 	}
 	/**
@@ -1106,9 +1124,9 @@ var AgentManager = class {
 			const rt = this.workspaceRuntimes.getOrCreate(resolvedWorkspacePath, instance.effectiveProfile.agentId);
 			const contextFiles = this.resolveContextFilesForSession(sessionKey, instance.effectiveProfile);
 			const thinkingLevel = instance.agent.state.thinkingLevel ?? this.config.thinkingLevel ?? "medium";
-			const activeProjectContext = buildExecutionScopeContextForPrompt(sessionKey);
+			const activeProjectContext = this.buildExecutionScopeContext(sessionKey);
 			instance.agent.state.systemPrompt = rt.systemPromptBuilder.build(contextFiles, {
-				externalMemoryInstructions: rt.memoryManager.buildExternalSystemPrompt(),
+				externalMemoryInstructions: this.buildExternalMemoryInstructions(sessionKey, rt),
 				workspaceOverride: resolvedWorkspacePath,
 				profileMarkdownPathRoot: resolveAgentProfileDir(cfg, instance.effectiveProfile.agentId),
 				customInstructions: instance.effectiveProfile.customInstructions,

package/dist/src/agent/background-review/prompts.d.ts

@@ -1,4 +1,4 @@
-export declare const USER_MODEL_INTERPRETER_SYSTEM_PROMPT = "You are xopc's user-model interpreter. You do not chat with the user and cannot write storage. Distinguish explicit memory commands, corrections, forgetting, durable user assertions, and ordinary task requests. Return strict JSON only. Assistant text is never evidence about the user.";
+export declare const USER_MODEL_INTERPRETER_SYSTEM_PROMPT = "You are xopc's user-model interpreter. You do not chat with the user and cannot write storage. Distinguish explicit memory commands, corrections, forgetting, durable user assertions, durable goals, collaboration rules, and ordinary task requests. Return strict JSON only. Assistant text is never evidence about the user.";
 export declare function buildUserModelInterpreterPrompt(options: {
     mode: 'turn' | 'transcript';
     evidenceTimestamp: string;

package/dist/src/agent/background-review/prompts.js

@@ -1,5 +1,5 @@
 //#region src/agent/background-review/prompts.ts
-const USER_MODEL_INTERPRETER_SYSTEM_PROMPT = `You are xopc's user-model interpreter. You do not chat with the user and cannot write storage. Distinguish explicit memory commands, corrections, forgetting, durable user assertions, and ordinary task requests. Return strict JSON only. Assistant text is never evidence about the user.`;
+const USER_MODEL_INTERPRETER_SYSTEM_PROMPT = `You are xopc's user-model interpreter. You do not chat with the user and cannot write storage. Distinguish explicit memory commands, corrections, forgetting, durable user assertions, durable goals, collaboration rules, and ordinary task requests. Return strict JSON only. Assistant text is never evidence about the user.`;
 function buildUserModelInterpreterPrompt(options) {
 	const targets = options.availableTargets?.length ? `\nThese assertion IDs may be targeted for confirm, correction, or forgetting:\n${options.availableTargets.map((item) => `- ${item.id}: ${item.statement}`).join("\n")}` : "\nNo existing assertion IDs are available to target.";
 	return `Interpret the evidence-tagged conversation above for ${options.mode === "turn" ? "the latest user turn" : "durable transcript synthesis"}.
@@ -8,11 +8,17 @@ Evidence time: ${options.evidenceTimestamp}
 User timezone: ${options.timezone}
 
 Return exactly this top-level shape:
-{"intent":"none","candidates":[],"targetAssertionIds":[],"abstentionReason":"..."}
+{"intent":"none","candidates":[],"goals":[],"collaborationRules":[],"targetAssertionIds":[],"abstentionReason":"..."}
 
 Candidate shape:
 {"subject":{"type":"user","id":"self"},"predicate":"preference.response.detail","cardinality":"single","scope":{"type":"global"},"kind":"preference","value":"concise","normalizedValue":"concise","statement":"The user prefers concise answers.","authority":"user_observed","confidence":0.9,"declaredImportance":0.8,"inferredImportance":0.6,"consequence":"medium","actionability":1,"volatility":"stable","sensitivity":"normal","disclosurePolicy":"referenceable","applicability":{"operation":"response"},"temporalResolution":"exact","evidence":[{"ref":"entry-id","quote":"exact quote"}],"selfContained":true,"unresolvedReferences":[]}
 
+Goal shape:
+{"title":"Ship Atlas","desiredOutcome":"Atlas is released with all acceptance checks passing.","scope":{"type":"project","id":"exact-project-id"},"declaredImportance":0.9,"targetAt":"2026-09-30T18:00:00+08:00","evidence":[{"ref":"entry-id","quote":"exact quote"}],"selfContained":true,"unresolvedReferences":[]}
+
+Collaboration rule shape:
+{"category":"communication","priority":10,"scope":{"type":"global"},"conditions":{"enforcementLevel":"prompt"},"statement":"Keep status updates concise.","evidence":[{"ref":"entry-id","quote":"exact quote"}],"selfContained":true,"unresolvedReferences":[]}
+
 Allowed intents: remember, query, confirm, correct, forget, user_assertion, task, none.
 Allowed subject types: user, person, goal, project, topic.
 Allowed kinds: identity, preference, value, routine, capability, relationship, current_state, derived_insight.
@@ -23,6 +29,9 @@ Rules:
 - A request to create, summarize, update, investigate, or track work uses task, not a user assertion.
 - Every candidate needs an exact quote from a user message. Assistant messages can resolve context but are never evidence.
 - Extract zero to eight independent candidates. Each candidate represents one stable predicate and one value.
+- Extract a goal only when the user explicitly describes a durable desired outcome, not a one-off task request.
+- Extract a collaboration rule only when the user explicitly states an ongoing way the assistant should communicate, execute, or respect a boundary.
+- Use only prompt enforcement for inferred collaboration rules. Never invent tool gates or deny effects.
 - predicate is a stable language-neutral lowercase identifier. The value is excluded from predicate identity.
 - Preserve importance stated by the user in declaredImportance; estimate inferredImportance separately.
 - Use current_state or event volatility only with a bounded validTo. If relative time cannot be resolved, use temporalResolution=unresolved and omit resolved time fields.

package/dist/src/agent/context/audit.d.ts

@@ -1,4 +1,4 @@
-import type { ExecutionContext } from './execution-context.js';
+import type { ExecutionContext } from './execution-context.types.js';
 export interface ExecutionContextBudget {
     maxAssertions: number;
     maxKnowledge: number;
@@ -27,6 +27,7 @@ export declare function recordExecutionContext(context: ExecutionContext, input:
     sessionId: string;
     budget: ExecutionContextBudget;
     renderedChars: number;
+    includedContext?: ExecutionContext;
 }): void;
 export declare function getExecutionContextAudit(turnId: string): ExecutionContextAudit | undefined;
 export declare function recordExecutionContextFeedback(input: {
@@ -34,3 +35,4 @@ export declare function recordExecutionContextFeedback(input: {
     rating: 'helpful' | 'irrelevant';
     reason?: string;
 }): boolean;
+export declare function getExecutionContextFeedbackScores(): Map<string, number>;

package/dist/src/agent/context/audit.js

@@ -3,39 +3,46 @@ import { createHash } from "node:crypto";
 //#region src/agent/context/audit.ts
 function recordExecutionContext(context, input) {
 	const createdAt = Date.now();
+	const included = /* @__PURE__ */ new Set();
+	const selected = input.includedContext ?? context;
+	for (const item of selected.rules) included.add(`rule:${item.id}`);
+	for (const item of selected.assertions) included.add(`assertion:${item.assertion.id}`);
+	for (const item of selected.goals) included.add(`goal:${item.id}`);
+	for (const item of selected.priorities) included.add(`priority:${item.id}`);
+	for (const item of selected.knowledge) included.add(`knowledge:${item.id}`);
 	const items = [
 		...context.rules.map((item) => ({
 			objectType: "rule",
 			objectId: item.id,
 			reasons: [`${item.enforcementLevel}_rule`],
-			included: true
+			included: included.has(`rule:${item.id}`)
 		})),
 		...context.assertions.map((item) => ({
 			objectType: "assertion",
 			objectId: item.assertion.id,
 			score: item.score,
 			reasons: item.reasons,
-			included: true
+			included: included.has(`assertion:${item.assertion.id}`)
 		})),
 		...context.goals.map((item) => ({
 			objectType: "goal",
 			objectId: item.id,
 			reasons: ["active_goal"],
-			included: true
+			included: included.has(`goal:${item.id}`)
 		})),
 		...context.priorities.map((item) => ({
 			objectType: "priority",
 			objectId: item.id,
 			score: item.urgency,
 			reasons: [`${item.rank}_priority`],
-			included: true
+			included: included.has(`priority:${item.id}`)
 		})),
 		...context.knowledge.map((item) => ({
 			objectType: "knowledge",
 			objectId: item.id,
 			score: item.importance,
 			reasons: ["task_relevant_knowledge"],
-			included: true
+			included: included.has(`knowledge:${item.id}`)
 		}))
 	];
 	const metrics = {
@@ -44,6 +51,11 @@ function recordExecutionContext(context, input) {
 		goals: context.goals.length,
 		priorities: context.priorities.length,
 		knowledge: context.knowledge.length,
+		includedRules: selected.rules.length,
+		includedAssertions: selected.assertions.length,
+		includedGoals: selected.goals.length,
+		includedPriorities: selected.priorities.length,
+		includedKnowledge: selected.knowledge.length,
 		renderedChars: input.renderedChars
 	};
 	runSqliteWriteTransaction((db) => {
@@ -93,5 +105,19 @@ function recordExecutionContextFeedback(input) {
     rating = excluded.rating, reason = excluded.reason, updated_at = excluded.updated_at`).run(input.turnId, input.rating, input.reason ?? null, now, now, input.turnId);
 	return Number(result.changes) > 0;
 }
+function getExecutionContextFeedbackScores() {
+	const rows = getSqliteDatabase().prepare(`SELECT i.object_type, i.object_id,
+      COUNT(*) AS samples,
+      SUM(CASE f.rating WHEN 'helpful' THEN 1 ELSE -1 END) AS balance
+    FROM execution_context_items i
+    JOIN execution_context_runs r ON r.run_id = i.run_id
+    JOIN (
+      SELECT turn_id, rating FROM execution_context_feedback
+      ORDER BY updated_at DESC LIMIT 500
+    ) f ON f.turn_id = r.turn_id
+    WHERE i.included = 1
+    GROUP BY i.object_type, i.object_id`).all();
+	return new Map(rows.flatMap((row) => row.samples < 2 ? [] : [[`${row.object_type}:${row.object_id}`, Math.max(-.1, Math.min(.1, row.balance / row.samples * .1))]]));
+}
 //#endregion
-export { getExecutionContextAudit, recordExecutionContext, recordExecutionContextFeedback };
+export { getExecutionContextAudit, getExecutionContextFeedbackScores, recordExecutionContext, recordExecutionContextFeedback };

package/dist/src/agent/context/coordinator.d.ts

@@ -1,5 +1,6 @@
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { Config } from '../../config/schema.js';
+import type { KnowledgeSource } from '../../knowledge-memory/index.js';
 import { type ExecutionContext } from './execution-context.js';
 export interface ExecutionContextPlan {
     traceId: string;
@@ -11,7 +12,11 @@ export interface ExecutionContextPlan {
 }
 export interface ExecutionContextCoordinatorOptions {
     getConfig: () => Config | undefined;
-    isEnabledForSession: (sessionKey: string) => boolean;
+    getAccessForSession: (sessionKey: string) => {
+        userModel: boolean;
+        knowledge: boolean;
+        knowledgeSources: readonly KnowledgeSource[];
+    };
     getWorkspaceIdForSession: (sessionKey: string) => string;
     getProjectIdForSession: (sessionKey: string) => string | undefined;
 }

package/dist/src/agent/context/coordinator.js

@@ -1,16 +1,10 @@
-import { init_session_key, parseSessionKey } from "../../routing/session-key.js";
 import { extractProfileAgentId } from "../../config/agent-profile.js";
 import { assembleTaskContext } from "../../tasks/task-context-assembler.js";
 import { recordExecutionContext } from "./audit.js";
 import { prependAgentContext } from "./prepend.js";
 import { extractAgentUserPlainText } from "../memory/user-message-text.js";
-import { buildExecutionContext, renderExecutionContext } from "./execution-context.js";
+import { buildExecutionContext, fitExecutionContextToChars } from "./execution-context.js";
 //#region src/agent/context/coordinator.ts
-init_session_key();
-function isPrivateSession(sessionKey) {
-	const parsed = parseSessionKey(sessionKey);
-	return !parsed || parsed.peerKind === "direct";
-}
 var ExecutionContextCoordinator = class {
 	currentBySession = /* @__PURE__ */ new Map();
 	constructor(options) {
@@ -34,7 +28,8 @@ var ExecutionContextCoordinator = class {
 			contextItemCount: 0
 		});
 		const config = this.options.getConfig();
-		if (!config || !config.userContext.contextPlanning.enabled || !this.options.isEnabledForSession(sessionKey) || !isPrivateSession(sessionKey)) return empty();
+		const access = this.options.getAccessForSession(sessionKey);
+		if (!config || !config.userContext.contextPlanning.enabled || !access.userModel && !access.knowledge) return empty();
 		const task = assembleTaskContext(sessionKey, extractAgentUserPlainText(userMessage));
 		const context = buildExecutionContext({
 			query: task.retrievalQuery,
@@ -43,20 +38,26 @@ var ExecutionContextCoordinator = class {
 			projectId: this.options.getProjectIdForSession(sessionKey),
 			sessionId: sessionKey,
 			maxAssertions: Math.min(config.userContext.contextPlanning.maxAssertions, task.allocation.maxResults),
-			maxKnowledge: Math.min(config.userContext.contextPlanning.maxKnowledge, task.allocation.maxResults)
+			maxKnowledge: Math.min(config.userContext.contextPlanning.maxKnowledge, task.allocation.maxResults),
+			includeUserModel: access.userModel,
+			includeKnowledge: access.knowledge,
+			knowledgeSources: access.knowledgeSources
 		});
 		this.currentBySession.set(sessionKey, context);
-		const rendered = renderExecutionContext(context).slice(0, Math.min(config.userContext.contextPlanning.maxChars, task.allocation.maxChars));
-		const contextItemCount = context.rules.length + context.assertions.length + context.goals.length + context.priorities.length + context.knowledge.length;
+		const maxChars = Math.min(config.userContext.contextPlanning.maxChars, task.allocation.maxChars);
+		const fitted = fitExecutionContextToChars(context, maxChars);
+		const rendered = fitted.rendered;
+		const contextItemCount = fitted.context.rules.length + fitted.context.assertions.length + fitted.context.goals.length + fitted.context.priorities.length + fitted.context.knowledge.length;
 		recordExecutionContext(context, {
 			turnId,
 			sessionId: sessionKey,
 			budget: {
 				maxAssertions: Math.min(config.userContext.contextPlanning.maxAssertions, task.allocation.maxResults),
 				maxKnowledge: Math.min(config.userContext.contextPlanning.maxKnowledge, task.allocation.maxResults),
-				maxChars: Math.min(config.userContext.contextPlanning.maxChars, task.allocation.maxChars)
+				maxChars
 			},
-			renderedChars: rendered.length
+			renderedChars: rendered.length,
+			includedContext: fitted.context
 		});
 		return {
 			traceId: context.traceId,

package/dist/src/agent/context/execution-context.d.ts

@@ -1,52 +1,11 @@
-import { type KnowledgeItem, type KnowledgeVisibilityContext } from '../../knowledge-memory/index.js';
-import type { UserAssertion } from '../../user-model/domain.js';
-export type RuleEnforcementLevel = 'prompt' | 'planner' | 'tool_gate';
-export interface ExecutionRule {
-    id: string;
-    statement: string;
-    priority: number;
-    enforcementLevel: RuleEnforcementLevel;
-    conditions: Record<string, unknown>;
-}
-export interface RankedExecutionAssertion {
-    assertion: UserAssertion;
-    score: number;
-    reasons: string[];
-}
-export interface ExecutionGoal {
-    id: string;
-    title: string;
-    desiredOutcome: string;
-    status: string;
-    declaredImportance?: number;
-    targetAt?: number;
-}
-export interface ExecutionPriority {
-    id: string;
-    targetType: string;
-    targetId: string;
-    rank: 'primary' | 'secondary' | 'background';
-    urgency: number;
-    validTo: number;
-}
-export interface ExecutionContext {
-    traceId: string;
-    asOf: number;
-    query: string;
-    rules: ExecutionRule[];
-    assertions: RankedExecutionAssertion[];
-    goals: ExecutionGoal[];
-    priorities: ExecutionPriority[];
-    knowledge: KnowledgeItem[];
-}
-export interface ExecutionContextRequest extends KnowledgeVisibilityContext {
-    query: string;
-    asOf?: number;
-    maxAssertions?: number;
-    maxKnowledge?: number;
-}
+import type { ExecutionContext, ExecutionContextRequest, ExecutionRule } from './execution-context.types.js';
+export type { ExecutionContext, ExecutionContextRequest, ExecutionGoal, ExecutionPriority, ExecutionRule, RankedExecutionAssertion, RuleEnforcementLevel, } from './execution-context.types.js';
 export declare function buildExecutionContext(request: ExecutionContextRequest): ExecutionContext;
 export declare function renderExecutionContext(context: ExecutionContext): string;
+export declare function fitExecutionContextToChars(context: ExecutionContext, maxChars: number): {
+    context: ExecutionContext;
+    rendered: string;
+};
 export declare function evaluateToolGate(context: ExecutionContext, operation: string): {
     allowed: boolean;
     rule?: ExecutionRule;

package/dist/src/agent/context/execution-context.js

@@ -5,6 +5,8 @@ import "../../knowledge-memory/index.js";
 import { retrievalLexicalSimilarity } from "../../retrieval/textFeatures.js";
 import { calculateExecutionValue } from "../../user-model/importance.js";
 import { listUserAssertions } from "../../user-model/repository.js";
+import { getExecutionContextFeedbackScores } from "./audit.js";
+import { buildUserContextBlock } from "../memory/context-fence.js";
 import { randomUUID } from "node:crypto";
 //#region src/agent/context/execution-context.ts
 function scopeVisible(scope, context) {
@@ -16,6 +18,22 @@ function scopeVisible(scope, context) {
 		session: context.sessionId
 	}[scope.type];
 }
+function applicabilityVisible(applicability, context) {
+	const operation = applicability.operation;
+	if (typeof operation === "string" && operation !== "response") return false;
+	if (Array.isArray(operation) && !operation.some((value) => value === "response")) return false;
+	for (const [key, actual] of [
+		["agentId", context.agentId],
+		["workspaceId", context.workspaceId],
+		["projectId", context.projectId],
+		["sessionId", context.sessionId]
+	]) {
+		const expected = applicability[key];
+		if (typeof expected === "string" && expected !== actual) return false;
+		if (Array.isArray(expected) && !expected.some((value) => typeof value === "string" && value === actual)) return false;
+	}
+	return true;
+}
 function urgency(assertion, asOf) {
 	const deadline = assertion.validTo ?? assertion.reviewAt;
 	if (deadline === void 0) return 0;
@@ -23,7 +41,7 @@ function urgency(assertion, asOf) {
 	if (remaining <= 0) return 1;
 	return Math.max(0, 1 - remaining / (720 * 60 * 60 * 1e3));
 }
-function rankAssertion(assertion, query, asOf) {
+function rankAssertion(assertion, query, asOf, feedbackScore) {
 	const taskRelevance = retrievalLexicalSimilarity(query, `${assertion.statement} ${assertion.normalizedValue}`);
 	return {
 		assertion,
@@ -34,12 +52,14 @@ function rankAssertion(assertion, query, asOf) {
 			actionability: assertion.actionability,
 			taskRelevance,
 			urgency: urgency(assertion, asOf)
-		}),
+		}) + feedbackScore,
 		reasons: [
 			taskRelevance >= .35 ? "task_relevant" : "",
 			assertion.declaredImportance !== void 0 ? "user_declared_importance" : "",
 			assertion.consequence === "critical" || assertion.consequence === "high" ? "high_consequence" : "",
-			assertion.kind === "identity" || assertion.kind === "preference" ? "stable_personalization" : ""
+			assertion.kind === "identity" || assertion.kind === "preference" ? "stable_personalization" : "",
+			feedbackScore > 0 ? "historically_helpful" : "",
+			feedbackScore < 0 ? "historically_irrelevant" : ""
 		].filter(Boolean)
 	};
 }
@@ -93,24 +113,33 @@ function loadPriorities(context, asOf) {
 }
 function buildExecutionContext(request) {
 	const asOf = request.asOf ?? Date.now();
-	const assertions = listUserAssertions({
+	const includeUserModel = request.includeUserModel !== false;
+	const feedbackScores = getExecutionContextFeedbackScores();
+	const assertions = includeUserModel ? listUserAssertions({
 		statuses: ["active"],
 		limit: 1e3
-	}).filter((item) => scopeVisible(getAssertionScope(item.slotId), request)).filter((item) => (item.validFrom === void 0 || item.validFrom <= asOf) && (item.validTo === void 0 || item.validTo >= asOf)).filter((item) => item.sensitivity !== "secret" && item.sensitivity !== "regulated" && item.disclosurePolicy !== "ask_before_reference").map((item) => rankAssertion(item, request.query, asOf)).filter((item) => item.score >= .12 || item.reasons.includes("high_consequence")).sort((left, right) => right.score - left.score).slice(0, Math.max(1, Math.min(100, request.maxAssertions ?? 20)));
+	}).filter((item) => scopeVisible(getAssertionScope(item.slotId), request)).filter((item) => applicabilityVisible(item.applicability, request)).filter((item) => (item.validFrom === void 0 || item.validFrom <= asOf) && (item.validTo === void 0 || item.validTo >= asOf)).filter((item) => item.authority !== "external_untrusted").filter((item) => item.sensitivity !== "secret" && item.sensitivity !== "regulated" && item.disclosurePolicy !== "ask_before_reference").map((item) => rankAssertion(item, request.query, asOf, feedbackScores.get(`assertion:${item.id}`) ?? 0)).filter((item) => item.score >= .12 || item.reasons.includes("high_consequence")).sort((left, right) => right.score - left.score).slice(0, Math.max(1, Math.min(100, request.maxAssertions ?? 20))) : [];
+	const maxKnowledge = Math.max(0, Math.min(100, request.maxKnowledge ?? 12));
+	const knowledge = request.includeKnowledge === false || maxKnowledge === 0 ? [] : searchKnowledgeItems({
+		query: request.query,
+		context: request,
+		asOf,
+		trustedOnly: true,
+		sources: request.knowledgeSources,
+		limit: Math.min(100, maxKnowledge * 2)
+	}).map((item) => ({
+		item,
+		score: retrievalLexicalSimilarity(request.query, item.content) * .7 + item.importance * .3 + (feedbackScores.get(`knowledge:${item.id}`) ?? 0)
+	})).sort((left, right) => right.score - left.score).slice(0, maxKnowledge).map(({ item }) => item);
 	return {
 		traceId: randomUUID(),
 		asOf,
 		query: request.query,
-		rules: loadRules(request),
+		rules: includeUserModel ? loadRules(request) : [],
 		assertions,
-		goals: loadGoals(request, asOf),
-		priorities: loadPriorities(request, asOf),
-		knowledge: searchKnowledgeItems({
-			query: request.query,
-			context: request,
-			asOf,
-			limit: request.maxKnowledge ?? 12
-		})
+		goals: includeUserModel ? loadGoals(request, asOf) : [],
+		priorities: includeUserModel ? loadPriorities(request, asOf) : [],
+		knowledge
 	};
 }
 function getAssertionScope(slotId) {
@@ -130,6 +159,41 @@ function renderExecutionContext(context) {
 	if (context.knowledge.length) sections.push(`Relevant knowledge:\n${context.knowledge.map((item) => `- ${item.content}`).join("\n")}`);
 	return sections.join("\n\n");
 }
+function fitExecutionContextToChars(context, maxChars) {
+	const selected = {
+		...context,
+		rules: [],
+		assertions: [],
+		goals: [],
+		priorities: [],
+		knowledge: []
+	};
+	const fits = () => buildUserContextBlock(renderExecutionContext(selected)).length <= maxChars;
+	for (const item of context.rules) {
+		selected.rules.push(item);
+		if (!fits()) selected.rules.pop();
+	}
+	for (const item of context.assertions) {
+		selected.assertions.push(item);
+		if (!fits()) selected.assertions.pop();
+	}
+	for (const item of context.goals) {
+		selected.goals.push(item);
+		if (!fits()) selected.goals.pop();
+	}
+	for (const item of context.priorities) {
+		selected.priorities.push(item);
+		if (!fits()) selected.priorities.pop();
+	}
+	for (const item of context.knowledge) {
+		selected.knowledge.push(item);
+		if (!fits()) selected.knowledge.pop();
+	}
+	return {
+		context: selected,
+		rendered: buildUserContextBlock(renderExecutionContext(selected))
+	};
+}
 function evaluateToolGate(context, operation) {
 	for (const rule of context.rules) {
 		if (rule.enforcementLevel !== "tool_gate") continue;
@@ -144,4 +208,4 @@ function evaluateToolGate(context, operation) {
 	return { allowed: true };
 }
 //#endregion
-export { buildExecutionContext, evaluateToolGate, renderExecutionContext };
+export { buildExecutionContext, evaluateToolGate, fitExecutionContextToChars, renderExecutionContext };