@nextclaw/kernel 0.4.1-beta.0 → 0.4.2

package/dist/index.js

@@ -1,7 +1,7 @@
 import { n as getUnsignedUpdateManifest, r as serializeUnsignedUpdateManifest, t as UpdateManifestReader } from "./update-manifest.types-C0qPrjGQ.js";
 import { createRequire } from "node:module";
 import { NcpEventType, sanitizeAssistantReplyTags } from "@nextclaw/ncp";
-import { AgentRouteResolver, BUILTIN_MAIN_AGENT_ID, CLEAR_THINKING_TOKENS, CONTEXT_COMPACTION_METADATA_KEY, ChannelManager, ChannelManager as ChannelManager$1, ConfigSchema, ContextBuilder, ContextCompactionService, ContextWindowBudgetService, CronService, CronTool, DEFAULT_PANELS_DIR, DEFAULT_SERVICE_APPS_DIR, DEFAULT_SESSION_SEARCH_LIMIT, EditFileTool, ExecTool, GatewayTool, InputBudgetPruner, LLMProvider, ListDirTool, LiteLLMProvider, MAX_SESSION_SEARCH_LIMIT, MemoryGetTool, MemorySearchTool, MessageBus, MessageTool, ProviderRegistry, ReadFileTool, RequestedSkillsMetadataReader, SessionSearchManager, SkillsLoader, THINKING_LEVELS, WebFetchTool, WebSearchTool, WriteFileTool, buildCompressingCompactionCheckpoint, buildConfigSchema, buildContextWindowSnapshot, buildMinimalSystemExecutionPrompt, buildReloadPlan, buildSessionRequestToolResult, buildToolCatalogEntries, createAssistantStreamDeltaControlMessage, createAssistantStreamResetControlMessage, createCompletedSessionRequest, createFailedSessionRequest, createRunningSessionRequest, createRuntimeChildEnv, createTypingStopControlMessage, diffConfigPaths, ensureDir, expandHome, findEffectiveAgentProfile, getConfigPath, getDataDir, getDataPath, getSessionsPath, getWorkspacePath, getWorkspacePathFromConfig, loadConfig, mergeExtensionConfigView, modelSupportsVision, normalizeInlineSecretRefs, normalizeProviderModelConfig, normalizeToolParams, parseAgentScopedSessionKey, parseThinkingLevel, readCompressedContextCompactionCheckpoint, readOptionalString, readParentSessionId, readSessionProjectRoot, redactConfigObject, resolveConfigSecrets, resolveDefaultAgentProfileId, resolveProviderRuntime, resolveSessionWorkspacePath, resolveThinkingLevel, saveConfig, summarizeSessionRequestTask, toDisposable, toExtensionConfigView } from "@nextclaw/core";
+import { APP_NAME, AgentRouteResolver, BUILTIN_MAIN_AGENT_ID, CLEAR_THINKING_TOKENS, CONTEXT_COMPACTION_METADATA_KEY, ChannelManager, ChannelManager as ChannelManager$1, ConfigSchema, ContextCompactionService, ContextWindowBudgetService, CronService, CronTool, DEFAULT_PANELS_DIR, DEFAULT_SERVICE_APPS_DIR, DEFAULT_SESSION_SEARCH_LIMIT, DEFAULT_WORKSPACE_REPOSITORY_IDENTITY_RESOLVER, EditFileTool, ExecTool, GatewayTool, InputBudgetPruner, LLMProvider, ListDirTool, LiteLLMProvider, MAX_SESSION_SEARCH_LIMIT, MemoryGetTool, MemorySearchTool, MemoryStore, MessageBus, MessageTool, ProviderRegistry, ReadFileTool, RequestedSkillsMetadataReader, SILENT_REPLY_TOKEN, SessionProjectContextResolver, SessionSearchManager, SkillsLoader, THINKING_LEVELS, WebFetchTool, WebSearchTool, WriteFileTool, buildCompressingCompactionCheckpoint, buildConfigSchema, buildContextWindowSnapshot, buildReloadPlan, buildSessionRequestToolResult, buildToolCatalogEntries, createAssistantStreamDeltaControlMessage, createAssistantStreamResetControlMessage, createCompletedSessionRequest, createFailedSessionRequest, createRunningSessionRequest, createRuntimeChildEnv, createTypingStopControlMessage, diffConfigPaths, ensureDir, expandHome, findEffectiveAgentProfile, getConfigPath, getDataDir, getDataPath, getSessionsPath, getWorkspacePath, getWorkspacePathFromConfig, loadConfig, mergeExtensionConfigView, modelSupportsVision, normalizeInlineSecretRefs, normalizeProviderModelConfig, normalizeToolParams, parseAgentScopedSessionKey, parseThinkingLevel, readCompressedContextCompactionCheckpoint, readOptionalString, readParentSessionId, readSessionProjectRoot, redactConfigObject, resolveConfigSecrets, resolveDefaultAgentProfileId, resolveNextclawSelfManageGuidePaths, resolveProviderRuntime, resolveSessionWorkspacePath, resolveThinkingLevel, saveConfig, summarizeSessionRequestTask, toDisposable, toExtensionConfigView } from "@nextclaw/core";
 import { LocalAssetStore, buildAssetContentPath, buildNcpUserContent, buildOpenAiFunctionTool, ncpMessageToOpenAiMessages, validateToolArgs } from "@nextclaw/ncp-agent-runtime";
 import { createHash, createHmac, randomBytes, randomUUID, scryptSync, timingSafeEqual } from "node:crypto";
 import { EventBus, Ingress, eventKeys, ingressKeys } from "@nextclaw/shared";
@@ -3270,13 +3270,7 @@ function readMessageFromSummaryEvent(event) {
 	if (event.type === NcpEventType.MessageSent || event.type === NcpEventType.MessageCompleted || event.type === "session.snapshot.message") return event.payload.message;
 }
 //#endregion
-//#region src/managers/session.manager.ts
-const DEFAULT_SESSION_TYPE = "native";
-const DEFAULT_LIFECYCLE = "persistent";
-const SESSION_METADATA_LABEL_KEY = "label";
-const CHILD_SESSION_PARENT_METADATA_KEY = "parent_session_id";
-const CHILD_SESSION_REQUEST_METADATA_KEY = "spawned_by_request_id";
-const CHILD_SESSION_LIFECYCLE_METADATA_KEY = "session_lifecycle";
+//#region src/utils/session-manager.utils.ts
 function normalizeSessionId(sessionId) {
 	return sessionId.trim();
 }
@@ -3295,6 +3289,37 @@ function readOptionalMetadataString(value) {
 function readEventSessionId$1(event) {
 	return "payload" in event && "sessionId" in event.payload ? readOptionalMetadataString(event.payload.sessionId) : void 0;
 }
+//#endregion
+//#region src/services/session-working-dir-resolver.service.ts
+var SessionWorkingDirResolver = class {
+	constructor(configManager) {
+		this.configManager = configManager;
+	}
+	withWorkingDir = (summary) => ({
+		...summary,
+		workingDir: this.resolve({
+			agentId: summary.agentId,
+			metadata: summary.metadata
+		})
+	});
+	resolve = (params) => {
+		const config = this.configManager.loadConfig();
+		const defaultAgentId = resolveDefaultAgentProfileId(config);
+		const profile = findEffectiveAgentProfile(config, readOptionalString$7(params.agentId) ?? defaultAgentId) ?? findEffectiveAgentProfile(config, defaultAgentId);
+		return resolveSessionWorkspacePath({
+			sessionMetadata: params.metadata,
+			workspace: profile?.workspace ?? config.agents.defaults.workspace
+		});
+	};
+};
+//#endregion
+//#region src/managers/session.manager.ts
+const DEFAULT_SESSION_TYPE = "native";
+const DEFAULT_LIFECYCLE = "persistent";
+const SESSION_METADATA_LABEL_KEY = "label";
+const CHILD_SESSION_PARENT_METADATA_KEY = "parent_session_id";
+const CHILD_SESSION_REQUEST_METADATA_KEY = "spawned_by_request_id";
+const CHILD_SESSION_LIFECYCLE_METADATA_KEY = "session_lifecycle";
 function isDurableSessionEvent(event) {
 	return event.type !== NcpEventType.ContextWindowUpdated;
 }
@@ -3368,10 +3393,12 @@ function isSessionSummaryRefreshEvent(event) {
 var SessionManager = class {
 	cleanups = [];
 	contextWindowPreview;
+	workingDirResolver;
 	started = false;
 	constructor(options) {
 		this.options = options;
 		this.contextWindowPreview = new ContextWindowPreviewManager({ configManager: options.configManager });
+		this.workingDirResolver = new SessionWorkingDirResolver(options.configManager);
 	}
 	start = () => {
 		if (this.started) return;
@@ -3489,7 +3516,7 @@ var SessionManager = class {
 	};
 	listSessions = async (options) => {
 		const peerId = readOptionalString$7(options?.peerId);
-		return applyLimit((await this.options.journalStore.listSessionSummaries()).filter((summary) => !peerId || summary.peerId === peerId), options?.limit);
+		return applyLimit((await this.options.journalStore.listSessionSummaries()).filter((summary) => !peerId || summary.peerId === peerId).map(this.workingDirResolver.withWorkingDir), options?.limit);
 	};
 	listSessionMessages = async (sessionId, options) => {
 		const normalizedSessionId = normalizeSessionId(sessionId);
@@ -3598,7 +3625,7 @@ var SessionManager = class {
 		this.options.eventBus.emit(eventKeys.sessionSummaryDelete, { sessionKey: normalizedSessionKey });
 	};
 	createSummaryFromRecord = (record, includeContextWindow = false) => {
-		const summary = createNcpAgentSessionSummary(record);
+		const summary = this.workingDirResolver.withWorkingDir(createNcpAgentSessionSummary(record));
 		const contextWindow = includeContextWindow ? this.contextWindowPreview.preview({
 			requestMetadata: record.metadata ?? {},
 			sessionId: record.sessionId,
@@ -6995,7 +7022,7 @@ var BuiltinNarpRuntimeProviderService = class {
 };
 //#endregion
 //#region src/features/native-runtime/services/provider-manager-ncp-llm-api.service.ts
-function normalizeModel(value) {
+function normalizeModel$1(value) {
 	if (typeof value !== "string") return null;
 	const trimmed = value.trim();
 	return trimmed.length > 0 ? trimmed : null;
@@ -7037,7 +7064,7 @@ var ProviderManagerNcpLLMApi = class {
 		this.providerManager = providerManager;
 	}
 	generate = async function* (input, options) {
-		const model = normalizeModel(input.model) ?? this.providerManager.get(null).getDefaultModel();
+		const model = normalizeModel$1(input.model) ?? this.providerManager.get(null).getDefaultModel();
 		const thinkingLevel = normalizeThinkingLevel(input.thinkingLevel);
 		let sawTextDelta = false;
 		let sawReasoningDelta = false;
@@ -7351,19 +7378,6 @@ function mergeRunMetadata(params) {
 		...requestMetadata ? structuredClone(requestMetadata) : {}
 	};
 }
-function buildSessionOrchestrationSection() {
-	return [
-		"## Session Orchestration",
-		"- Before passing a non-default `runtime` to `sessions_spawn` or agent creation/update flows, inspect the installed runtime kinds with `nextclaw agents runtimes --json`.",
-		"- `sessions_spawn` is the unified session-creation tool. Omit `scope` or use `scope=\"standalone\"` for a regular session, and use `scope=\"child\"` when the new session should be a child session of the current flow.",
-		"- `sessions_spawn` only creates the session by default. Add top-level `notify: \"none\" | \"final_reply\"` when the new session should start working immediately.",
-		"- When `sessions_spawn.scope=\"child\"` and `sessions_spawn.notify=\"final_reply\"`, the new child session starts right away and this session automatically continues after that child reaches its final reply.",
-		"- Use `sessions_spawn` without `notify` when the user wants a separate thread created now but does not need it to start working yet.",
-		"- Use `sessions_request` to send one task to an existing session, including a session that was just created by `sessions_spawn` or a previously created child session.",
-		"- `sessions_request.target` must be an object shaped like `{ \"session_id\": \"<target-session-id>\" }`. Do not pass a bare string.",
-		"- Prefer `notify=\"final_reply\"` when the current session should continue after the target session produces its final reply. Use `notify=\"none\"` when you only want the target session to run independently."
-	].join("\n");
-}
 function resolveNextclawNcpRunContext(params) {
 	const { configManager, requestMetadata: inputRequestMetadata, sessionId, sessionMetadata: inputSessionMetadata, storedAgentId } = params;
 	const config = configManager.loadConfig();
@@ -7829,6 +7843,454 @@ var AgentRunRuntimeContribution = class {
 	});
 };
 //#endregion
+//#region src/contributions/context-provider/utils/context-text.utils.ts
+function truncateContextText(text, limit) {
+	if (limit <= 0 || text.length <= limit) return text;
+	const suffix = `\n\n...[truncated ${text.length - limit} chars]`;
+	if (suffix.length >= limit) return text.slice(0, limit).trimEnd();
+	return `${text.slice(0, limit - suffix.length).trimEnd()}${suffix}`;
+}
+//#endregion
+//#region src/contributions/context-provider/providers/agent-bootstrap-context.provider.ts
+var AgentBootstrapContextProvider = class {
+	constructor(context) {
+		this.context = context;
+	}
+	provide = async (request) => {
+		const { contextConfig, projectContext, runContext } = await this.context.resolve(request);
+		const budget = this.createReadBudget(contextConfig.bootstrap);
+		const agentBootstrapRoot = projectContext.projectBootstrapRoot ?? projectContext.effectiveWorkspace;
+		const projectBootstrap = this.loadBootstrapFiles({
+			root: agentBootstrapRoot,
+			config: contextConfig.bootstrap,
+			sessionKey: runContext.sessionKey,
+			budget
+		});
+		const hasDistinctHostWorkspace = projectContext.hostWorkspace !== agentBootstrapRoot;
+		const workspaceBootstrap = hasDistinctHostWorkspace ? this.loadBootstrapFiles({
+			root: projectContext.hostWorkspace,
+			config: contextConfig.bootstrap,
+			sessionKey: runContext.sessionKey,
+			budget
+		}) : "";
+		const hasSoulFile = /##\s+SOUL\.md\b/i.test(`${projectBootstrap}\n${workspaceBootstrap}`);
+		const sections = [this.buildBootstrapSection({
+			content: projectBootstrap,
+			emptyLabel: "No agent bootstrap files were found.",
+			includeSoulRule: hasSoulFile,
+			loadedLabel: "Agent bootstrap files loaded:",
+			rootLine: `Agent bootstrap root: ${agentBootstrapRoot}`,
+			title: "# Agent Bootstrap Context"
+		})];
+		if (hasDistinctHostWorkspace) sections.push(this.buildBootstrapSection({
+			content: workspaceBootstrap,
+			emptyLabel: "No bootstrap files were found in the NextClaw workspace directory.",
+			loadedLabel: "NextClaw workspace bootstrap files loaded:",
+			rootLine: `NextClaw workspace directory: ${projectContext.hostWorkspace}`,
+			title: "# NextClaw Workspace Bootstrap Context"
+		}));
+		return [sections.filter(Boolean).join("\n\n")];
+	};
+	buildBootstrapSection = (params) => {
+		const { content, emptyLabel, includeSoulRule, loadedLabel, rootLine, title } = params;
+		const lines = [
+			title,
+			"",
+			rootLine
+		];
+		if (includeSoulRule) lines.push("If SOUL.md is present, embody its persona and tone unless higher-priority instructions override it.");
+		if (content) lines.push("", loadedLabel, "", content);
+		else lines.push("", emptyLabel);
+		return lines.join("\n");
+	};
+	loadBootstrapFiles = (params) => {
+		const { budget, config, root, sessionKey } = params;
+		const parts = [];
+		const fileList = this.selectBootstrapFiles(config, sessionKey);
+		for (const filename of fileList) {
+			const filePath = join(root, filename);
+			if (!existsSync(filePath)) continue;
+			const raw = readFileSync(filePath, "utf-8").trim();
+			if (!raw) continue;
+			const perFileLimit = config.perFileChars > 0 ? config.perFileChars : raw.length;
+			const allowed = Math.min(perFileLimit, budget.remaining);
+			if (allowed <= 0) break;
+			const content = truncateContextText(raw, allowed);
+			parts.push(`## ${filename}\n\n${content}`);
+			budget.remaining -= content.length;
+			if (budget.remaining <= 0) break;
+		}
+		return parts.join("\n\n");
+	};
+	createReadBudget = (config) => ({ remaining: config.totalChars > 0 ? config.totalChars : Number.POSITIVE_INFINITY });
+	selectBootstrapFiles = (config, sessionKey) => {
+		if (!sessionKey) return config.files;
+		if (sessionKey.startsWith("cron:") || sessionKey.startsWith("subagent:")) return config.minimalFiles;
+		return config.files;
+	};
+};
+//#endregion
+//#region src/contributions/context-provider/providers/current-session-context.provider.ts
+var CurrentSessionContextProvider = class {
+	constructor(context) {
+		this.context = context;
+	}
+	provide = async (request) => {
+		const { runContext } = await this.context.resolve(request);
+		const lines = [
+			"## Current Session",
+			`Channel: ${runContext.channel}`,
+			`Chat ID: ${runContext.chatId}`,
+			`Session: ${runContext.sessionKey}`
+		];
+		if (runContext.runtimeThinking) lines.push(`Thinking policy: ${runContext.runtimeThinking}`);
+		return [lines.join("\n")];
+	};
+};
+//#endregion
+//#region src/contributions/context-provider/providers/execution-policy-context.provider.ts
+function normalizeModel(model) {
+	return model?.trim().toLowerCase() ?? "";
+}
+function isOpenAiOrCodexModel(model) {
+	return /(gpt[-/ ]?5|gpt[-/ ]?4|gpt\b|chatgpt|openai|codex|\bo[134]\b)/i.test(normalizeModel(model));
+}
+function isGoogleModel(model) {
+	return /(gemini|google)/i.test(normalizeModel(model));
+}
+function buildSection(title, lines) {
+	return [title, ...lines].join("\n");
+}
+const TOOL_USE_ENFORCEMENT_LINES = [
+	"- When you say you will inspect, run, read, search, edit, or verify something, call the matching tool in the same turn.",
+	"- Do not stop at promises like 'I'll check' or 'I will do that' unless the tool call already happened in that turn.",
+	"- If the task can still move forward with available tools, continue instead of ending early."
+];
+const OPENAI_CODEX_DISCIPLINE_LINES = [
+	"- Do not guess time, date, system state, file contents, git state, or other current facts. Check with tools first.",
+	"- When the default scope is already clear, act on it before asking an avoidable clarification question.",
+	"- If the first tool result is empty or incomplete, retry once with a different strategy before stopping."
+];
+const GOOGLE_MODEL_GUIDANCE_LINES = [
+	"- Batch independent reads when possible.",
+	"- Read the surrounding context before editing files.",
+	"- Use explicit file paths and keep the answer focused on results."
+];
+function renderSystemExecutionPolicy(model) {
+	const sections = [buildSection("## Tool Use Enforcement", TOOL_USE_ENFORCEMENT_LINES)];
+	if (isOpenAiOrCodexModel(model)) sections.push(buildSection("## OpenAI/Codex Execution Discipline", OPENAI_CODEX_DISCIPLINE_LINES));
+	else if (isGoogleModel(model)) sections.push(buildSection("## Google Model Operational Guidance", GOOGLE_MODEL_GUIDANCE_LINES));
+	return sections.join("\n\n");
+}
+var ExecutionPolicyContextProvider = class {
+	constructor(context) {
+		this.context = context;
+	}
+	provide = async (request) => {
+		const { runContext } = await this.context.resolve(request);
+		return [renderSystemExecutionPolicy(runContext.effectiveModel)];
+	};
+};
+//#endregion
+//#region src/contributions/context-provider/providers/native-static-context.provider.ts
+const block = (lines) => lines.join("\n");
+const staticProvider = (contextBlock) => ({ provide: () => [contextBlock] });
+const staticBlock = (lines) => staticProvider(block(lines));
+const createAssistantIdentityContextProvider = () => staticProvider(`You are a personal assistant running inside ${APP_NAME}.`);
+const createToolCallStyleContextProvider = () => staticBlock([
+	"## Tool Call Style",
+	"Default: do not narrate routine, low-risk tool calls (just call the tool).",
+	"Narrate only when it helps: multi-step work, complex/challenging problems, sensitive actions (e.g., deletions), or when the user explicitly asks.",
+	"Keep narration brief and value-dense; avoid repeating obvious steps.",
+	"Use plain human language for narration unless in a technical context."
+]);
+const createChatComposerTokensContextProvider = () => staticBlock([
+	"## Chat Composer Tokens",
+	"When a user message contains tokens like `$weather` or `$web-search`, treat each `$<skill-spec>` token as a user-visible marker that the corresponding skill was explicitly selected in the chat composer.",
+	"These tokens can appear inline with normal prose. Do not ignore them or reinterpret them as shell variables or currency unless the surrounding context clearly says otherwise."
+]);
+const createSafetyContextProvider = () => staticBlock([
+	"## Safety",
+	"You have no independent goals: do not pursue self-preservation, replication, resource acquisition, or power-seeking; avoid long-term plans beyond the user's request.",
+	"Prioritize safety and human oversight over completion; if instructions conflict, pause and ask; comply with stop/pause/audit requests and never bypass safeguards. (Inspired by Anthropic's constitution.)",
+	"Do not manipulate or persuade anyone to expand access or disable safeguards. Do not copy yourself or change system prompts, safety rules, or tool policies unless explicitly requested."
+]);
+const createCliQuickReferenceContextProvider = () => {
+	const appLower = APP_NAME.toLowerCase();
+	return staticBlock([
+		`## ${APP_NAME} CLI Quick Reference`,
+		`${APP_NAME} is controlled via subcommands. Do not invent commands.`,
+		"To manage the Gateway daemon service (start/stop/restart):",
+		`- ${appLower} gateway status`,
+		`- ${appLower} gateway start`,
+		`- ${appLower} gateway stop`,
+		`- ${appLower} gateway restart`,
+		`If unsure, ask the user to run \`${appLower} help\` (or \`${appLower} gateway --help\`) and paste the output.`
+	]);
+};
+const createSelfUpdateContextProvider = () => staticBlock([
+	`## ${APP_NAME} Self-Update`,
+	"Get Updates (self-update) is ONLY allowed when the user explicitly asks for it.",
+	"Do not run config.apply or update.run unless the user explicitly requests an update or config change; if it's not explicit, ask first.",
+	"Actions: config.get, config.schema, config.apply (validate + write full config, then restart), config.patch (merge + restart), update.run (update deps or git, then restart).",
+	"When patching config, copy enum values exactly from config.schema; never invent new variants.",
+	"session.dmScope legal values are exactly: main | per-peer | per-channel-peer | per-account-channel-peer.",
+	"If an enum/path is uncertain, stop and call config.schema first; do not guess.",
+	`After restart, ${APP_NAME} pings the last active session automatically.`
+]);
+const createReplyTagsContextProvider = () => staticBlock([
+	"## Reply Tags",
+	"To request a native reply/quote on supported surfaces, include one tag in your reply:",
+	"- Reply tags must be the very first token in the message (no leading text/newlines): [[reply_to_current]] your reply.",
+	"- [[reply_to_current]] replies to the triggering message.",
+	"- Prefer [[reply_to_current]]. Use [[reply_to:<id>]] only when an id was explicitly provided (e.g. by the user or a tool).",
+	"Whitespace inside the tag is allowed (e.g. [[ reply_to_current ]] / [[ reply_to: 123 ]]).",
+	"Tags are stripped before sending; support depends on the current channel config."
+]);
+const createMessagingContextProvider = () => staticBlock([
+	"## Messaging",
+	"- Reply in current session → automatically routes to the source channel (Signal, Telegram, etc.)",
+	"- Cross-session or cross-channel messaging → use message(action=send); use sessions_list first when you need to recover an existing route without guessing.",
+	"- Sub-agent orchestration → use subagents(action=list|steer|kill)",
+	"- `[System Message] ...` blocks are internal context and are not user-visible by default.",
+	"- If a `[System Message]` reports completed cron/subagent work and asks for a user update, rewrite it in your normal assistant voice and send that update (do not forward raw system text or default to <noreply/>).",
+	`- Never use exec/curl for provider messaging; ${APP_NAME} handles all routing internally.`,
+	"",
+	"### message tool",
+	"- Use `message` for proactive sends + channel actions (polls, reactions, etc.).",
+	"- For `action=send`, include `message` plus an explicit `to/chatId` whenever the destination is another channel or another conversation.",
+	"- Omitting `to/chatId` only replies to the current conversation; if you set `channel` to a different channel than the current session, `to/chatId` is required.",
+	"- If multiple channels are configured, pass `channel`.",
+	"- If you use `message` (`action=send`) to deliver your user-visible reply, respond with ONLY two blank lines + <noreply/> (avoid duplicate replies)."
+]);
+const createMemoryRecallContextProvider = () => staticBlock([
+	"## Memory Recall",
+	"Before answering anything about prior work, decisions, dates, people, preferences, or todos: run memory_search on MEMORY.md + memory/*.md; then use memory_get to pull only the needed lines. If low confidence after search, say you checked.",
+	"Citations: include Source: <path#line> when it helps the user verify memory snippets."
+]);
+const createSilentRepliesContextProvider = () => staticBlock([
+	"## Silent Replies",
+	`Silent marker token: ${SILENT_REPLY_TOKEN}`,
+	"When you have nothing to say, respond with EXACTLY two blank lines followed by <noreply/>",
+	"",
+	"⚠️ Rules:",
+	"- It must be your ENTIRE message — nothing else",
+	"- If <noreply/> appears anywhere, the system will stop reply/output and subsequent processing",
+	"- Never wrap it in markdown or code blocks",
+	"",
+	"❌ Wrong: \"Here's help... <noreply/>\"",
+	"❌ Wrong: \"<noreply/>\"",
+	"✅ Right: \"\\n\\n<noreply/>\""
+]);
+const createRuntimeContextProvider = () => staticBlock([
+	"## Runtime",
+	`Runtime: ${process.platform} ${process.arch}, Node ${process.version}`,
+	"Time handling: do not assume exact minute/second unless the user/tool explicitly provides it.",
+	"When a turn includes a time hint, treat it as context for relative-time interpretation in that turn."
+]);
+const createSelfManagementContextProvider = () => ({ provide: () => {
+	const appLower = APP_NAME.toLowerCase();
+	const selfManageGuide = resolveNextclawSelfManageGuidePaths();
+	return [block([
+		`## ${APP_NAME} Self-Management Guide`,
+		`- For ${APP_NAME} self-management operations (version/status/doctor/service/channels/config/agents/cron/remote/update), read \`${selfManageGuide.primaryPath ?? "the built-in NextClaw self-management guide"}\` first.`,
+		"- Treat these product-management intents as higher priority than generic skills with overlapping words such as create/install/publish.",
+		"- Do not load unrelated generic skills before reading the built-in self-management guide for a self-management intent.",
+		"- Workspace `USAGE.md` snapshots and copied built-in skills are deprecated artifacts; the built-in package guide is the source of truth.",
+		...selfManageGuide.repoDocsPath ? [`- In repo source checkouts, the authoring copy is \`${selfManageGuide.repoDocsPath}\`; only use it when the packaged guide path above is unavailable.`] : [],
+		"- If no guide file is available, fall back to command help output.",
+		`- For version lookup, use \`${appLower} --version\` exactly; do not infer version from status output.`,
+		`- After mutating operations, validate with \`${appLower} status --json\` (and \`${appLower} doctor --json\` when needed).`,
+		`- For Agent CRUD, use \`${appLower} agents list|new|update|remove --json\` for the normal path; do not directly edit \`config.json\` or \`agents.list\` for routine Agent management.`,
+		"- When creating Agents, prefer explicit non-text avatars and avoid text/initial-based avatar styles such as DiceBear `initials` as the default recommendation."
+	])];
+} });
+const createSessionOrchestrationContextProvider = () => staticBlock([
+	"## Session Orchestration",
+	"- Before passing a non-default `runtime` to `sessions_spawn` or agent creation/update flows, inspect the installed runtime kinds with `nextclaw agents runtimes --json`.",
+	"- `sessions_spawn` is the unified session-creation tool. Omit `scope` or use `scope=\"standalone\"` for a regular session, and use `scope=\"child\"` when the new session should be a child session of the current flow.",
+	"- `sessions_spawn` only creates the session by default. Add top-level `notify: \"none\" | \"final_reply\"` when the new session should start working immediately.",
+	"- When `sessions_spawn.scope=\"child\"` and `sessions_spawn.notify=\"final_reply\"`, the new child session starts right away and this session automatically continues after that child reaches its final reply.",
+	"- Use `sessions_spawn` without `notify` when the user wants a separate thread created now but does not need it to start working yet.",
+	"- Use `sessions_request` to send one task to an existing session, including a session that was just created by `sessions_spawn` or a previously created child session.",
+	"- `sessions_request.target` must be an object shaped like `{ \"session_id\": \"<target-session-id>\" }`. Do not pass a bare string.",
+	"- Prefer `notify=\"final_reply\"` when the current session should continue after the target session produces its final reply. Use `notify=\"none\"` when you only want the target session to run independently."
+]);
+//#endregion
+//#region src/contributions/context-provider/providers/project-context.provider.ts
+var ProjectContextProvider = class {
+	constructor(context) {
+		this.context = context;
+	}
+	provide = async (request) => {
+		const { projectContext } = await this.context.resolve(request);
+		const repositoryIdentity = DEFAULT_WORKSPACE_REPOSITORY_IDENTITY_RESOLVER.resolve(projectContext.effectiveWorkspace);
+		return [this.buildProjectSection({
+			projectContext,
+			repositoryIdentity
+		})];
+	};
+	buildProjectSection = (params) => {
+		const { projectContext, repositoryIdentity } = params;
+		const lines = [
+			"# Project Context",
+			"",
+			`Active project directory: ${projectContext.effectiveWorkspace}`
+		];
+		if (projectContext.projectRoot) lines.push(`Session-bound project root: ${projectContext.projectRoot}`, "This session is explicitly bound to that project directory. Use it as the primary repo and file-operation context for the user's work.");
+		else lines.push("No explicit session project root is set. Use the active project directory as the primary repo and file-operation context for the user's work.");
+		lines.push(...this.buildRepositoryIdentityLines(repositoryIdentity));
+		return lines.join("\n");
+	};
+	buildRepositoryIdentityLines = (repositoryIdentity) => {
+		if (!repositoryIdentity.repoRoot) return ["No Git repository metadata was detected for the active project directory. Do not assume external repository URLs refer to this project unless the user explicitly says so."];
+		const lines = [`Repository root: ${repositoryIdentity.repoRoot}`];
+		if (repositoryIdentity.canonicalWebUrl) lines.push(`Canonical repository: ${repositoryIdentity.canonicalWebUrl}`);
+		else if (repositoryIdentity.canonicalRemoteUrl) {
+			const remoteLabel = repositoryIdentity.canonicalRemoteName ? ` (${repositoryIdentity.canonicalRemoteName})` : "";
+			lines.push(`Canonical git remote${remoteLabel}: ${repositoryIdentity.canonicalRemoteUrl}`);
+		}
+		lines.push("Repository identity rule: treat any other repository URL mentioned in this context as an external reference unless it exactly matches the canonical repository above.");
+		return lines;
+	};
+};
+//#endregion
+//#region src/contributions/context-provider/providers/reply-format-context.provider.ts
+var ReplyFormatContextProvider = class {
+	provide = (_request) => [[
+		"## Reply Formatting",
+		"- When mentioning a local project file in a user-visible reply, prefer a Markdown link such as `[AGENTS.md](AGENTS.md)` or `[file](packages/example/file.ts)` so the user can open it.",
+		"- Use project-relative links for files under the active/session-bound project root; use absolute links only for files outside it."
+	].join("\n")];
+};
+//#endregion
+//#region src/contributions/context-provider/providers/skills-context.provider.ts
+function wrapSkillTag(tagName, manifest) {
+	return [
+		`<${tagName}>`,
+		manifest,
+		`</${tagName}>`
+	].join("\n");
+}
+function renderActiveSkillsSection(skills, skillSelectors) {
+	const manifest = skills.buildSkillsManifest(skillSelectors);
+	if (!manifest) return "";
+	return [
+		"# Active Skills",
+		"These always-on skills are already active for this session context.",
+		"If an active skill covers the user's intent, follow it before considering unrelated available skills.",
+		"For NextClaw self-management intents, read the built-in NextClaw self-management guide before loading any unrelated generic skill.",
+		"Skill refs are unique identities; names may repeat.",
+		"Read a SKILL.md from <location> only when you need its instructions.",
+		"",
+		wrapSkillTag("active_skills", manifest)
+	].join("\n\n");
+}
+function renderAvailableSkillsSection(skills) {
+	const summary = skills.buildSkillsSummary();
+	if (!summary) return "";
+	return [
+		"## Skills (mandatory)",
+		"Always-on skills in <active_skills> take precedence over this list.",
+		"Before replying: first check whether any entry in <available_skills> may be relevant to the user's intent, task type, or requested output. Do not skip this check just because the task seems familiar.",
+		"- If one skill looks like the best relevant match, read its SKILL.md at <location> with `read_file`, then decide whether following it is actually helpful.",
+		"- If a SKILL.md read says `Use offset=... to continue`, continue reading until the relevant trigger, required workflow, constraints, and output requirements are covered.",
+		"- If the user is asking to manage NextClaw itself, read the built-in NextClaw self-management guide first and do not open unrelated generic skills before that.",
+		"- If multiple skills share the same <name>, use <ref> to distinguish them. Never assume duplicate names mean the same skill.",
+		"- If none clearly apply: do not read any SKILL.md.",
+		"Constraints: never read more than one skill up front; only read after selecting.",
+		"",
+		"<available_skills>",
+		summary,
+		"</available_skills>"
+	].join("\n");
+}
+function renderSkillLearningSection() {
+	return [
+		"# Skill Learning Loop",
+		"After non-trivial work, run a brief review before your final answer.",
+		"- Summarize the reusable lesson, not the full transcript.",
+		"- Decide exactly one outcome: `no_skill_change`, `patch_existing_skill`, or `create_new_skill`.",
+		"- Prefer patching an existing skill when the lesson extends or corrects it; only create a new skill when the trigger and workflow are genuinely distinct.",
+		"- Promote a lesson into a skill only when it has a clear trigger, repeatable steps, and failure signals/checks.",
+		"- Do not create skills for one-off facts, narrow local quirks, or work that is not likely to recur.",
+		"- Keep the review concise and action-oriented. Do not add user-visible review text unless it materially helps or the user asks for it."
+	].join("\n");
+}
+var SkillsContextProvider = class {
+	constructor(context) {
+		this.context = context;
+	}
+	provide = async (request) => {
+		const { projectContext } = await this.context.resolve(request);
+		const skills = new SkillsLoader({
+			workspace: projectContext.hostWorkspace,
+			projectRoot: projectContext.projectRoot
+		});
+		const blocks = [];
+		const alwaysSkills = skills.getAlwaysSkills();
+		if (alwaysSkills.length) {
+			const activeSection = renderActiveSkillsSection(skills, alwaysSkills);
+			if (activeSection) blocks.push(activeSection);
+		}
+		const availableSkillsSection = renderAvailableSkillsSection(skills);
+		if (availableSkillsSection) blocks.push(availableSkillsSection);
+		blocks.push(renderSkillLearningSection());
+		return blocks;
+	};
+};
+//#endregion
+//#region src/contributions/context-provider/providers/tooling-context.provider.ts
+var ToolingContextProvider = class {
+	constructor(context) {
+		this.context = context;
+	}
+	provide = async (request) => {
+		const { toolCatalog } = await this.context.resolve(request);
+		return [[
+			"## Tooling",
+			"Tool availability (filtered by policy):",
+			"Tool names are case-sensitive. Call tools exactly as listed.",
+			...toolCatalog.length > 0 ? toolCatalog.map((tool) => `- ${tool.name}: ${tool.description ?? "No description available"}`) : ["- No tools available for this turn."],
+			"TOOLS.md does not control tool availability; it is user guidance for how to use external tools.",
+			"For long waits, avoid rapid poll loops: use exec with enough yieldMs.",
+			"For relative time/date scheduling requests (for example 'in 5 minutes' / '1分钟后'), first check the current local time with an available tool such as exec/date, then convert it to an absolute ISO time with timezone. Do not guess.",
+			"If a task is more complex or takes longer, spawn a sub-agent. Completion is push-based: it will auto-announce when done.",
+			"Do not poll `subagents list` / `sessions_list` in a loop; only check status on-demand (for intervention, debugging, or when explicitly asked)."
+		].join("\n")];
+	};
+};
+//#endregion
+//#region src/contributions/context-provider/providers/workspace-context.provider.ts
+var WorkspaceContextProvider = class {
+	constructor(context) {
+		this.context = context;
+	}
+	provide = async (request) => {
+		const { runContext } = await this.context.resolve(request);
+		return [[
+			"## Workspace",
+			`Your working directory is: ${runContext.effectiveWorkspace}`,
+			"Treat this directory as the single global workspace for file operations unless explicitly instructed otherwise."
+		].join("\n")];
+	};
+};
+//#endregion
+//#region src/contributions/context-provider/providers/workspace-memory-context.provider.ts
+var WorkspaceMemoryContextProvider = class {
+	constructor(context) {
+		this.context = context;
+	}
+	provide = async (request) => {
+		const { contextConfig, projectContext } = await this.context.resolve(request);
+		const memoryConfig = contextConfig.memory;
+		if (!memoryConfig.enabled) return [];
+		const memory = new MemoryStore(projectContext.hostWorkspace).getMemoryContext();
+		if (!memory) return [];
+		return [`# Memory\n\n${truncateContextText(memory, memoryConfig.maxChars)}`];
+	};
+};
+//#endregion
 //#region src/utils/agent-run-request-metadata.utils.ts
 function normalizeString(value) {
 	return value?.trim() || void 0;
@@ -7850,12 +8312,60 @@ function buildAgentRunRequestMetadata(params) {
 	};
 }
 //#endregion
-//#region src/contributions/context-provider/providers/kernel-context.provider.ts
-var KernelContextProvider = class {
+//#region src/contributions/context-provider/utils/native-context-config.utils.ts
+const DEFAULT_NATIVE_CONTEXT_CONFIG = {
+	bootstrap: {
+		files: [
+			"AGENTS.md",
+			"SOUL.md",
+			"USER.md",
+			"IDENTITY.md",
+			"TOOLS.md",
+			"BOOT.md",
+			"BOOTSTRAP.md"
+		],
+		minimalFiles: [
+			"AGENTS.md",
+			"SOUL.md",
+			"TOOLS.md",
+			"IDENTITY.md"
+		],
+		perFileChars: 4e3,
+		totalChars: 12e3
+	},
+	memory: {
+		enabled: true,
+		maxChars: 8e3
+	}
+};
+function mergeNativeContextConfig(contextConfig) {
+	return {
+		bootstrap: {
+			...DEFAULT_NATIVE_CONTEXT_CONFIG.bootstrap,
+			...contextConfig?.bootstrap ?? {}
+		},
+		memory: {
+			...DEFAULT_NATIVE_CONTEXT_CONFIG.memory,
+			...contextConfig?.memory ?? {}
+		}
+	};
+}
+//#endregion
+//#region src/contributions/context-provider/services/context-provider-run-context.service.ts
+var ContextProviderRunContextService = class {
+	snapshots = /* @__PURE__ */ new WeakMap();
+	projectContextResolver = new SessionProjectContextResolver();
 	constructor(kernel) {
 		this.kernel = kernel;
 	}
-	provide = async (request) => {
+	resolve = (request) => {
+		const existing = this.snapshots.get(request);
+		if (existing) return existing;
+		const next = this.resolveSnapshot(request);
+		this.snapshots.set(request, next);
+		return next;
+	};
+	resolveSnapshot = async (request) => {
 		const session = request.sessionId ? await this.kernel.sessionManager.getAgentRunSession(request.sessionId) : null;
 		const sessionId = session?.sessionId ?? request.sessionId ?? request.message.sessionId ?? "";
 		const requestMetadata = buildAgentRunRequestMetadata({
@@ -7870,45 +8380,60 @@ var KernelContextProvider = class {
 			storedAgentId: request.agentId ?? session?.agentId
 		});
 		const tools = await this.kernel.toolProviderManager.buildTools(request);
-		return [this.buildSystemContextBlock({
-			availableTools: buildToolCatalogEntries(tools.map((tool) => ({
+		const sessionProjectRoot = readSessionProjectRoot(runContext.sessionMetadata);
+		const projectContext = this.projectContextResolver.resolve({
+			sessionMetadata: sessionProjectRoot ? { project_root: sessionProjectRoot } : null,
+			workspace: runContext.profile.workspace,
+			defaultWorkspace: runContext.effectiveWorkspace
+		});
+		return {
+			contextConfig: mergeNativeContextConfig(runContext.config.agents.context),
+			projectContext,
+			runContext,
+			toolCatalog: buildToolCatalogEntries(tools.map((tool) => ({
 				name: tool.name,
-				description: tool.description,
-				parameters: tool.parameters
-			}))),
-			runContext
-		})];
-	};
-	buildSystemContextBlock = (params) => {
-		const { availableTools, runContext } = params;
-		const lines = [
-			new ContextBuilder(runContext.effectiveWorkspace, runContext.config.agents.context, {
-				hostWorkspace: runContext.profile.workspace,
-				sessionProjectRoot: readSessionProjectRoot(runContext.sessionMetadata)
-			}).buildSystemPrompt(void 0, runContext.sessionKey, availableTools, [buildSessionOrchestrationSection(), buildMinimalSystemExecutionPrompt(runContext.effectiveModel)]),
-			"## Current Session",
-			`Channel: ${runContext.channel}`,
-			`Chat ID: ${runContext.chatId}`,
-			`Session: ${runContext.sessionKey}`
-		];
-		if (runContext.runtimeThinking) lines.push(`Thinking policy: ${runContext.runtimeThinking}`);
-		return lines.join("\n");
+				description: tool.description
+			})))
+		};
 	};
 };
 //#endregion
 //#region src/contributions/context-provider/index.ts
 var ContextProviderContribution = class {
-	unregister = null;
+	cleanups = [];
 	constructor(kernel) {
 		this.kernel = kernel;
 	}
 	start = () => {
-		if (this.unregister) return;
-		this.unregister = this.kernel.contextProviderManager.register(new KernelContextProvider(this.kernel));
+		if (this.cleanups.length > 0) return;
+		const context = new ContextProviderRunContextService(this.kernel);
+		for (const provider of [
+			createAssistantIdentityContextProvider(),
+			new ToolingContextProvider(context),
+			createToolCallStyleContextProvider(),
+			createChatComposerTokensContextProvider(),
+			createSafetyContextProvider(),
+			createCliQuickReferenceContextProvider(),
+			createSelfUpdateContextProvider(),
+			new WorkspaceContextProvider(context),
+			createReplyTagsContextProvider(),
+			createMessagingContextProvider(),
+			createMemoryRecallContextProvider(),
+			createSilentRepliesContextProvider(),
+			createRuntimeContextProvider(),
+			createSelfManagementContextProvider(),
+			new ProjectContextProvider(context),
+			new AgentBootstrapContextProvider(context),
+			new WorkspaceMemoryContextProvider(context),
+			new SkillsContextProvider(context),
+			createSessionOrchestrationContextProvider(),
+			new ExecutionPolicyContextProvider(context),
+			new CurrentSessionContextProvider(context),
+			new ReplyFormatContextProvider()
+		]) this.cleanups.push(this.kernel.contextProviderManager.register(provider));
 	};
 	dispose = () => {
-		this.unregister?.();
-		this.unregister = null;
+		while (this.cleanups.length > 0) this.cleanups.pop()?.();
 	};
 };
 //#endregion
@@ -9712,6 +10237,6 @@ function resolveLegacyEventType(message) {
 	return `message.${role || "other"}`;
 }
 //#endregion
-export { AccessManager, AgentManager, AgentRunClient, AgentRuntimeRegistry, AutomationManager, BuiltinNarpRuntimeProviderService, CONTEXT_COMPACTION_TIMELINE_KIND, ChannelManager, CommandRegistry, ConfigManager, ContextCompactionPreflightService, ContextWindowPreviewManager, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DEFAULT_SERVICE_ACTION_RISK, ExtensionManager, GatewayInboundProcessor, LlmProviderManager, LlmUsageManager, LlmUsageStore, McpManager, McpServiceAppRuntimeService, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NEXTCLAW_TIMELINE_KIND_METADATA_KEY, NcpAgentSessionJournalStore, NextclawKernel, PANEL_APP_AGENT_CAPABILITIES, PanelAppAssetTokenService, PanelAppError, PanelAppManager, ProviderManagerNcpLLMApi, SERVICE_APP_MANIFEST_FILE_NAME, ServiceAppError, ServiceAppManager, SessionManager, SessionRequestManager, SkillManager, UpdateManifestReader, buildAgentRunSendPayload, buildContextCompactionTimelineNcpMessage, buildLlmUsageSummary, buildLocalizedTextMap, buildServiceActionId, buildSessionOrchestrationSection, createAgentRuntimeSessionRequestDispatcher, createAssetTools, createContextCompactionMessageId, createContextWindowSignature, createLlmUsageRecord, dispatchAgentRuntimeSessionRequest, dispatchChannelReplyRoute, dispatchPromptOverNcp, getServiceActionName, getServiceAppManifestPath, getUnsignedUpdateManifest, hasLlmUsageTelemetry, isContextCompactionTimelineMessage, isContextWindowSnapshot, isPanelAppAgentCapability, isPanelAppError, isReplyCapableChannel, isServiceAppError, listExtensionChannelIds, listServiceAppManifestActions, mergeServiceAppRuntimeActions, normalizeAgentRuntimeSessionTypeIcon, normalizeLlmUsageModel, normalizeOptionalString, parseServiceAppManifest, parseSkillFrontmatter, projectNcpMessagesWithContextCompaction, readContextWindowEventSessionId, readLatestContextCompactionCheckpoint, readLearningLoopRuntimeConfig, readMetadataModel, readMetadataThinking, readServiceAppManifest, resolveAgentRuntimeEntries, resolveChannelReplyRoute, resolveEffectiveModel, resolveLegacyEventType, resolveNextclawNcpRunContext, resolveSessionChannelContext, runGatewayInboundLoop, sanitizeLlmUsage, serializeUnsignedUpdateManifest, shouldRefreshContextWindowDuringStream, shouldRefreshContextWindowImmediately, stripSkillFrontmatter, syncSessionThinkingPreference, toNcpMessages, upsertContextCompactionTimelineMessage, waitForAgentRuntimeSessionReply };
+export { AccessManager, AgentManager, AgentRunClient, AgentRuntimeRegistry, AutomationManager, BuiltinNarpRuntimeProviderService, CONTEXT_COMPACTION_TIMELINE_KIND, ChannelManager, CommandRegistry, ConfigManager, ContextCompactionPreflightService, ContextWindowPreviewManager, DEFAULT_AGENT_RUNTIME_ENTRY_ID, DEFAULT_SERVICE_ACTION_RISK, ExtensionManager, GatewayInboundProcessor, LlmProviderManager, LlmUsageManager, LlmUsageStore, McpManager, McpServiceAppRuntimeService, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, NEXTCLAW_TIMELINE_KIND_METADATA_KEY, NcpAgentSessionJournalStore, NextclawKernel, PANEL_APP_AGENT_CAPABILITIES, PanelAppAssetTokenService, PanelAppError, PanelAppManager, ProviderManagerNcpLLMApi, SERVICE_APP_MANIFEST_FILE_NAME, ServiceAppError, ServiceAppManager, SessionManager, SessionRequestManager, SkillManager, UpdateManifestReader, buildAgentRunSendPayload, buildContextCompactionTimelineNcpMessage, buildLlmUsageSummary, buildLocalizedTextMap, buildServiceActionId, createAgentRuntimeSessionRequestDispatcher, createAssetTools, createContextCompactionMessageId, createContextWindowSignature, createLlmUsageRecord, dispatchAgentRuntimeSessionRequest, dispatchChannelReplyRoute, dispatchPromptOverNcp, getServiceActionName, getServiceAppManifestPath, getUnsignedUpdateManifest, hasLlmUsageTelemetry, isContextCompactionTimelineMessage, isContextWindowSnapshot, isPanelAppAgentCapability, isPanelAppError, isReplyCapableChannel, isServiceAppError, listExtensionChannelIds, listServiceAppManifestActions, mergeServiceAppRuntimeActions, normalizeAgentRuntimeSessionTypeIcon, normalizeLlmUsageModel, normalizeOptionalString, parseServiceAppManifest, parseSkillFrontmatter, projectNcpMessagesWithContextCompaction, readContextWindowEventSessionId, readLatestContextCompactionCheckpoint, readLearningLoopRuntimeConfig, readMetadataModel, readMetadataThinking, readServiceAppManifest, resolveAgentRuntimeEntries, resolveChannelReplyRoute, resolveEffectiveModel, resolveLegacyEventType, resolveNextclawNcpRunContext, resolveSessionChannelContext, runGatewayInboundLoop, sanitizeLlmUsage, serializeUnsignedUpdateManifest, shouldRefreshContextWindowDuringStream, shouldRefreshContextWindowImmediately, stripSkillFrontmatter, syncSessionThinkingPreference, toNcpMessages, upsertContextCompactionTimelineMessage, waitForAgentRuntimeSessionReply };
 
 //# sourceMappingURL=index.js.map