@xopcai/xopc 0.0.374 → 0.0.376

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

@@ -1,6 +1,7 @@
 import { getSqliteDatabase, init_transaction } from "../../storage/sqlite/transaction.js";
 import { init_collaboration_rule_repository, listCollaborationRules } from "../../storage/sqlite/collaboration-rule-repository.js";
-import { searchKnowledgeItems } from "../../knowledge-memory/repository.js";
+import { canUseKnowledge } from "../../knowledge-memory/usage-policy.js";
+import { listKnowledgeItems, searchKnowledgeItems } from "../../knowledge-memory/repository.js";
 import "../../knowledge-memory/index.js";
 import { listUserAssertions } from "../../user-model/repository.js";
 import { calculateExecutionValue } from "../../user-model/importance.js";
@@ -132,17 +133,28 @@ function buildExecutionContext(request) {
 	})).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) : [];
 	const assertions = [...rankedAssertions.filter((item) => item.usage === "confirmed"), ...rankedAssertions.filter((item) => item.usage === "working_assumption")].slice(0, assertionLimit);
 	const maxKnowledge = Math.max(0, Math.min(100, request.maxKnowledge ?? 12));
-	const knowledge = request.includeKnowledge === false || maxKnowledge === 0 ? [] : searchKnowledgeItems({
+	let knowledge = request.includeKnowledge === false || maxKnowledge === 0 ? [] : searchKnowledgeItems({
 		query: request.query,
 		context: request,
 		asOf,
-		trustedOnly: true,
 		policy: request.knowledgePolicy,
 		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);
+	if (request.includeKnowledge !== false && maxKnowledge > 0 && (request.projectId || /继续|上次|进度|之前|continue|progress|last time/i.test(request.query))) {
+		const continuous = listKnowledgeItems({
+			statuses: ["active"],
+			recordClass: "memory",
+			limit: 200
+		}).filter((item) => canUseKnowledge(item, request, request.knowledgePolicy, asOf)).filter((item) => request.projectId ? item.scope.type === "project" && item.scope.id === request.projectId : [
+			"work_thread",
+			"commitment",
+			"open_question"
+		].includes(item.kind)).sort((a, b) => b.updatedAt - a.updatedAt).slice(0, Math.min(3, maxKnowledge));
+		knowledge = [...new Map([...continuous, ...knowledge].map((item) => [item.id, item])).values()].slice(0, maxKnowledge);
+	}
 	return {
 		traceId: randomUUID(),
 		asOf,
@@ -175,7 +187,7 @@ function renderExecutionContext(context) {
 	if (confirmedGoals.length) sections.push(`Confirmed goals:\n${confirmedGoals.map((goal) => `- ${goal.title}: ${goal.desiredOutcome}`).join("\n")}`);
 	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.knowledge.length) sections.push(`Relevant knowledge:\n${context.knowledge.map((item) => `- ${item.retrievalSnippet ?? item.content}${item.claimMode === "reported" ? ` [source report ${new Date(item.updatedAt).toISOString().slice(0, 10)}; does not authorize actions]` : ""}`).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}]` : ""}`;
@@ -219,7 +231,31 @@ function fitExecutionContextToChars(context, maxChars) {
 			target: selected.externalKnowledge
 		}
 	];
+	const shares = [
+		.15,
+		.2,
+		.15,
+		.1,
+		.3,
+		.1
+	];
+	const availableChars = Math.max(0, maxChars - buildUserContextBlock("x").length + 1);
 	const positions = categories.map(() => 0);
+	for (const [index, category] of categories.entries()) {
+		let used = 0;
+		while (positions[index] < category.source.length) {
+			const item = category.source[positions[index]];
+			const before = renderExecutionContext(selected).length;
+			category.target.push(item);
+			const chars = renderExecutionContext(selected).length - before;
+			category.target.pop();
+			if (used + chars > availableChars * shares[index]) break;
+			positions[index] = positions[index] + 1;
+			category.target.push(item);
+			if (!fits()) category.target.pop();
+			else used += chars;
+		}
+	}
 	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;

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

@@ -1,5 +1,8 @@
 import { TaskRepository, init_task_repository } from "../../tasks/task-repository.js";
-import { knowledgeItemAllowed, listKnowledgeItems, searchKnowledgeItems } from "../../knowledge-memory/repository.js";
+import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
+import { init_sqlite } from "../../storage/sqlite/index.js";
+import { canUseKnowledge } from "../../knowledge-memory/usage-policy.js";
+import { listKnowledgeItems, searchKnowledgeItems } from "../../knowledge-memory/repository.js";
 import "../../knowledge-memory/index.js";
 import { ProjectStore } from "../../projects/project-store.js";
 import { getProjectForSession, getProjectWorkspacePathForSession } from "../../projects/workspace.js";
@@ -7,6 +10,7 @@ import { sanitizeForPromptLiteral } from "../prompt/sanitize-for-prompt.js";
 import { TaskReadModelProjector } from "../../tasks/task-read-model-projector.js";
 import { LocalAppStore } from "../../local-apps/store.js";
 //#region src/agent/context/project-context.ts
+init_sqlite();
 init_task_repository();
 const MAX_TEXT = 1200;
 const MAX_TASKS = 5;
@@ -59,7 +63,6 @@ function buildActiveProjectContextForPrompt(conversationId, options = {}) {
 					projectId: project.id,
 					conversationId
 				},
-				trustedOnly: true,
 				policy: options.knowledgePolicy,
 				limit: MAX_RELEVANT_KNOWLEDGE
 			}) : [],
@@ -70,7 +73,12 @@ function buildActiveProjectContextForPrompt(conversationId, options = {}) {
 					id: project.id
 				},
 				limit: 500
-			}).filter((item) => item.originClass !== "untrusted").filter((item) => !options.knowledgePolicy || knowledgeItemAllowed(item, options.knowledgePolicy)).slice(0, MAX_RECENT_KNOWLEDGE)
+			}).filter((item) => canUseKnowledge(item, {
+				agentId: getSessionMetadata(conversationId)?.agentId ?? "main",
+				workspaceId: project.workspaceRoot ?? "",
+				projectId: project.id,
+				conversationId
+			}, options.knowledgePolicy)).slice(0, MAX_RECENT_KNOWLEDGE)
 		}),
 		localApp: localApp ? {
 			extensionId: localApp.extensionId,

package/dist/src/agent/embedded/model-runtime.js

@@ -1,6 +1,6 @@
 import { init_paths, resolveModelsJsonPath } from "../../config/paths.js";
-import { init_register_bundled_oauth_flows, registerBundledOAuthFlows } from "../../providers/register-bundled-oauth-flows.js";
 import { assertCurrentModelProvider, init_provider_policy } from "../../providers/provider-policy.js";
+import { init_register_bundled_oauth_flows, registerBundledOAuthFlows } from "../../providers/register-bundled-oauth-flows.js";
 import { CredentialResolver, init_credentials } from "../../auth/credentials.js";
 import { init_sync_provider_auth, resolveProviderApiKeySync } from "../../auth/sync-provider-auth.js";
 import { XopcModelCredentialStore, init_model_credential_store } from "../../auth/model-credential-store.js";

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

@@ -2,13 +2,13 @@ import { createLogger } from "../../utils/logger/index.js";
 import { init_logger } from "../../utils/logger.js";
 import { parseTurnOutcome } from "../../../packages/gateway-contract/src/turn-outcome.js";
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
-import { setTraceIdentity, startObservation, traceOperation, traceRun } from "../../observability/runtime.js";
 import { resolveEffectiveAgentProfileForSession } from "../../config/agent-profile.js";
 import { init_providers, resolveModel } from "../../providers/index.js";
 import { appendDynamicPromptSection } from "../prompt/cache-boundary.js";
+import { setTraceIdentity, startObservation, traceOperation, traceRun } from "../../observability/runtime.js";
+import { resolveAgentTurnTimeoutMs } from "../orchestration/run-agent-turn-with-timeout.js";
 import { isPersonalConversation } from "../../personal-agent/repository.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";
 import { prepareNativeMcpConfig } from "../mcp/native-mcp.js";
 import { evaluateContextBudget } from "../memory/context-budget.js";

package/dist/src/agent/embedded/run-turn.js

@@ -6,18 +6,18 @@ import { getConnectionResumeInput, init_connection_wait_repository, isConnection
 import { getSessionMetadata } from "../../storage/sqlite/session-read-repository.js";
 import { init_session_repository } from "../../storage/sqlite/session-repository.js";
 import { init_sqlite } from "../../storage/sqlite/index.js";
-import { setTraceIdentity, traceOperation, traceRun, traceTools } from "../../observability/runtime.js";
 import { resolveEffectiveAgentConfigForSession } from "../../config/agent-profile.js";
+import { setTraceIdentity, traceOperation, traceRun, traceTools } from "../../observability/runtime.js";
 import { continuesAfterTool, trackAiUsageStream } from "../../usage/recorder.js";
+import { cloudCreditBudgetStopMessage, isCloudCreditBudgetExhausted, reportCloudCreditError, withCloudCreditBudget } from "../../providers/xopc-cloud-credit-budget.js";
+import { isAgentTurnUnsettledError, resolveAgentTurnTimeoutMs, runAgentTurnWithTimeout } from "../orchestration/run-agent-turn-with-timeout.js";
+import { isContextOverflowError } from "../orchestration/context-overflow.js";
+import { getAssistantTurnErrorMessage, isAssistantTurnAborted, isAssistantTurnFailed, maybeRetryTurnAfterTransientLlmFailure, stripTrailingErrorAssistantMessages } from "../orchestration/llm-turn-retry.js";
 import { runWithEmbeddedExecutionSession } from "./execution-context.js";
 import { externalPolicyContext } from "./tool-metadata.js";
-import { cloudCreditBudgetStopMessage, isCloudCreditBudgetExhausted, reportCloudCreditError, withCloudCreditBudget } from "../../providers/xopc-cloud-credit-budget.js";
 import { isComputerControlActive, isComputerLeaseTool, stopComputerControl } from "../../computer/control-guard.js";
 import { EmbeddedRunConflictError, abortEmbeddedRun, acquireEmbeddedRunLease, queueEmbeddedSteer } from "./runs.js";
 import { lastAssistantPlainText, subscribeEmbeddedSessionEvents } from "./subscribe-session.js";
-import { isContextOverflowError } from "../orchestration/context-overflow.js";
-import { getAssistantTurnErrorMessage, isAssistantTurnAborted, isAssistantTurnFailed, maybeRetryTurnAfterTransientLlmFailure, stripTrailingErrorAssistantMessages } from "../orchestration/llm-turn-retry.js";
-import { isAgentTurnUnsettledError, resolveAgentTurnTimeoutMs, runAgentTurnWithTimeout } from "../orchestration/run-agent-turn-with-timeout.js";
 import { detectToolLoops } from "../orchestration/loop-guard.js";
 import { tryApplySessionTranscriptHygiene } from "../transcript/transcript-hygiene.js";
 import { restoreCurrentTurnImages } from "./current-turn-images.js";

package/dist/src/agent/image/tool-model-config.js

@@ -1,6 +1,6 @@
 import { init_agent_scope, resolveDefaultAgentId } from "../agent-scope.js";
-import { getAgentDefaultImageModelConfig, getAgentDefaultModelRef, init_schema, parseModelRef } from "../../config/schema.js";
 import { resolveEffectiveAgentConfigForAgent } from "../../config/agent-profile.js";
+import { getAgentDefaultImageModelConfig, getAgentDefaultModelRef, init_schema, parseModelRef } from "../../config/schema.js";
 import { getDefaultModelSync, getModelsByProvider, init_providers, isProviderConfiguredSync, resolveModel } from "../../providers/index.js";
 import { resolveAgentModelFallbackValues, resolveAgentModelPrimaryValue } from "../../config/model-input.js";
 import { buildCapabilityPlansForConfig } from "../../capabilities/readiness/from-config.js";

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

@@ -1,10 +1,10 @@
 import { stripRuntimeUserMessageEnvelope } from "../../../packages/gateway-contract/src/user-message-display.js";
 import { init_src } from "../../../packages/gateway-contract/src/index.js";
 import { extractProfileAgentId } from "../../config/agent-profile.js";
+import { readAgentMessageContent } from "../memory/agent-message-access.js";
 import { isPersonalConversation } from "../../personal-agent/repository.js";
 import { MODEL_IMAGE_MAX_BYTES, MODEL_IMAGE_SOURCE_MAX_BYTES, prepareImageForModel } from "../image/prepare-image-for-model.js";
 import { mimeTypeFromMediaPath } from "../../media/store.js";
-import { readAgentMessageContent } from "../memory/agent-message-access.js";
 import { readMediaReference } from "../../media/media-reference.js";
 import { isImageInboundAttachment } from "../../channels/attachments/attachment-classifiers.js";
 import "../../channels/attachments/inbound-persist.js";

package/dist/src/agent/mcp/connection-setup.d.ts

@@ -0,0 +1,21 @@
+import type { Config } from '../../config/schema.js';
+export type McpConnectionProbe = {
+    state: 'connected' | 'oauth_required' | 'token_required' | 'error';
+    toolCount?: number;
+    error?: string;
+};
+export declare function probeMcpConnection(config: Config, workspace: string, serverId: string): Promise<McpConnectionProbe>;
+export type McpAuthorization = {
+    id: string;
+    serverId: string;
+    state: 'starting' | 'authorizing' | 'connected' | 'error' | 'cancelled';
+    authorizationUrl?: string;
+    acceptsRedirect?: boolean;
+    toolCount?: number;
+    error?: string;
+};
+/** A UI bridge to native pi's login command; no host-owned OAuth client or token store. */
+export declare function startMcpAuthorization(config: Config, workspace: string, serverId: string, owner: string): McpAuthorization;
+export declare function getMcpAuthorization(id: string, owner: string, config: Config): McpAuthorization | undefined;
+export declare function cancelMcpAuthorization(id: string, owner: string): boolean;
+export declare function submitMcpRedirect(id: string, owner: string, redirectUrl: string, config: Config): boolean;

package/dist/src/agent/mcp/connection-setup.js

@@ -0,0 +1,214 @@
+import { isManagedConnectorServer } from "../../connectors/materialize.js";
+import { prepareNativeMcpConfig } from "./native-mcp.js";
+import { McpAuthenticationRequiredError, discoverMcpTools, signInNativeMcp } from "./tool-catalog.js";
+import { createHash, randomUUID } from "node:crypto";
+//#region src/agent/mcp/connection-setup.ts
+function httpUrl(value) {
+	const url = new URL(value);
+	if (!["http:", "https:"].includes(url.protocol) || url.username || url.password) throw new Error("Use an HTTP or HTTPS MCP address without embedded credentials.");
+	return url;
+}
+async function metadata(url) {
+	try {
+		const response = await fetch(url, {
+			signal: AbortSignal.timeout(5e3),
+			redirect: "error",
+			headers: { Accept: "application/json" }
+		});
+		if (!response.ok) return;
+		const result = await response.json();
+		if (result && typeof result === "object" && !Array.isArray(result)) return result;
+	} catch {}
+}
+/** A 401 alone is not evidence that a service supports OAuth. */
+async function advertisesOAuth(config, workspace, serverId) {
+	const entry = (await prepareNativeMcpConfig(config, workspace)).servers.find((server) => server.name === serverId);
+	if (!entry || !("url" in entry.config)) return false;
+	const url = httpUrl(entry.config.url);
+	if (Object.keys(entry.config.headers ?? {}).some((name) => name.toLowerCase() === "authorization")) return false;
+	const response = await fetch(url, {
+		method: "POST",
+		signal: AbortSignal.timeout(1e4),
+		redirect: "error",
+		headers: {
+			Accept: "application/json, text/event-stream",
+			"Content-Type": "application/json",
+			...entry.config.headers
+		},
+		body: JSON.stringify({
+			jsonrpc: "2.0",
+			id: 1,
+			method: "initialize",
+			params: {
+				protocolVersion: "2025-03-26",
+				capabilities: {},
+				clientInfo: {
+					name: "xopc",
+					version: "1"
+				}
+			}
+		})
+	});
+	const challenge = response.headers.get("WWW-Authenticate") ?? "";
+	await response.body?.cancel();
+	const resourceMetadata = /resource_metadata\s*=\s*"([^"\s]+)"/i.exec(challenge)?.[1];
+	const candidates = [
+		...resourceMetadata ? [httpUrl(resourceMetadata)] : [],
+		new URL(`/.well-known/oauth-protected-resource${url.pathname === "/" ? "" : url.pathname}`, url),
+		new URL("/.well-known/oauth-protected-resource", url)
+	];
+	for (const candidate of candidates) {
+		const data = await metadata(candidate);
+		if (data && typeof data.resource === "string" && data.resource === url.href && Array.isArray(data.authorization_servers) && data.authorization_servers.some((value) => {
+			try {
+				return typeof value === "string" && Boolean(httpUrl(value));
+			} catch {
+				return false;
+			}
+		})) return true;
+	}
+	if (!/\bBearer\b/i.test(challenge)) return false;
+	const legacy = await metadata(new URL("/.well-known/oauth-authorization-server", url));
+	return Boolean(legacy && legacy.issuer === url.origin && typeof legacy.authorization_endpoint === "string" && typeof legacy.token_endpoint === "string");
+}
+async function probeMcpConnection(config, workspace, serverId) {
+	try {
+		return {
+			state: "connected",
+			toolCount: (await discoverMcpTools(config, workspace, serverId)).length
+		};
+	} catch (error) {
+		if (error instanceof McpAuthenticationRequiredError) try {
+			return { state: await advertisesOAuth(config, workspace, serverId) ? "oauth_required" : "token_required" };
+		} catch (error) {
+			return {
+				state: "error",
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+		const server = config.mcp?.servers?.[serverId];
+		if (server?.url && Object.keys(server.headers ?? {}).some((name) => name.toLowerCase() === "authorization") && /401|403|unauthorized|forbidden/i.test(String(error))) return { state: "token_required" };
+		return {
+			state: "error",
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+const attempts = /* @__PURE__ */ new Map();
+function fingerprint(config, serverId) {
+	const server = config.mcp?.servers?.[serverId];
+	return createHash("sha256").update(JSON.stringify(server ? {
+		...server,
+		xopcConnector: void 0
+	} : null)).digest("hex");
+}
+function finish(attempt) {
+	attempt.dispose?.();
+	attempt.dispose = void 0;
+	attempt.redirect?.(void 0);
+	attempt.redirect = void 0;
+	attempt.result.acceptsRedirect = false;
+}
+function cancel(attempt) {
+	if (attempt.result.state === "starting" || attempt.result.state === "authorizing") {
+		attempt.result.state = "cancelled";
+		attempt.controller.abort();
+		finish(attempt);
+	}
+}
+/** A UI bridge to native pi's login command; no host-owned OAuth client or token store. */
+function startMcpAuthorization(config, workspace, serverId, owner) {
+	const server = config.mcp?.servers?.[serverId];
+	if (!server?.url || server.enabled === false || isManagedConnectorServer(server) && server.xopcConnector.enabled === false) throw new Error("An enabled HTTP MCP server is required.");
+	httpUrl(server.url);
+	if (server.auth || Object.keys(server.headers ?? {}).some((name) => name.toLowerCase() === "authorization")) throw new Error("This server uses configured credentials. Remove Authorization before using OAuth.");
+	for (const attempt of attempts.values()) if (attempt.owner === owner && attempt.result.serverId === serverId) cancel(attempt);
+	if (attempts.size >= 100) throw new Error("Too many pending sign-ins. Try again later.");
+	const attempt = {
+		owner,
+		fingerprint: fingerprint(config, serverId),
+		controller: new AbortController(),
+		result: {
+			id: randomUUID(),
+			serverId,
+			state: "starting"
+		}
+	};
+	attempts.set(attempt.result.id, attempt);
+	const expiry = setTimeout(() => cancel(attempt), 18e4);
+	expiry.unref();
+	setTimeout(() => {
+		cancel(attempt);
+		attempts.delete(attempt.result.id);
+	}, 10 * 6e4).unref();
+	signInNativeMcp(structuredClone(config), workspace, serverId, {
+		signal: attempt.controller.signal,
+		onAuthorizationUrl(url) {
+			const parsed = httpUrl(url);
+			if (attempt.controller.signal.aborted) return;
+			attempt.result.authorizationUrl = parsed.href;
+			attempt.result.state = "authorizing";
+		},
+		requestRedirectUrl(signal) {
+			if (signal?.aborted || attempt.controller.signal.aborted) return Promise.resolve(void 0);
+			attempt.result.acceptsRedirect = true;
+			return new Promise((resolve) => {
+				const stop = () => resolve(void 0);
+				signal?.addEventListener("abort", stop, { once: true });
+				attempt.redirect = resolve;
+				attempt.dispose = () => signal?.removeEventListener("abort", stop);
+			});
+		}
+	}).then((tools) => {
+		if (!attempt.controller.signal.aborted) {
+			attempt.result.state = "connected";
+			attempt.result.toolCount = tools.length;
+			delete attempt.result.authorizationUrl;
+		}
+	}).catch((error) => {
+		if (!attempt.controller.signal.aborted) {
+			attempt.result.state = "error";
+			attempt.result.error = error instanceof Error ? error.message : String(error);
+			delete attempt.result.authorizationUrl;
+		}
+	}).finally(() => {
+		clearTimeout(expiry);
+		finish(attempt);
+	});
+	return { ...attempt.result };
+}
+function getMcpAuthorization(id, owner, config) {
+	const attempt = attempts.get(id);
+	if (!attempt || attempt.owner !== owner) return;
+	if (attempt.fingerprint !== fingerprint(config, attempt.result.serverId)) {
+		cancel(attempt);
+		attempt.result = {
+			id,
+			serverId: attempt.result.serverId,
+			state: "cancelled"
+		};
+	}
+	return { ...attempt.result };
+}
+function cancelMcpAuthorization(id, owner) {
+	const attempt = attempts.get(id);
+	if (!attempt || attempt.owner !== owner) return false;
+	cancel(attempt);
+	return true;
+}
+function submitMcpRedirect(id, owner, redirectUrl, config) {
+	const result = getMcpAuthorization(id, owner, config);
+	const attempt = attempts.get(id);
+	if (!result || !attempt?.redirect || result.state !== "authorizing" || !result.authorizationUrl) return false;
+	const authorization = new URL(result.authorizationUrl);
+	const expected = authorization.searchParams.get("redirect_uri");
+	if (!expected) return false;
+	const target = new URL(expected);
+	const actual = httpUrl(redirectUrl);
+	if (actual.origin !== target.origin || actual.pathname !== target.pathname || actual.searchParams.get("state") !== authorization.searchParams.get("state") || !actual.searchParams.get("code")) return false;
+	attempt.redirect(actual.href);
+	attempt.redirect = void 0;
+	return true;
+}
+//#endregion
+export { cancelMcpAuthorization, getMcpAuthorization, probeMcpConnection, startMcpAuthorization, submitMcpRedirect };

package/dist/src/agent/mcp/tool-catalog.d.ts

@@ -0,0 +1,18 @@
+import type { Config } from '../../config/schema.js';
+export type McpCatalogTool = {
+    name: string;
+    description: string;
+    inputSchema: unknown;
+    exposure?: string;
+};
+export declare class McpAuthenticationRequiredError extends Error {
+}
+export type McpLoginInteraction = {
+    signal: AbortSignal;
+    onAuthorizationUrl: (url: string) => void;
+    requestRedirectUrl: (signal?: AbortSignal) => Promise<string | undefined>;
+};
+/** A short-lived native session discovers tools without making a model request. */
+export declare function discoverMcpTools(config: Config, workspaceDir: string, serverId: string): Promise<McpCatalogTool[]>;
+/** Native pi owns PKCE, registration, callbacks, token storage and refresh. */
+export declare function signInNativeMcp(config: Config, workspaceDir: string, serverId: string, interaction: McpLoginInteraction): Promise<McpCatalogTool[]>;

package/dist/src/agent/mcp/tool-catalog.js

@@ -0,0 +1,120 @@
+import { createEmbeddedModelRuntime } from "../embedded/model-runtime.js";
+import { getNativePiAgentDir, prepareNativeMcpConfig } from "./native-mcp.js";
+import { join } from "node:path";
+import { InMemoryCredentialStore, InMemoryModelsStore } from "@earendil-works/pi-ai";
+import { DefaultResourceLoader, ModelRuntime, SessionManager, SettingsManager, createAgentSession, createMcpExtension, createToolSearchExtension } from "@earendil-works/pi-coding-agent";
+//#region src/agent/mcp/tool-catalog.ts
+var McpAuthenticationRequiredError = class extends Error {};
+/** A short-lived native session discovers tools without making a model request. */
+async function discoverMcpTools(config, workspaceDir, serverId) {
+	return runNativeMcpSession(config, workspaceDir, serverId);
+}
+/** Native pi owns PKCE, registration, callbacks, token storage and refresh. */
+async function signInNativeMcp(config, workspaceDir, serverId, interaction) {
+	return runNativeMcpSession(config, workspaceDir, serverId, interaction);
+}
+async function runNativeMcpSession(config, workspaceDir, serverId, interaction) {
+	const entry = (await prepareNativeMcpConfig(config, workspaceDir)).servers.find((server) => server.name === serverId);
+	if (!entry) throw new Error(`MCP server "${serverId}" is not configured or has invalid configuration.`);
+	if (entry.config.enabled === false) throw new Error(`MCP server "${serverId}" is disabled.`);
+	const agentDir = getNativePiAgentDir();
+	const settingsManager = SettingsManager.inMemory({
+		retry: { enabled: false },
+		compaction: { enabled: false }
+	});
+	const loader = new DefaultResourceLoader({
+		cwd: workspaceDir,
+		agentDir,
+		settingsManager,
+		noExtensions: true,
+		noSkills: true,
+		noPromptTemplates: true,
+		noThemes: true,
+		noContextFiles: true,
+		extensionFactories: [createToolSearchExtension(), createMcpExtension({
+			loadConfig: () => ({
+				servers: [entry],
+				errors: [],
+				autoEnableCodemode: false
+			}),
+			logPath: join(agentDir, "mcp.log"),
+			openUrl: (url) => interaction?.onAuthorizationUrl(url)
+		})]
+	});
+	await loader.reload();
+	const provider = "url" in entry.config ? entry.config.auth?.provider : void 0;
+	const { session } = await createAgentSession({
+		cwd: workspaceDir,
+		agentDir,
+		resourceLoader: loader,
+		settingsManager,
+		modelRuntime: provider ? await createEmbeddedModelRuntime(provider) : await ModelRuntime.create({
+			credentials: new InMemoryCredentialStore(),
+			modelsStore: new InMemoryModelsStore(),
+			modelsPath: null,
+			refreshOnCreate: false
+		}),
+		sessionManager: SessionManager.inMemory(),
+		noTools: "builtin"
+	});
+	let failure;
+	let signedIn = false;
+	let shutdown;
+	const close = () => shutdown ??= session.extensionRunner?.emit({
+		type: "session_shutdown",
+		reason: "quit"
+	}) ?? Promise.resolve();
+	const abort = () => {
+		close();
+	};
+	try {
+		const runner = session.extensionRunner;
+		if (!runner) throw new Error("Native MCP extension is unavailable.");
+		await session.bindExtensions({ uiContext: {
+			...runner.getUIContext(),
+			notify(message) {
+				if (message.startsWith("MCP servers need attention:") || message.startsWith("MCP failed to load:")) failure = message;
+				if (message.startsWith("Signed in to MCP server")) signedIn = true;
+				if (message.startsWith("Sign-in ") || message.startsWith("Signed in, but")) failure = message;
+			},
+			input(_title, _placeholder, options) {
+				return interaction?.requestRedirectUrl(options?.signal) ?? Promise.resolve(void 0);
+			}
+		} });
+		interaction?.signal.addEventListener("abort", abort, { once: true });
+		if (interaction?.signal.aborted) throw new Error("MCP sign-in cancelled.");
+		let timer;
+		try {
+			await Promise.race([session.prompt("/mcp"), new Promise((_resolve, reject) => {
+				timer = setTimeout(() => reject(/* @__PURE__ */ new Error("MCP tool discovery timed out.")), 6e4);
+			})]);
+		} finally {
+			clearTimeout(timer);
+		}
+		if (interaction) {
+			failure = void 0;
+			await session.prompt(`/mcp login ${serverId}`);
+			if (interaction.signal.aborted) throw new Error("MCP sign-in cancelled.");
+			if (failure || !signedIn) throw new Error(failure ?? "MCP sign-in did not complete.");
+		} else if (failure) {
+			if (/needs sign-in|needs-auth/.test(failure)) throw new McpAuthenticationRequiredError(failure);
+			throw new Error(failure);
+		}
+		const namespace = `mcp__${serverId.replace(/-/g, "_")}`;
+		return session.getAllTools().filter((tool) => tool.namespace?.name === namespace).map((tool) => ({
+			name: tool.name,
+			description: tool.description,
+			inputSchema: tool.parameters,
+			exposure: tool.exposure
+		})).sort((a, b) => a.name.localeCompare(b.name));
+	} finally {
+		try {
+			interaction?.signal.removeEventListener("abort", abort);
+			await close();
+		} finally {
+			session.dispose();
+		}
+	}
+}
+//#endregion
+export { McpAuthenticationRequiredError, discoverMcpTools, signInNativeMcp };

package/dist/src/agent/memory/compaction-promotion.d.ts

@@ -1,5 +1,6 @@
 import type { CompactionAudit, CompactionHandover } from '../../session/compaction-types.js';
 import type { TranscriptSourceEntry } from '../../storage/sqlite/transcript-repository.js';
+import { type KnowledgeReadPolicy } from '../../knowledge-memory/index.js';
 export interface PromoteCompactionLedgerInput {
     conversationId: string;
     transcriptId: string;
@@ -10,6 +11,7 @@ export interface PromoteCompactionLedgerInput {
     audit: CompactionAudit;
     sourceEntries: readonly TranscriptSourceEntry[];
     writePolicy: 'deny' | 'allow';
+    readPolicy?: KnowledgeReadPolicy;
 }
 export interface PromoteCompactionLedgerResult {
     episodicRecordIds: string[];