@gajae-code/coding-agent 0.2.2 → 0.2.4

package/src/slash-commands/builtin-registry.ts

@@ -16,10 +16,12 @@ import type { InteractiveModeContext } from "../modes/types";
 import { formatModelOnboardingGuidance } from "../setup/model-onboarding-guidance";
 import {
 	addApiCompatibleProvider,
+	formatProviderPresetList,
 	formatProviderSetupResult,
 	parseProviderCompatibility,
 } from "../setup/provider-onboarding";
 import { parseThinkingLevel } from "../thinking";
+import { buildContextReportText } from "./helpers/context-report";
 import { formatDuration } from "./helpers/format";
 import { commandConsumed, errorMessage, parseSlashCommand, usage } from "./helpers/parse";
 import { handleSshAcp } from "./helpers/ssh";
@@ -39,6 +41,7 @@ export type { BuiltinSlashCommand, SubcommandDef } from "./types";
 export type BuiltinSlashCommandRuntime = TuiSlashCommandRuntime;
 
 function parseProviderSetupSlashArgs(args: string): {
+	preset?: string;
 	compat?: string;
 	provider?: string;
 	baseUrl?: string;
@@ -49,6 +52,7 @@ function parseProviderSetupSlashArgs(args: string): {
 } {
 	const tokens = args.split(/\s+/).filter(Boolean);
 	const result: {
+		preset?: string;
 		compat?: string;
 		provider?: string;
 		baseUrl?: string;
@@ -67,9 +71,16 @@ function parseProviderSetupSlashArgs(args: string): {
 			result.force = true;
 			continue;
 		}
+		if (!token.startsWith("-") && !result.preset) {
+			result.preset = token;
+			continue;
+		}
 		const value = tokens[i + 1];
 		if (!value) continue;
-		if (token === "--compat") {
+		if (token === "--preset") {
+			result.preset = value;
+			i += 1;
+		} else if (token === "--compat") {
 			result.compat = value;
 			i += 1;
 		} else if (token === "--provider") {
@@ -95,7 +106,10 @@ function parseProviderSetupSlashArgs(args: string): {
 function providerSetupUsage(): string {
 	return [
 		"Provider onboarding",
+		"Presets: /provider add --preset <minimax|minimax-cn|glm> [--force]",
+		"Aliases: /provider add minimax, /provider add minimax-cn, /provider add glm, /provider add zai (writes glm-proxy)",
 		"API providers: /provider add --compat <openai|anthropic> --provider <id> --base-url <url> --api-key-env <ENV> --model <model> [--force]",
+		`Available presets:\n${formatProviderPresetList()}`,
 		"OAuth/subscription providers: /provider login [provider-id] or /login [provider-id]",
 		"Headless OAuth callbacks can be pasted with /login <redirect URL or code>.",
 	].join("\n");
@@ -202,6 +216,14 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "theme",
+		description: "Open theme selector",
+		handleTui: (_command, runtime) => {
+			runtime.ctx.showThemeSelector();
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "goal",
 		description: "Toggle goal mode (persistent autonomous objective for this session)",
@@ -503,6 +525,19 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			runtime.ctx.editor.setText("");
 		},
 	},
+	{
+		name: "context",
+		description: "Show active context token usage breakdown",
+		acpDescription: "Show active context token usage breakdown",
+		handle: async (_command, runtime) => {
+			await runtime.output(buildContextReportText(runtime));
+			return commandConsumed();
+		},
+		handleTui: (_command, runtime) => {
+			runtime.ctx.handleContextCommand();
+			runtime.ctx.editor.setText("");
+		},
+	},
 	{
 		name: "usage",
 		description: "Show provider usage and limits",
@@ -580,20 +615,30 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 			if (!args.startsWith("add ")) return usage(providerSetupUsage(), runtime);
 			const parsed = parseProviderSetupSlashArgs(args.slice(4));
 			const missing: string[] = [];
-			if (!parsed.compat) missing.push("--compat");
-			if (!parsed.provider) missing.push("--provider");
-			if (!parsed.baseUrl) missing.push("--base-url");
+			if (!parsed.preset) {
+				if (!parsed.compat) missing.push("--compat");
+				if (!parsed.provider) missing.push("--provider");
+				if (!parsed.baseUrl) missing.push("--base-url");
+			}
 			if (parsed.rejectedRawApiKey) {
 				return usage("Provider setup rejects raw --api-key values; use --api-key-env <ENV> instead.", runtime);
 			}
-			if (!parsed.apiKeyEnv) missing.push("--api-key-env");
-			if (parsed.models.length === 0) missing.push("--model");
-			if (missing.length > 0) return usage(`Missing required option(s): ${missing.join(", ")}`, runtime);
+			if (!parsed.preset) {
+				if (!parsed.apiKeyEnv) missing.push("--api-key-env");
+				if (parsed.models.length === 0) missing.push("--model");
+			}
+			if (missing.length > 0) {
+				return usage(
+					`Missing required option(s): ${missing.join(", ")}. Or use /provider add --preset <preset>.`,
+					runtime,
+				);
+			}
 			try {
 				const result = await addApiCompatibleProvider({
-					compatibility: parseProviderCompatibility(parsed.compat!),
-					providerId: parsed.provider!,
-					baseUrl: parsed.baseUrl!,
+					compatibility: parsed.compat ? parseProviderCompatibility(parsed.compat) : undefined,
+					preset: parsed.preset,
+					providerId: parsed.provider,
+					baseUrl: parsed.baseUrl,
 					apiKeyEnv: parsed.apiKeyEnv,
 					models: parsed.models,
 					force: parsed.force,
@@ -631,9 +676,10 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 						throw new Error("Provider setup rejects raw --api-key values; use --api-key-env <ENV> instead.");
 					}
 					const result = await addApiCompatibleProvider({
-						compatibility: parseProviderCompatibility(parsed.compat ?? ""),
-						providerId: parsed.provider ?? "",
-						baseUrl: parsed.baseUrl ?? "",
+						compatibility: parsed.compat ? parseProviderCompatibility(parsed.compat) : undefined,
+						preset: parsed.preset,
+						providerId: parsed.provider,
+						baseUrl: parsed.baseUrl,
 						apiKeyEnv: parsed.apiKeyEnv,
 						models: parsed.models,
 						force: parsed.force,
@@ -885,7 +931,9 @@ const BUILTIN_SLASH_COMMAND_REGISTRY: ReadonlyArray<SlashCommandSpec> = [
 						runtime.settings,
 						runtime.session,
 					);
-					await runtime.output(payload || "Memory payload is empty.");
+					await runtime.output(
+						payload || "Memory payload is empty; durable memory is unavailable or unconfirmed.",
+					);
 					return commandConsumed();
 				}
 				case "clear":

package/src/slash-commands/helpers/context-report.ts

@@ -1,7 +1,88 @@
+import type { AgentMessage } from "@gajae-code/agent-core";
+import { type CompactionSettings, calculatePromptTokens } from "@gajae-code/agent-core/compaction";
+import type { AssistantMessage, Usage } from "@gajae-code/ai";
 import { computeContextBreakdown } from "../../modes/utils/context-usage";
+import type { CompactionEntry, SessionEntry } from "../../session/session-manager";
 import type { SlashCommandRuntime } from "../types";
 import { renderAsciiBar } from "./format";
 
+interface ActiveHistorySummary {
+	activeMessages: readonly AgentMessage[];
+	rawBranchMessages: number;
+	rawBranchEntries: number;
+	compaction: CompactionEntry | undefined;
+	compactedRawMessages: number | undefined;
+}
+
+function isMessageEntry(entry: SessionEntry): boolean {
+	return entry.type === "message" || entry.type === "custom_message" || entry.type === "branch_summary";
+}
+
+function summarizeActiveHistory(runtime: SlashCommandRuntime): ActiveHistorySummary {
+	const activeContext = runtime.sessionManager.buildSessionContext();
+	const branch = runtime.sessionManager.getBranch();
+	let compaction: CompactionEntry | undefined;
+	let compactionIndex = -1;
+	for (let i = branch.length - 1; i >= 0; i--) {
+		const entry = branch[i];
+		if (entry.type === "compaction") {
+			compaction = entry;
+			compactionIndex = i;
+			break;
+		}
+	}
+
+	const rawBranchMessages = branch.filter(isMessageEntry).length;
+	let compactedRawMessages: number | undefined;
+	if (compaction) {
+		const firstKeptIndex = branch.findIndex(entry => entry.id === compaction?.firstKeptEntryId);
+		if (firstKeptIndex >= 0 && compactionIndex >= 0) {
+			compactedRawMessages = branch.slice(0, firstKeptIndex).filter(isMessageEntry).length;
+		}
+	}
+
+	return {
+		activeMessages: activeContext.messages,
+		rawBranchMessages,
+		rawBranchEntries: branch.length,
+		compaction,
+		compactedRawMessages,
+	};
+}
+
+function findLastAssistantUsage(messages: readonly AgentMessage[]):
+	| {
+			message: AssistantMessage;
+			usage: Usage;
+	  }
+	| undefined {
+	for (let i = messages.length - 1; i >= 0; i--) {
+		const message = messages[i];
+		if (message.role === "assistant") {
+			const assistant = message as AssistantMessage;
+			return { message: assistant, usage: assistant.usage };
+		}
+	}
+	return undefined;
+}
+
+function formatUnknownNumber(value: number | undefined): string {
+	return value === undefined ? "unknown" : value.toLocaleString();
+}
+
+function formatTokenLine(label: string, tokens: number, contextWindow: number): string {
+	const fraction = contextWindow > 0 ? tokens / contextWindow : 0;
+	return `  ${label.padEnd(16)} ${renderAsciiBar(fraction)}  ${tokens.toLocaleString()} tokens`;
+}
+
+function formatReserveText(runtime: SlashCommandRuntime, contextWindow: number, reserveTokens: number): string {
+	if (contextWindow <= 0) return "unknown";
+	if (reserveTokens > 0) return `${reserveTokens.toLocaleString()} tokens`;
+	const compaction = runtime.settings.getGroup("compaction") as CompactionSettings;
+	if (!compaction.enabled || compaction.strategy === "off") return "none configured";
+	return "unknown";
+}
+
 /**
  * Build the `/context` ACP-mode text. Tries the rich breakdown first
  * (categories + auto-compact buffer + free slack) and falls back to the
@@ -9,31 +90,60 @@ import { renderAsciiBar } from "./format";
  */
 export function buildContextReportText(runtime: SlashCommandRuntime): string {
 	try {
-		const breakdown = computeContextBreakdown(runtime.session);
+		const history = summarizeActiveHistory(runtime);
+		const breakdown = computeContextBreakdown(runtime.session, { messages: history.activeMessages });
 		if (breakdown.contextWindow <= 0) {
 			return "Context usage is unavailable: no model is selected for this session.";
 		}
-		const usedPct = Math.round((breakdown.usedTokens / breakdown.contextWindow) * 100);
-		const lines = [`Context window: ${breakdown.contextWindow} tokens (${usedPct}% used)`];
+		const promptUsage = findLastAssistantUsage(history.activeMessages);
+		const usedPct = (breakdown.usedTokens / breakdown.contextWindow) * 100;
+		const lines = [
+			"Context usage",
+			`Model: ${breakdown.model?.provider ?? "unknown"}/${breakdown.model?.id ?? "unknown"}`,
+			`Active context: ${breakdown.usedTokens.toLocaleString()} / ${breakdown.contextWindow.toLocaleString()} tokens (${usedPct.toFixed(1)}% used)`,
+			`Reserve: ${formatReserveText(runtime, breakdown.contextWindow, breakdown.autoCompactBufferTokens)}`,
+			"",
+			"Active context breakdown (estimated)",
+		];
 		for (const category of breakdown.categories) {
-			if (category.tokens === 0) continue;
-			const fraction = category.tokens / breakdown.contextWindow;
-			lines.push(`  ${category.label.padEnd(16)} ${renderAsciiBar(fraction)}  ${category.tokens} tokens`);
+			lines.push(formatTokenLine(category.label, category.tokens, breakdown.contextWindow));
 		}
 		if (breakdown.autoCompactBufferTokens > 0) {
-			const fraction = breakdown.autoCompactBufferTokens / breakdown.contextWindow;
+			lines.push(formatTokenLine("Reserve", breakdown.autoCompactBufferTokens, breakdown.contextWindow));
+		}
+		lines.push(formatTokenLine("Free", breakdown.freeTokens, breakdown.contextWindow));
+		lines.push(
+			"",
+			"History",
+			`Active messages sent next turn: ${history.activeMessages.length.toLocaleString()}`,
+			`Raw branch history: ${history.rawBranchMessages.toLocaleString()} message entries / ${history.rawBranchEntries.toLocaleString()} total entries`,
+			history.compaction
+				? `Compacted history: summary active; compacted raw messages: ${formatUnknownNumber(history.compactedRawMessages)}; tokens before compaction: ${history.compaction.tokensBefore.toLocaleString()}`
+				: "Compacted history: none on active branch",
+			"",
+			"Last recorded provider turn",
+		);
+		if (promptUsage) {
 			lines.push(
-				`  ${"Auto-compact buf".padEnd(16)} ${renderAsciiBar(fraction)}  ${breakdown.autoCompactBufferTokens} tokens`,
+				`Model: ${promptUsage.message.provider}/${promptUsage.message.model}`,
+				`Prompt tokens: ${calculatePromptTokens(promptUsage.usage).toLocaleString()}`,
+				`Input/output/cache: ${promptUsage.usage.input.toLocaleString()} / ${promptUsage.usage.output.toLocaleString()} / ${(
+					promptUsage.usage.cacheRead + promptUsage.usage.cacheWrite
+				).toLocaleString()}`,
+				`Cost: $${promptUsage.usage.cost.total.toFixed(6)}`,
 			);
-		}
-		if (breakdown.freeTokens > 0) {
-			const fraction = breakdown.freeTokens / breakdown.contextWindow;
-			lines.push(`  ${"Free".padEnd(16)} ${renderAsciiBar(fraction)}  ${breakdown.freeTokens} tokens`);
+		} else {
+			lines.push("Usage/cost: unknown (no assistant response with recorded provider usage yet)");
 		}
 		return lines.join("\n");
 	} catch {
 		const fallback = runtime.session.getContextUsage();
 		if (!fallback) return "Context usage is unavailable.";
-		return ["Context", `Window: ${fallback.contextWindow}`, `Used: ${fallback.tokens ?? 0}`].join("\n");
+		return [
+			"Context usage",
+			`Active context: ${fallback.tokens === null || fallback.tokens === undefined ? "unknown" : fallback.tokens.toLocaleString()}`,
+			`Context window: ${fallback.contextWindow.toLocaleString()}`,
+			"Breakdown: unknown",
+		].join("\n");
 	}
 }

package/src/task/agents.ts

@@ -29,6 +29,7 @@ interface AgentFrontmatter {
 	thinkingLevel?: string;
 	blocking?: boolean;
 	hide?: boolean;
+	forkContext?: "forbidden" | "allowed";
 }
 
 interface EmbeddedAgentDef {

package/src/task/executor.ts

@@ -23,7 +23,7 @@ import subagentSystemPromptTemplate from "../prompts/system/subagent-system-prom
 import submitReminderTemplate from "../prompts/system/subagent-yield-reminder.md" with { type: "text" };
 import { AgentRegistry } from "../registry/agent-registry";
 import { createAgentSession, discoverAuthStorage } from "../sdk";
-import type { AgentSession, AgentSessionEvent } from "../session/agent-session";
+import type { AgentSession, AgentSessionEvent, ForkContextSeed } from "../session/agent-session";
 import type { ArtifactManager } from "../session/artifacts";
 import type { AuthStorage } from "../session/auth-storage";
 import { SKILL_PROMPT_MESSAGE_TYPE } from "../session/messages";
@@ -157,6 +157,7 @@ export interface ExecutorOptions {
 	parentTelemetry?: AgentTelemetryConfig;
 	/** Skills to autoload via sendCustomMessage before the first prompt */
 	autoloadSkills?: Skill[];
+	forkContextSeed?: ForkContextSeed;
 }
 
 function parseStringifiedJson(value: unknown): unknown {
@@ -1143,6 +1144,10 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 
 			const { normalized: normalizedOutputSchema } = normalizeSchema(outputSchema);
 
+			const forkContextNotice = options.forkContextSeed
+				? `This subagent was started with a forked snapshot of the parent conversation. Included ${options.forkContextSeed.metadata.includedMessages} message(s), skipped ${options.forkContextSeed.metadata.skippedMessages}, approximately ${options.forkContextSeed.metadata.approximateTokens} tokens. The snapshot is not live; use IRC for live coordination when enabled.`
+				: "";
+
 			const { session } = await awaitAbortable(
 				createAgentSession({
 					cwd: worktree ?? cwd,
@@ -1167,6 +1172,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 							contextFile: contextFileForPrompt,
 							ircPeers: ircEnabled ? renderIrcPeerRoster(id) : "",
 							ircSelfId: ircEnabled ? id : "",
+							forkContext: forkContextNotice,
 						});
 						return defaultPrompt.length === 0
 							? [subagentPrompt]
@@ -1185,6 +1191,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 					enableMCP,
 					localProtocolOptions: options.localProtocolOptions,
 					telemetry: subagentTelemetry,
+					forkContextSeed: options.forkContextSeed,
 				}),
 			);
 
@@ -1215,6 +1222,7 @@ export async function runSubprocess(options: ExecutorOptions): Promise<SingleRes
 				task,
 				tools: session.getActiveToolNames(),
 				outputSchema,
+				forkContext: options.forkContextSeed?.metadata,
 			});
 
 			abortSignal.addEventListener(

package/src/task/index.ts

@@ -16,7 +16,7 @@ import * as fs from "node:fs/promises";
 import * as os from "node:os";
 import path from "node:path";
 import type { AgentTool, AgentToolResult, AgentToolUpdateCallback } from "@gajae-code/agent-core";
-import type { Usage } from "@gajae-code/ai";
+import type { Model, Usage } from "@gajae-code/ai";
 import { $env, prompt, Snowflake } from "@gajae-code/utils";
 import type { ToolSession } from "..";
 import { AsyncJobManager } from "../async";
@@ -26,12 +26,15 @@ import planModeSubagentPrompt from "../prompts/system/plan-mode-subagent.md" wit
 import subagentUserPromptTemplate from "../prompts/system/subagent-user-prompt.md" with { type: "text" };
 import taskDescriptionTemplate from "../prompts/tools/task.md" with { type: "text" };
 import taskSummaryTemplate from "../prompts/tools/task-summary.md" with { type: "text" };
+import type { ForkContextSeed } from "../session/agent-session";
 import { formatBytes, formatDuration } from "../tools/render-utils";
 import {
 	type AgentDefinition,
 	type AgentProgress,
+	type ForkContextPolicy,
 	getTaskSchema,
 	type SingleResult,
+	type TaskItem,
 	type TaskParams,
 	type TaskToolDetails,
 	type TaskToolSchemaInstance,
@@ -203,6 +206,33 @@ function validateTaskModeParams(simpleMode: TaskSimpleMode, params: TaskParams):
 	return "task.simple is set to independent, so the task tool does not accept `context` or `schema`. Put all required background and output expectations inside each task assignment or the selected agent definition.";
 }
 
+function getForkContextPolicy(agent: AgentDefinition): ForkContextPolicy {
+	return agent.forkContext ?? "forbidden";
+}
+
+function validateForkContextRequests(
+	tasks: readonly TaskItem[],
+	agent: AgentDefinition,
+	forkContextEnabled: boolean,
+): string | undefined {
+	const requested = tasks.filter(task => task.inheritContext === true);
+	if (requested.length === 0) return undefined;
+	const taskIds = requested.map(task => task.id).join(", ");
+	if (!forkContextEnabled) {
+		return `Cannot inherit parent context for task(s) ${taskIds}: task.forkContext.enabled is false.`;
+	}
+	if (getForkContextPolicy(agent) !== "allowed") {
+		return `Cannot inherit parent context for task(s) ${taskIds}: agent '${agent.name}' does not declare forkContext: allowed.`;
+	}
+	return undefined;
+}
+
+function resolveForkContextMaxTokens(configured: number, model: Model | undefined): number {
+	if (configured > 0) return Math.trunc(configured);
+	const contextWindow = model?.contextWindow ?? 0;
+	return contextWindow > 0 ? Math.max(1, Math.floor(contextWindow * 0.25)) : 25_000;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Tool Class
 // ═══════════════════════════════════════════════════════════════════════════
@@ -314,6 +344,15 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			};
 		}
 
+		const forkContextValidationError = validateForkContextRequests(
+			taskItems,
+			agent,
+			this.session.settings.get("task.forkContext.enabled"),
+		);
+		if (forkContextValidationError) {
+			return createTaskModeError(forkContextValidationError);
+		}
+
 		const manager = AsyncJobManager.instance();
 		if (!manager) {
 			return {
@@ -378,6 +417,20 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 
 		const maxConcurrency = this.session.settings.get("task.maxConcurrency");
 		const semaphore = new Semaphore(maxConcurrency);
+		const buildForkContextSeedForTask = async (task: TaskItem): Promise<ForkContextSeed | undefined> => {
+			if (task.inheritContext !== true) return undefined;
+			if (!this.session.buildForkContextSeed) {
+				throw new Error("Current session cannot build fork-context seeds.");
+			}
+			const maxMessages = this.session.settings.get("task.forkContext.maxMessages");
+			const configuredMaxTokens = this.session.settings.get("task.forkContext.maxTokens");
+			return await this.session.buildForkContextSeed({
+				maxMessages,
+				maxTokens: resolveForkContextMaxTokens(configuredMaxTokens, this.session.model),
+				signal,
+			});
+		};
+		const frozenForkSeeds = new Map<string, ForkContextSeed>();
 
 		for (let i = 0; i < taskItems.length; i++) {
 			const taskItem = taskItems[i];
@@ -391,6 +444,8 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			}
 
 			const uniqueId = uniqueIds[i];
+			const frozenForkSeed = await buildForkContextSeedForTask(taskItem);
+			if (frozenForkSeed) frozenForkSeeds.set(uniqueId, frozenForkSeed);
 			const singleParams: TaskParams = { ...params, tasks: [taskItem] };
 			const label = uniqueId;
 			try {
@@ -416,9 +471,14 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 							buildAsyncDetails("running", startedJobs[0]?.jobId ?? label) as unknown as Record<string, unknown>,
 						);
 						try {
-							const result = await this.#executeSync(_toolCallId, singleParams, runSignal, undefined, [
-								uniqueId,
-							]);
+							const result = await this.#executeSync(
+								_toolCallId,
+								singleParams,
+								runSignal,
+								undefined,
+								[uniqueId],
+								frozenForkSeeds,
+							);
 							const finalText = result.content.find(part => part.type === "text")?.text ?? "(no output)";
 							const singleResult = result.details?.results[0];
 							if (progress) {
@@ -576,6 +636,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 		signal?: AbortSignal,
 		onUpdate?: AgentToolUpdateCallback<TaskToolDetails>,
 		preAllocatedIds?: string[],
+		prebuiltForkContextSeeds?: ReadonlyMap<string, ForkContextSeed>,
 	): Promise<AgentToolResult<TaskToolDetails>> {
 		const startTime = Date.now();
 		const { agents, projectAgentsDir } = await discoverAgents(this.session.cwd);
@@ -651,6 +712,15 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			};
 		}
 
+		const forkContextValidationError = validateForkContextRequests(
+			params.tasks ?? [],
+			agent,
+			this.session.settings.get("task.forkContext.enabled"),
+		);
+		if (forkContextValidationError) {
+			return createTaskModeError(forkContextValidationError);
+		}
+
 		const planModeState = this.session.getPlanModeState?.();
 		const planModeTools = ["read", "search", "find", "lsp", "web_search"];
 		const effectiveAgent: typeof agent = planModeState?.enabled
@@ -912,7 +982,22 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 			}
 			emitProgress();
 
+			const buildForkContextSeed = async (task: (typeof tasksWithUniqueIds)[number]) => {
+				if (task.inheritContext !== true) return undefined;
+				if (!this.session.buildForkContextSeed) {
+					throw new Error("Current session cannot build fork-context seeds.");
+				}
+				const maxMessages = this.session.settings.get("task.forkContext.maxMessages");
+				const configuredMaxTokens = this.session.settings.get("task.forkContext.maxTokens");
+				return await this.session.buildForkContextSeed({
+					maxMessages,
+					maxTokens: resolveForkContextMaxTokens(configuredMaxTokens, this.session.model),
+					signal,
+				});
+			};
+
 			const runTask = async (task: (typeof tasksWithUniqueIds)[number], index: number) => {
+				const forkContextSeed = prebuiltForkContextSeeds?.get(task.id) ?? (await buildForkContextSeed(task));
 				if (!isIsolated) {
 					return runSubprocess({
 						cwd: this.session.cwd,
@@ -953,6 +1038,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						parentArtifactManager,
 						parentHindsightSessionState: this.session.getHindsightSessionState?.(),
 						parentTelemetry: this.session.getTelemetry?.(),
+						forkContextSeed,
 					});
 				}
 
@@ -1007,6 +1093,7 @@ export class TaskTool implements AgentTool<TaskToolSchemaInstance, TaskToolDetai
 						parentArtifactManager,
 						parentHindsightSessionState: this.session.getHindsightSessionState?.(),
 						parentTelemetry: this.session.getTelemetry?.(),
+						forkContextSeed,
 					});
 					if (mergeMode === "branch" && result.exitCode === 0) {
 						try {

package/src/task/types.ts

@@ -7,6 +7,7 @@ import type { NestedRepoPatch } from "./worktree";
 
 /** Source of an agent definition */
 export type AgentSource = "bundled" | "user" | "project";
+export type ForkContextPolicy = "forbidden" | "allowed";
 
 const parseNumber = (value: string | undefined, defaultValue: number): number => {
 	if (value) {
@@ -64,6 +65,10 @@ const createTaskItemSchema = (_contextEnabled: boolean) =>
 		id: z.string().max(48).describe("camelcase identifier"),
 		description: z.string().describe("ui label, not seen by subagent"),
 		assignment: z.string().describe(assignmentDescription),
+		inheritContext: z
+			.boolean()
+			.optional()
+			.describe("explicit request to seed a subagent with sanitized parent context"),
 	});
 
 /** Single task item for parallel execution (default shape with context enabled). */
@@ -175,6 +180,7 @@ export interface AgentDefinition {
 	blocking?: boolean;
 	autoloadSkills?: string[];
 	hide?: boolean;
+	forkContext?: ForkContextPolicy;
 	source: AgentSource;
 	filePath?: string;
 }

package/src/tools/ask.ts

@@ -149,6 +149,7 @@ interface UIContext {
 			timeout?: number;
 			signal?: AbortSignal;
 			outline?: boolean;
+			wrapFocused?: boolean;
 			onTimeout?: () => void;
 			onLeft?: () => void;
 			onRight?: () => void;
@@ -194,6 +195,7 @@ async function askSingleQuestion(
 			timeout,
 			signal,
 			outline: true,
+			wrapFocused: true,
 			onTimeout,
 			helpText,
 			onLeft: navigation?.allowBack