@xopcai/xopc 0.0.302 → 0.0.306

package/dist/src/agent/commands/command-registry.js

@@ -2,11 +2,11 @@ import { resolveStateDir } from "../../config/paths-state.js";
 import { init_global_singleton, resolveGlobalSingleton } from "../../utils/global-singleton.js";
 import { init_paths } from "../../config/paths.js";
 import { DurableState } from "../../storage/sqlite/durable-state.js";
+import { spawnProcess } from "../../process/run-process.js";
 import { isolatedCommand, removeCommandContainer } from "./command-isolation.js";
 import { readWorkspaceRevision } from "../coding/workspace-revision.js";
 import { join } from "node:path";
 import { appendFileSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
-import { spawn } from "node:child_process";
 import { createHash, randomUUID } from "node:crypto";
 //#region src/agent/commands/command-registry.ts
 init_paths();
@@ -17,26 +17,6 @@ const MAX_LOG_BYTES = 8 * 1024 * 1024;
 function commandTimeout(raw, ceiling = MAX_COMMAND_TIMEOUT_MS) {
 	return Math.min(ceiling, Math.max(1, typeof raw === "number" && Number.isFinite(raw) ? Math.floor(raw) : DEFAULT_COMMAND_TIMEOUT_MS));
 }
-function killTree(child) {
-	if (!child.pid) return;
-	if (process.platform === "win32") {
-		const killer = spawn("taskkill", [
-			"/pid",
-			String(child.pid),
-			"/t",
-			"/f"
-		], {
-			stdio: "ignore",
-			windowsHide: true
-		});
-		killer.on("error", () => child.kill("SIGKILL"));
-		killer.unref();
-	} else try {
-		process.kill(-child.pid, "SIGKILL");
-	} catch {
-		child.kill("SIGKILL");
-	}
-}
 /** Foreground and background tools share ownership, cancellation, output and durable receipts. */
 var CommandRegistry = class {
 	prunedAt = /* @__PURE__ */ new Map();
@@ -97,12 +77,6 @@ var CommandRegistry = class {
 			flag: "wx"
 		});
 		this.persist(input.owner, result);
-		const child = spawn(launch.executable, launch.args, {
-			shell: launch.shell,
-			cwd: input.cwd,
-			env: input.env,
-			detached: process.platform !== "win32"
-		});
 		const limit = input.maxOutputChars ?? 5e4;
 		let logBytes = 0;
 		let closed = false;
@@ -123,6 +97,19 @@ var CommandRegistry = class {
 			result.logTruncated ||= bytes.length > remaining;
 			input.onOutput?.(stream, value.length > 16e3 ? `${value.slice(0, 16e3)}\n[stream delta truncated]` : value);
 		};
+		const handle = spawnProcess({
+			program: launch.executable,
+			args: launch.args,
+			shell: launch.shell,
+			cwd: input.cwd,
+			env: input.env,
+			detached: process.platform !== "win32",
+			terminationPolicy: "tree",
+			keepStdinOpen: true,
+			maxOutputBytes: 0,
+			onOutput: append
+		});
+		const child = handle.child;
 		const stop = (status) => {
 			if (result.status !== "running" || closed) return;
 			result.status = status;
@@ -131,25 +118,23 @@ var CommandRegistry = class {
 				result.status = "interrupted";
 				append("stderr", `Container cleanup failed: ${String(error)}`);
 			});
-			killTree(child);
+			handle.terminate(status === "timed_out" ? "timed_out" : "cancelled");
 		};
 		const timer = setTimeout(() => stop("timed_out"), commandTimeout(input.timeoutMs));
 		timer.unref();
 		const abort = () => stop("cancelled");
 		input.signal?.addEventListener("abort", abort, { once: true });
 		const done = new Promise((resolve) => {
-			child.stdout?.on("data", (value) => append("stdout", value));
-			child.stderr?.on("data", (value) => append("stderr", value));
 			child.on("error", (error) => append("stderr", error.message));
 			child.stdin?.on("error", (error) => append("stderr", error.message));
-			child.on("close", async (exitCode) => {
+			handle.completion.then(async (processResult) => {
 				closed = true;
 				clearTimeout(timer);
 				input.signal?.removeEventListener("abort", abort);
 				if (containerCleanup) await containerCleanup;
 				if (input.snapshot) result.endRevision = await readWorkspaceRevision(input.cwd);
-				if (result.status === "running") result.status = exitCode === 0 ? "success" : "failed";
-				result.exitCode = exitCode;
+				if (result.status === "running") result.status = processResult.exitCode === 0 ? "success" : "failed";
+				result.exitCode = processResult.exitCode;
 				result.durationMs = Date.now() - result.createdAtMs;
 				try {
 					this.persist(input.owner, result);

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

@@ -11,6 +11,7 @@ function recordExecutionContext(context, input) {
 	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}`);
+	for (const item of selected.externalKnowledge) included.add(`knowledge:external:${item.citation.providerId}:${item.record.id}`);
 	const items = [
 		...context.rules.map((item) => ({
 			objectType: "rule",
@@ -44,6 +45,13 @@ function recordExecutionContext(context, input) {
 			score: item.importance,
 			reasons: ["task_relevant_knowledge"],
 			included: included.has(`knowledge:${item.id}`)
+		})),
+		...context.externalKnowledge.map((item) => ({
+			objectType: "knowledge",
+			objectId: `external:${item.citation.providerId}:${item.record.id}`,
+			score: item.score,
+			reasons: ["external_memory", "task_relevant_knowledge"],
+			included: included.has(`knowledge:external:${item.citation.providerId}:${item.record.id}`)
 		}))
 	];
 	const metrics = {
@@ -51,12 +59,14 @@ function recordExecutionContext(context, input) {
 		assertions: context.assertions.length,
 		goals: context.goals.length,
 		priorities: context.priorities.length,
-		knowledge: context.knowledge.length,
+		knowledge: context.knowledge.length + context.externalKnowledge.length,
+		externalKnowledge: context.externalKnowledge.length,
 		includedRules: selected.rules.length,
 		includedAssertions: selected.assertions.length,
 		includedGoals: selected.goals.length,
 		includedPriorities: selected.priorities.length,
-		includedKnowledge: selected.knowledge.length,
+		includedKnowledge: selected.knowledge.length + selected.externalKnowledge.length,
+		includedExternalKnowledge: selected.externalKnowledge.length,
 		renderedChars: input.renderedChars
 	};
 	runSqliteWriteTransaction((db) => {

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

@@ -1,10 +1,11 @@
 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 { KnowledgeReadPolicy } from '../../knowledge-memory/index.js';
+import type { MemorySearchResult } from '../memory/types.js';
 import { type ExecutionContext } from './execution-context.js';
 export interface ExecutionContextPlan {
     traceId: string;
-    modelMessage: AgentMessage;
+    dynamicSystemContext?: string;
     executionContext?: ExecutionContext;
     estimatedTokens: number;
     contextChars: number;
@@ -15,10 +16,19 @@ export interface ExecutionContextCoordinatorOptions {
     getAccessForSession: (conversationId: string) => {
         userModel: boolean;
         knowledge: boolean;
-        knowledgeSources: readonly KnowledgeSource[];
+        knowledgePolicy: KnowledgeReadPolicy;
     };
     getWorkspaceIdForSession: (conversationId: string) => string;
     getProjectIdForSession: (conversationId: string) => string | undefined;
+    ensureMemoryReady: (conversationId: string) => Promise<void>;
+    searchExternalMemory: (input: {
+        query: string;
+        conversationId: string;
+        agentId: string;
+        workspaceId: string;
+        projectId?: string;
+        maxResults: number;
+    }) => Promise<MemorySearchResult[]>;
 }
 export declare class ExecutionContextCoordinator {
     private readonly options;

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

@@ -1,7 +1,6 @@
 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, fitExecutionContextToChars } from "./execution-context.js";
 //#region src/agent/context/coordinator.ts
@@ -22,7 +21,6 @@ var ExecutionContextCoordinator = class {
 	async prepare(userMessage, conversationId, turnId) {
 		const empty = () => ({
 			traceId: "",
-			modelMessage: userMessage,
 			estimatedTokens: 0,
 			contextChars: 0,
 			contextItemCount: 0
@@ -30,30 +28,48 @@ var ExecutionContextCoordinator = class {
 		const config = this.options.getConfig();
 		const access = this.options.getAccessForSession(conversationId);
 		if (!config || !config.userContext.contextPlanning.enabled || !access.userModel && !access.knowledge) return empty();
+		await this.options.ensureMemoryReady(conversationId);
 		const task = assembleTaskContext(conversationId, extractAgentUserPlainText(userMessage));
+		const agentId = extractProfileAgentId(conversationId, config);
+		const workspaceId = this.options.getWorkspaceIdForSession(conversationId);
+		const projectId = this.options.getProjectIdForSession(conversationId);
+		const maxKnowledge = Math.min(config.userContext.contextPlanning.maxKnowledge, task.allocation.maxResults);
+		const strategy = config.userContext.knowledgeMemory.searchStrategy;
+		const externalResults = access.knowledge && access.knowledgePolicy.contentSources.includes("connector") && strategy !== "local-only" && maxKnowledge > 0 ? await this.options.searchExternalMemory({
+			query: task.retrievalQuery,
+			conversationId,
+			agentId,
+			workspaceId,
+			projectId,
+			maxResults: maxKnowledge
+		}) : [];
+		const externalReserved = strategy === "external-only" || strategy === "external-first" ? Math.min(maxKnowledge, externalResults.length) : strategy === "fanout" ? Math.min(Math.ceil(maxKnowledge / 2), externalResults.length) : 0;
+		const localBudget = strategy === "external-only" ? 0 : maxKnowledge - externalReserved;
 		const context = buildExecutionContext({
 			query: task.retrievalQuery,
-			agentId: extractProfileAgentId(conversationId, config),
-			workspaceId: this.options.getWorkspaceIdForSession(conversationId),
-			projectId: this.options.getProjectIdForSession(conversationId),
+			agentId,
+			workspaceId,
+			projectId,
 			conversationId,
 			maxAssertions: Math.min(config.userContext.contextPlanning.maxAssertions, task.allocation.maxResults),
-			maxKnowledge: Math.min(config.userContext.contextPlanning.maxKnowledge, task.allocation.maxResults),
+			maxKnowledge: localBudget,
 			includeUserModel: access.userModel,
-			includeKnowledge: access.knowledge,
-			knowledgeSources: access.knowledgeSources
+			includeKnowledge: access.knowledge && strategy !== "external-only",
+			knowledgePolicy: access.knowledgePolicy
 		});
+		const remainingKnowledge = Math.max(0, maxKnowledge - context.knowledge.length);
+		context.externalKnowledge = externalResults.slice(0, remainingKnowledge);
 		this.currentBySession.set(conversationId, context);
 		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;
+		const contextItemCount = fitted.context.rules.length + fitted.context.assertions.length + fitted.context.goals.length + fitted.context.priorities.length + fitted.context.knowledge.length + fitted.context.externalKnowledge.length;
 		recordExecutionContext(context, {
 			turnId,
 			conversationId,
 			budget: {
 				maxAssertions: Math.min(config.userContext.contextPlanning.maxAssertions, task.allocation.maxResults),
-				maxKnowledge: Math.min(config.userContext.contextPlanning.maxKnowledge, task.allocation.maxResults),
+				maxKnowledge,
 				maxChars
 			},
 			renderedChars: rendered.length,
@@ -61,7 +77,7 @@ var ExecutionContextCoordinator = class {
 		});
 		return {
 			traceId: context.traceId,
-			modelMessage: prependAgentContext(userMessage, rendered),
+			dynamicSystemContext: rendered,
 			executionContext: context,
 			estimatedTokens: Math.ceil(rendered.length / 4),
 			contextChars: rendered.length,

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

@@ -133,7 +133,7 @@ function buildExecutionContext(request) {
 		context: request,
 		asOf,
 		trustedOnly: true,
-		sources: request.knowledgeSources,
+		policy: request.knowledgePolicy,
 		limit: Math.min(100, maxKnowledge * 2)
 	}).map((item) => ({
 		item,
@@ -147,7 +147,8 @@ function buildExecutionContext(request) {
 		assertions,
 		goals: includeUserModel ? loadGoals(request, asOf) : [],
 		priorities: includeUserModel ? loadPriorities(request, asOf) : [],
-		knowledge
+		knowledge,
+		externalKnowledge: []
 	};
 }
 function getAssertionScope(slotId) {
@@ -171,6 +172,10 @@ function renderExecutionContext(context) {
 	if (assumedGoals.length) sections.push(`Possible goals (not yet confirmed):\n${assumedGoals.map((goal) => `- ${goal.title}: ${goal.desiredOutcome}`).join("\n")}`);
 	if (context.priorities.length) sections.push(`Current priorities:\n${context.priorities.map((item) => `- ${item.rank}: ${item.targetType}/${item.targetId}`).join("\n")}`);
 	if (context.knowledge.length) sections.push(`Relevant knowledge:\n${context.knowledge.map((item) => `- ${item.content}`).join("\n")}`);
+	if (context.externalKnowledge.length) sections.push(`Relevant external memory:\n${context.externalKnowledge.map((item) => {
+		const citation = item.citation.title ?? item.citation.path ?? item.citation.uri;
+		return `- ${item.snippet || item.record.content}${citation ? ` [${citation}]` : ""}`;
+	}).join("\n")}`);
 	return sections.join("\n\n");
 }
 function fitExecutionContextToChars(context, maxChars) {
@@ -180,28 +185,43 @@ function fitExecutionContextToChars(context, maxChars) {
 		assertions: [],
 		goals: [],
 		priorities: [],
-		knowledge: []
+		knowledge: [],
+		externalKnowledge: []
 	};
 	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();
+	const categories = [
+		{
+			source: context.rules,
+			target: selected.rules
+		},
+		{
+			source: context.assertions,
+			target: selected.assertions
+		},
+		{
+			source: context.goals,
+			target: selected.goals
+		},
+		{
+			source: context.priorities,
+			target: selected.priorities
+		},
+		{
+			source: context.knowledge,
+			target: selected.knowledge
+		},
+		{
+			source: context.externalKnowledge,
+			target: selected.externalKnowledge
+		}
+	];
+	const positions = categories.map(() => 0);
+	while (categories.some((category, index) => positions[index] < category.source.length)) for (const [index, category] of categories.entries()) {
+		const item = category.source[positions[index]];
+		if (item === void 0) continue;
+		positions[index] = positions[index] + 1;
+		category.target.push(item);
+		if (!fits()) category.target.pop();
 	}
 	return {
 		context: selected,

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

@@ -1,5 +1,6 @@
-import type { KnowledgeItem, KnowledgeSource, KnowledgeVisibilityContext } from '../../knowledge-memory/index.js';
+import type { KnowledgeItem, KnowledgeReadPolicy, KnowledgeVisibilityContext } from '../../knowledge-memory/index.js';
 import type { UserAssertion } from '../../user-model/domain.js';
+import type { MemorySearchResult } from '../memory/types.js';
 export type RuleEnforcementLevel = 'prompt' | 'planner' | 'tool_gate';
 export interface ExecutionRule {
     id: string;
@@ -40,6 +41,7 @@ export interface ExecutionContext {
     goals: ExecutionGoal[];
     priorities: ExecutionPriority[];
     knowledge: KnowledgeItem[];
+    externalKnowledge: MemorySearchResult[];
 }
 export interface ExecutionContextRequest extends KnowledgeVisibilityContext {
     query: string;
@@ -48,5 +50,5 @@ export interface ExecutionContextRequest extends KnowledgeVisibilityContext {
     maxKnowledge?: number;
     includeUserModel?: boolean;
     includeKnowledge?: boolean;
-    knowledgeSources?: readonly KnowledgeSource[];
+    knowledgePolicy?: KnowledgeReadPolicy;
 }

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

@@ -1,4 +1,4 @@
-import type { KnowledgeSource } from '../../knowledge-memory/index.js';
+import type { KnowledgeReadPolicy } from '../../knowledge-memory/index.js';
 export type ExecutionObjective = {
     kind: 'task';
     id: string;
@@ -26,5 +26,5 @@ export declare function resolveExecutionScope(conversationId: string): Execution
 export declare function formatCurrentWorkForPrompt(scope: ExecutionScope): string | undefined;
 export declare function buildExecutionScopeContextForPrompt(conversationId: string, options?: {
     includeKnowledge?: boolean;
-    knowledgeSources?: readonly KnowledgeSource[];
+    knowledgePolicy?: KnowledgeReadPolicy;
 }): string | undefined;

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

@@ -82,7 +82,7 @@ function buildExecutionScopeContextForPrompt(conversationId, options = {}) {
 	return [buildActiveProjectContextForPrompt(conversationId, {
 		knowledgeQuery: scope.objective?.objective,
 		includeKnowledge: options.includeKnowledge,
-		knowledgeSources: options.knowledgeSources
+		knowledgePolicy: options.knowledgePolicy
 	}), formatCurrentWorkForPrompt(scope)].filter((section) => Boolean(section?.trim())).join("\n\n") || void 0;
 }
 //#endregion

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

@@ -1,5 +1,5 @@
 import type { Project } from '../../projects/types.js';
-import { type KnowledgeSource } from '../../knowledge-memory/index.js';
+import { type KnowledgeReadPolicy } from '../../knowledge-memory/index.js';
 export interface ProjectTaskContext {
     title: string;
     state: string;
@@ -8,7 +8,7 @@ export interface ProjectTaskContext {
 export declare function buildActiveProjectContextForPrompt(conversationId: string, options?: {
     knowledgeQuery?: string;
     includeKnowledge?: boolean;
-    knowledgeSources?: readonly KnowledgeSource[];
+    knowledgePolicy?: KnowledgeReadPolicy;
 }): string | undefined;
 export declare function formatActiveProjectContextForPrompt(input: {
     project: Project;

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

@@ -4,7 +4,7 @@ import { TaskReadModelProjector } from "../../tasks/task-read-model-projector.js
 import { LocalAppStore } from "../../local-apps/store.js";
 import { ProjectStore } from "../../projects/project-store.js";
 import { getProjectForSession, getProjectWorkspacePathForSession } from "../../projects/workspace.js";
-import { knowledgeSourceAllowed, listKnowledgeItems, searchKnowledgeItems } from "../../knowledge-memory/repository.js";
+import { knowledgeItemAllowed, listKnowledgeItems, searchKnowledgeItems } from "../../knowledge-memory/repository.js";
 import "../../knowledge-memory/index.js";
 //#region src/agent/context/project-context.ts
 const MAX_TEXT = 1200;
@@ -59,7 +59,7 @@ function buildActiveProjectContextForPrompt(conversationId, options = {}) {
 					conversationId
 				},
 				trustedOnly: true,
-				sources: options.knowledgeSources,
+				policy: options.knowledgePolicy,
 				limit: MAX_RELEVANT_KNOWLEDGE
 			}) : [],
 			recent: listKnowledgeItems({
@@ -69,7 +69,7 @@ function buildActiveProjectContextForPrompt(conversationId, options = {}) {
 					id: project.id
 				},
 				limit: 500
-			}).filter((item) => item.originClass !== "untrusted").filter((item) => !options.knowledgeSources || knowledgeSourceAllowed(item, options.knowledgeSources)).slice(0, MAX_RECENT_KNOWLEDGE)
+			}).filter((item) => item.originClass !== "untrusted").filter((item) => !options.knowledgePolicy || knowledgeItemAllowed(item, options.knowledgePolicy)).slice(0, MAX_RECENT_KNOWLEDGE)
 		}),
 		localApp: localApp ? {
 			extensionId: localApp.extensionId,

package/dist/src/agent/embedded/run-for-session.d.ts

@@ -8,6 +8,7 @@ export type RunEmbeddedForSessionParams = {
     conversationId: string;
     runId?: string;
     userMessage: AgentMessage;
+    dynamicSystemContext?: string;
     llmImages?: import('@earendil-works/pi-ai').ImageContent[];
     sessionStore: SessionStore;
     agentManager: AgentInstanceGateway;

package/dist/src/agent/embedded/run-for-session.js

@@ -4,6 +4,7 @@ import { parseTurnOutcome } from "../../../packages/gateway-contract/src/turn-ou
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
 import { init_providers, resolveModel } from "../../providers/index.js";
+import { appendDynamicPromptSection } from "../prompt/cache-boundary.js";
 import { runWithEmbeddedExecutionSession } from "./execution-context.js";
 import { resolveAgentTurnTimeoutMs } from "../orchestration/run-agent-turn-with-timeout.js";
 import { resolvePromptCachePolicy } from "../../providers/prompt-cache-plan.js";
@@ -71,6 +72,11 @@ async function runEmbeddedTurnForSession(params) {
 			ok: false,
 			errorMessage: "aborted"
 		};
+		await agentManager.ensureMemoryReadyForSession?.(conversationId);
+		if (supervisor.signal.aborted) return {
+			ok: false,
+			errorMessage: "aborted"
+		};
 		const agent = agentManager.getOrCreateAgent(conversationId);
 		const mm = modelManager;
 		const configuredModelRef = String(mm.getModelForSession(conversationId));
@@ -100,7 +106,7 @@ async function runEmbeddedTurnForSession(params) {
 		agentManager.setModelForSession(conversationId, modelRef);
 		const tools = agent.state.tools;
 		const turnPolicy = agentManager.createAgentTurnPolicy(conversationId);
-		const systemPrompt = [agent.state.systemPrompt ?? "", params.presentation === "voice" ? voicePresentationPrompt : ""].filter(Boolean).join("\n\n");
+		const systemPrompt = appendDynamicPromptSection([agent.state.systemPrompt ?? "", params.presentation === "voice" ? voicePresentationPrompt : ""].filter(Boolean).join("\n\n"), params.dynamicSystemContext ?? "");
 		const thinkingLevel = params.thinkingOverride ?? agent.state.thinkingLevel;
 		const workspaceDir = agentManager.getResolvedWorkspaceForSession(conversationId);
 		const promptCachePolicy = resolvePromptCachePolicy(config ? resolveEffectiveAgentProfileForSession(config, conversationId).config.runtime.promptCache : void 0);

package/dist/src/agent/inbound/attachment-pipeline.d.ts

@@ -24,6 +24,8 @@ export declare function buildTranscriptUserMessage(opts: {
     modelRef: string;
     config: Config | undefined;
     agentManager: AgentInstanceGateway;
+    /** Keep these attachments in transcript metadata without exposing read_media hints to the LLM. */
+    suppressMediaPromptUris?: ReadonlySet<string>;
 }): Promise<TranscriptUserMessage>;
 /** Hydrate images from media store for the current LLM prompt. */
 export declare function hydrateUserTurnForLlm(opts: {

package/dist/src/agent/inbound/attachment-pipeline.js

@@ -58,8 +58,8 @@ async function readImageBase64FromRef(ref) {
 		mimeType: prepared.mimeType
 	};
 }
-function appendMediaAttachedLines(textParts, media) {
-	for (const ref of media) if (!isImageInboundAttachment(ref)) textParts.push([
+function appendMediaAttachedLines(textParts, media, suppressMediaPromptUris) {
+	for (const ref of media) if (!isImageInboundAttachment(ref) && !suppressMediaPromptUris?.has(ref.uri)) textParts.push([
 		`[media attached: ${ref.name} (${ref.mimeType}, ${ref.size} bytes)]`,
 		`xopc-media-uri:${ref.uri}`,
 		`xopc-media-path:${ref.path}`,
@@ -85,7 +85,7 @@ async function buildTranscriptUserMessage(opts) {
 	const textParts = [];
 	if (expandedText) textParts.push(expandedText);
 	const strategy = resolveImageHandlingStrategy(opts.modelRef);
-	appendMediaAttachedLines(textParts, prepared.filter((m) => !isImageInboundAttachment(m)));
+	appendMediaAttachedLines(textParts, prepared.filter((m) => !isImageInboundAttachment(m)), opts.suppressMediaPromptUris);
 	if (imageRefs.length > 0 && strategy !== "native") {
 		const images = await Promise.all(imageRefs.map((ref) => readImageBase64FromRef(ref)));
 		const agentId = opts.config ? extractProfileAgentId(opts.conversationId, opts.config) : void 0;

package/dist/src/agent/inbound/inbound-loop.js

@@ -95,6 +95,7 @@ var InboundLoop = class {
 				...sessionMetadata?.transcriptId ? { transcriptId: sessionMetadata.transcriptId } : {}
 			});
 			await this.cfg.sessionContextManager.runWith(sessionContext, async () => {
+				await this.cfg.agentManager.ensureMemoryReadyForSession?.(sessionContext.conversationId);
 				this.cfg.agentManager.getOrCreateAgent(sessionContext.conversationId);
 				this.cfg.setupSessionEventHandling(sessionContext.conversationId);
 				await this.cfg.sessionLifecycleManager.startSession(sessionContext);

package/dist/src/agent/inbound/turn-dispatcher.js

@@ -106,13 +106,14 @@ var TurnDispatcher = class {
 			sessionConfigStore: c.sessionConfigStore,
 			commandHandler: c.commandHandler,
 			prepareInboundAttachments: c.prepareInboundAttachments,
-			buildTranscriptUserMessage: async (text, prepared, sk) => buildDirectUserMessageContent({
+			buildTranscriptUserMessage: async (text, prepared, sk, options) => buildDirectUserMessageContent({
 				content: text,
 				attachments: prepared,
 				conversationId: sk,
 				config: c.requireConfig(),
 				agentManager: c.agentManager,
-				modelManager: c.modelManager
+				modelManager: c.modelManager,
+				suppressMediaPromptUris: options?.suppressMediaPromptUris
 			}),
 			recordTaskReviewStreamHint: (sk, o) => c.sessionState.recordTaskReviewStreamHint(sk, o),
 			enqueueProvisionalSessionTitle: (sk, userText) => {
@@ -128,7 +129,6 @@ var TurnDispatcher = class {
 			sourceContextResolver: c.sourceContextResolver,
 			maybeEmitWebchatTts: (sk, hadVoice) => maybeEmitWebchatTts({
 				config: c.getConfig(),
-				sessionStore: c.sessionStore,
 				getLastAssistantPlainText: (conversationId) => c.sessionState.getLastAssistantText(conversationId) ?? c.agentManager.getLastAssistantContent(conversationId) ?? "",
 				log: this.log
 			}, sk, hadVoice),

package/dist/src/agent/mcp/mcp-stdio-transport.js

@@ -1,4 +1,4 @@
-import { killProcessTree } from "../../process/kill-tree.js";
+import { terminateProcess } from "../../process/kill-tree.js";
 import { spawn } from "node:child_process";
 import { getDefaultEnvironment } from "@modelcontextprotocol/sdk/client/stdio.js";
 import process from "node:process";
@@ -87,7 +87,10 @@ var XopcStdioClientTransport = class {
 			} catch {}
 			await Promise.race([closePromise, delay(CLOSE_TIMEOUT_MS)]);
 			if (processToClose.exitCode === null && processToClose.pid) {
-				killProcessTree(processToClose.pid);
+				await terminateProcess(processToClose, {
+					tree: true,
+					detached: process.platform !== "win32"
+				});
 				await Promise.race([closePromise, delay(CLOSE_TIMEOUT_MS)]);
 			}
 		}

package/dist/src/agent/memory/compaction-promotion.js

@@ -1,4 +1,4 @@
-import { listKnowledgeItems, setKnowledgeStatus, writeKnowledgeItem } from "../../knowledge-memory/repository.js";
+import { listKnowledgeItems, transitionKnowledgeStatus, writeKnowledgeItem } from "../../knowledge-memory/repository.js";
 import "../../knowledge-memory/index.js";
 import { resolveMemorySessionKind } from "./turn-provenance.js";
 import { createHash } from "node:crypto";
@@ -146,7 +146,12 @@ function promoteCompactionLedger(input) {
 		result.episodicRecordIds.push(episode.item.id);
 		if (!(active && input.audit.status === "passed" && sessionKind === "interactive" && originClass === "agent" && !classified.derivedFromRecalledContext && DURABLE_KINDS.has(item.kind))) {
 			const existingDurable = !active ? listKnowledgeItems({ limit: 2e3 }).find((entry) => entry.canonicalKey === `durable:${item.kind}:${stableId("fact", item.text)}`) : void 0;
-			if (existingDurable?.sourceConversationId === input.conversationId) setKnowledgeStatus(existingDurable.id, "archived");
+			if (existingDurable?.sourceConversationId === input.conversationId) transitionKnowledgeStatus({
+				id: existingDurable.id,
+				status: "archived",
+				actor: "runtime",
+				reason: "The source session no longer supports this durable memory."
+			});
 			result.rejectedRecordIds.push(episode.item.id);
 			continue;
 		}

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

@@ -19,6 +19,7 @@ function resolveMemoryManagerOptions(config) {
 	const providerRouting = config.userContext.knowledgeMemory;
 	return {
 		searchStrategy: providerRouting.searchStrategy,
+		searchTimeoutMs: providerRouting.searchTimeoutMs,
 		writeStrategy: providerRouting.writeStrategy,
 		writePolicy: {
 			allowExternalWrites: providerRouting.allowExternalWrites,

package/dist/src/agent/memory/manager.d.ts

@@ -14,6 +14,7 @@ export interface MemoryManagerOptions extends MemoryRoutingOptions {
     loadProviders?: () => Promise<MemoryProvider[]>;
     writePolicy?: MemoryWritePolicy;
     memoryRuntime?: MemoryRuntime;
+    searchTimeoutMs?: number;
 }
 export interface MemoryWritePolicy {
     allowExternalWrites?: boolean;
@@ -27,7 +28,10 @@ export declare class MemoryManager {
     private readonly loadProviders?;
     private readonly writePolicy;
     private pluginProvidersLoaded;
+    private pluginProvidersPromise?;
+    private readonly sessionInitializations;
     private readonly memoryRuntime?;
+    private readonly searchTimeoutMs;
     private readonly sessionContexts;
     constructor(options?: MemoryManagerOptions);
     addProvider(provider: MemoryProvider): void;
@@ -48,6 +52,8 @@ export declare class MemoryManager {
     }>;
     handleToolCall(toolName: string, args: Record<string, unknown>): Promise<string>;
     search(request: MemorySearchRequest): Promise<MemorySearchResult[]>;
+    searchExternal(request: MemorySearchRequest): Promise<MemorySearchResult[]>;
+    private searchProviders;
     read(request: MemoryReadRequest): Promise<MemoryReadResult | null>;
     get(id: string): Promise<MemoryRecord | null>;
     list(request: MemoryListRequest): Promise<MemoryRecord[]>;