@pi-ohm/subagents 0.6.4-dev.27882043826.1.f8cd4e4 → 0.6.4-dev.27886562528.1.753a5fd

package/dist/agent-controller.d.ts

@@ -56,7 +56,7 @@ declare function resolveAvailableAgents(input: {
   readonly currentModel?: Model<Api>;
 }): Promise<Result<readonly AvailableAgent[], Error>>;
 interface SubagentToolRuntime {
-  spawn(params: SpawnAgentArgs, ctx: ToolContext): Promise<AgentToolResult<unknown>>;
+  spawn(params: SpawnAgentArgs, ctx: ToolContext, signal: AbortSignal | undefined): Promise<AgentToolResult<unknown>>;
   sendMessage(params: SendMessageArgs, ctx: ToolContext): Promise<AgentToolResult<unknown>>;
   followupTask(params: FollowupTaskArgs, ctx: ToolContext): Promise<AgentToolResult<unknown>>;
   wait(params: WaitAgentArgs, ctx: ToolContext): Promise<AgentToolResult<unknown>>;
@@ -67,6 +67,23 @@ interface SubagentToolRuntime {
 type ToolContext = Parameters<ToolDefinition["execute"]>[4];
 declare function createSubagentTools(runtime: SubagentToolRuntime): readonly ToolDefinition[];
 declare function resolveForkMode(forkTurns: string | undefined): Result<SpawnForkMode, Error>;
+declare function createBranchSummaryForkEntries(input: {
+  readonly entries: readonly SessionEntry[];
+  readonly summary: string;
+  readonly readFiles: readonly string[];
+  readonly modifiedFiles: readonly string[];
+  readonly id: string;
+  readonly timestamp: string;
+}): readonly SessionEntry[];
+declare function createCompactionForkEntries(input: {
+  readonly entries: readonly SessionEntry[];
+  readonly summary: string;
+  readonly firstKeptEntryId: string;
+  readonly tokensBefore: number;
+  readonly details?: unknown;
+  readonly id: string;
+  readonly timestamp: string;
+}): readonly SessionEntry[];
 declare function sliceForkEntries(entries: readonly SessionEntry[], turns: number): readonly SessionEntry[];
 //#endregion
-export { type ResolvedSpawnConfig, SubagentToolRuntime, createSubagentToolRuntime, createSubagentTools, registerAgentControllerTool, resolveAvailableAgents, resolveForkMode, resolveSpawnConfig, sliceForkEntries };
+export { type ResolvedSpawnConfig, SubagentToolRuntime, createBranchSummaryForkEntries, createCompactionForkEntries, createSubagentToolRuntime, createSubagentTools, registerAgentControllerTool, resolveAvailableAgents, resolveForkMode, resolveSpawnConfig, sliceForkEntries };

package/dist/agent-controller.js

@@ -1,4 +1,4 @@
-import { isSubagentRuntimeConfig, resolveSubagentAgentRuntimeConfig, subagentsConfigModule } from "./config.js";
+import { getSummarizeHistoryConfig, isSubagentRuntimeConfig, resolveSubagentAgentRuntimeConfig, subagentsConfigModule } from "./config.js";
 import { INTEGRATED_SUBAGENTS } from "./catalog.js";
 import { DEFAULT_AGENT_TYPE, resolveSpawnConfig } from "./spawn-config.js";
 import { Result } from "better-result";
@@ -6,7 +6,7 @@ import { loadConfig, pickConfig } from "@pi-ohm/core/config";
 import { randomUUID } from "node:crypto";
 import { mkdir, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { CURRENT_SESSION_VERSION, defineTool } from "@earendil-works/pi-coding-agent";
+import { CURRENT_SESSION_VERSION, DEFAULT_COMPACTION_SETTINGS, buildSessionContext, defineTool, estimateTokens, findCutPoint, generateBranchSummary, generateSummary } from "@earendil-works/pi-coding-agent";
 import { Type } from "@earendil-works/pi-ai";
 import { PipController, createSdkPipRunner } from "@pi-ohm/core/pip";
 import { resolveOhmAgentDataHome } from "@pi-ohm/core/paths";
@@ -62,7 +62,7 @@ function registerAgentControllerTool(pi) {
 function createSubagentToolRuntime(pi) {
 	const ownedPipIds = new Set();
 	return {
-		async spawn(params, ctx) {
+		async spawn(params, ctx, signal) {
 			const taskName = normalizeTaskName(params.task_name);
 			if (Result.isError(taskName)) return toolError(taskName.error.message);
 			const fork = resolveForkMode(params.fork_turns);
@@ -90,6 +90,8 @@ function createSubagentToolRuntime(pi) {
 				currentThinking: pi.getThinkingLevel()
 			});
 			if (Result.isError(config)) return toolError(config.error.message);
+			const summarize = await resolveSummarizeHistoryConfig(ctx.cwd);
+			if (Result.isError(summarize)) return toolError(summarize.error.message);
 			const key = controllerKey(config.value);
 			const currentController = record.controllers.get(key);
 			const created = currentController ? Result.ok(currentController) : createPipController({
@@ -103,7 +105,12 @@ function createSubagentToolRuntime(pi) {
 			const parentSessionFile = await resolveForkSourceFile({
 				fork: fork.value,
 				sessionManager: ctx.sessionManager,
-				cwd: ctx.cwd
+				cwd: ctx.cwd,
+				summarize: summarize.value,
+				model: ctx.model,
+				modelRegistry: ctx.modelRegistry,
+				thinking: pi.getThinkingLevel(),
+				signal
 			});
 			if (Result.isError(parentSessionFile)) return toolError(parentSessionFile.error.message);
 			const spawned = await controller.spawn({
@@ -307,7 +314,7 @@ function createSubagentTools(runtime) {
 			label: "Spawn Agent",
 			description: "Spawns an agent to work on a concrete bounded task. The spawned agent inherits the parent model unless explicit overrides are supplied.",
 			parameters: SpawnAgentArgsSchema,
-			execute: async (_toolCallId, params, _signal, _onUpdate, ctx) => runtime.spawn(params, ctx)
+			execute: async (_toolCallId, params, signal, _onUpdate, ctx) => runtime.spawn(params, ctx, signal)
 		}),
 		defineTool({
 			name: "send_message",
@@ -409,15 +416,102 @@ function resolveForkMode(forkTurns) {
 	}
 	return Result.err(new Error("fork_turns must be \"none\", \"all\", or a positive integer string"));
 }
+async function resolveSummarizeHistoryConfig(cwd) {
+	const loaded = await loadConfig({
+		cwd,
+		modules: [subagentsConfigModule]
+	});
+	if (Result.isError(loaded)) return Result.err(loaded.error);
+	const subagents = pickConfig({
+		loaded: loaded.value,
+		module: subagentsConfigModule,
+		is: isSubagentRuntimeConfig
+	});
+	if (Result.isError(subagents)) return Result.err(subagents.error);
+	return Result.ok(getSummarizeHistoryConfig({ subagents: subagents.value }));
+}
 async function resolveForkSourceFile(input) {
 	if (input.fork.kind === "none") return Result.ok(undefined);
 	const source = input.fork.kind === "all" ? reparentEntries(input.sessionManager.getBranch()) : sliceForkEntries(input.sessionManager.getBranch(), input.fork.turns);
+	const entries = input.summarize.enabled ? await summarizeForkEntries({
+		entries: source,
+		summarize: input.summarize,
+		model: input.model,
+		modelRegistry: input.modelRegistry,
+		thinking: input.thinking,
+		signal: input.signal
+	}) : Result.ok(source);
+	if (Result.isError(entries)) return Result.err(entries.error);
 	return writeForkSourceFile({
 		header: forkSourceHeader({
 			sessionManager: input.sessionManager,
 			cwd: input.cwd
 		}),
-		entries: source
+		entries: entries.value
+	});
+}
+async function summarizeForkEntries(input) {
+	if (input.entries.length === 0) return Result.ok([]);
+	const model = input.model;
+	if (!model) return Result.err(new Error("No active model available to summarize fork history"));
+	const auth = await resolveSummaryAuth({
+		model,
+		modelRegistry: input.modelRegistry
+	});
+	if (Result.isError(auth)) return Result.err(auth.error);
+	if (input.summarize.type === "branch") {
+		const summarized = await Result.tryPromise({
+			try: () => generateBranchSummary([...input.entries], {
+				model,
+				apiKey: auth.value.apiKey,
+				headers: auth.value.headers,
+				signal: input.signal ?? new AbortController().signal
+			}),
+			catch: (cause) => new Error(`Failed to summarize fork history: ${messageFromCause(cause)}`)
+		});
+		if (Result.isError(summarized)) return Result.err(summarized.error);
+		if (summarized.value.aborted) return Result.err(new Error("Fork history summarization aborted"));
+		if (summarized.value.error) {
+			return Result.err(new Error(`Failed to summarize fork history: ${summarized.value.error}`));
+		}
+		const summary = summarized.value.summary ?? "No summary generated";
+		return Result.ok(createBranchSummaryForkEntries({
+			entries: input.entries,
+			summary,
+			readFiles: summarized.value.readFiles ?? [],
+			modifiedFiles: summarized.value.modifiedFiles ?? [],
+			id: randomUUID(),
+			timestamp: new Date().toISOString()
+		}));
+	}
+	const cut = findCutPoint([...input.entries], 0, input.entries.length, DEFAULT_COMPACTION_SETTINGS.keepRecentTokens);
+	const firstKeptEntry = input.entries[cut.firstKeptEntryIndex];
+	if (!firstKeptEntry) return Result.ok(input.entries);
+	const historyEnd = cut.isSplitTurn && cut.turnStartIndex >= 0 ? cut.turnStartIndex : cut.firstKeptEntryIndex;
+	const messages = buildSessionContext(input.entries.slice(0, historyEnd)).messages;
+	if (messages.length === 0) return Result.ok(input.entries);
+	const tokensBefore = buildSessionContext([...input.entries]).messages.reduce((total, message) => total + estimateTokens(message), 0);
+	const compacted = await Result.tryPromise({
+		try: () => generateSummary(messages, model, DEFAULT_COMPACTION_SETTINGS.reserveTokens, auth.value.apiKey, auth.value.headers, input.signal, undefined, undefined, input.thinking),
+		catch: (cause) => new Error(`Failed to compact fork history: ${messageFromCause(cause)}`)
+	});
+	if (Result.isError(compacted)) return Result.err(compacted.error);
+	return Result.ok(createCompactionForkEntries({
+		entries: input.entries,
+		summary: compacted.value,
+		firstKeptEntryId: firstKeptEntry.id,
+		tokensBefore,
+		id: randomUUID(),
+		timestamp: new Date().toISOString()
+	}));
+}
+async function resolveSummaryAuth(input) {
+	const auth = await input.modelRegistry.getApiKeyAndHeaders(input.model);
+	if (!auth.ok) return Result.err(new Error(auth.error));
+	if (!auth.apiKey) return Result.err(new Error(`No API key found for "${input.model.provider}"`));
+	return Result.ok({
+		apiKey: auth.apiKey,
+		...auth.headers ? { headers: auth.headers } : {}
 	});
 }
 function forkSourceHeader(input) {
@@ -452,6 +546,36 @@ async function writeForkSourceFile(input) {
 	if (Result.isError(written)) return Result.err(written.error);
 	return Result.ok(written.value);
 }
+function createBranchSummaryForkEntries(input) {
+	const fromId = input.entries[input.entries.length - 1]?.id ?? "root";
+	return [{
+		type: "branch_summary",
+		id: input.id,
+		parentId: null,
+		timestamp: input.timestamp,
+		fromId,
+		summary: input.summary,
+		details: {
+			readFiles: [...input.readFiles],
+			modifiedFiles: [...input.modifiedFiles]
+		}
+	}];
+}
+function createCompactionForkEntries(input) {
+	const compaction = {
+		type: "compaction",
+		id: input.id,
+		parentId: null,
+		timestamp: input.timestamp,
+		summary: input.summary,
+		firstKeptEntryId: input.firstKeptEntryId,
+		tokensBefore: input.tokensBefore,
+		details: input.details
+	};
+	const firstKeptIndex = input.entries.findIndex((entry) => entry.id === input.firstKeptEntryId);
+	const suffix = firstKeptIndex >= 0 ? input.entries.slice(firstKeptIndex) : [];
+	return [compaction, ...reparentEntries(suffix, compaction.id)];
+}
 function sliceForkEntries(entries, turns) {
 	const positions = entries.flatMap((entry, index) => isForkTurnBoundary(entry) ? [index] : []);
 	const start = positions.length > turns ? positions[positions.length - turns] : positions[0] ?? entries.length;
@@ -460,10 +584,10 @@ function sliceForkEntries(entries, turns) {
 function isForkTurnBoundary(entry) {
 	return entry.type === "message" && entry.message.role === "user";
 }
-function reparentEntries(entries) {
+function reparentEntries(entries, parentId = null) {
 	const initial = {
 		entries: [],
-		parentId: null
+		parentId
 	};
 	return entries.reduce((state, entry) => {
 		state.entries.push(reparentEntry(entry, state.parentId));
@@ -742,4 +866,4 @@ function toolError(message) {
 }
 
 //#endregion
-export { createSubagentToolRuntime, createSubagentTools, registerAgentControllerTool, resolveAvailableAgents, resolveForkMode, resolveSpawnConfig, sliceForkEntries };
+export { createBranchSummaryForkEntries, createCompactionForkEntries, createSubagentToolRuntime, createSubagentTools, registerAgentControllerTool, resolveAvailableAgents, resolveForkMode, resolveSpawnConfig, sliceForkEntries };

package/dist/config.js

@@ -8,7 +8,7 @@ import { Value } from "typebox/value";
 const SubagentRuntimeAgentsSchema = Type.Record(Type.String({ minLength: 1 }), SubagentAgentPatchSchema);
 const SummarizeHistoryRuntimeConfigSchema = Type.Object({
 	enabled: Type.Boolean(),
-	type: Type.Union([Type.Literal("compact"), Type.Literal("summary")])
+	type: Type.Union([Type.Literal("branch"), Type.Literal("compact")])
 }, { additionalProperties: false });
 const SubagentsExperimentalRuntimeConfigSchema = Type.Object({ summarize_history: SummarizeHistoryRuntimeConfigSchema }, { additionalProperties: false });
 const SubagentRuntimeConfigSchema = Type.Object({
@@ -19,7 +19,7 @@ const DEFAULT_SUBAGENT_RUNTIME_CONFIG = {
 	agents: {},
 	experimental: { summarize_history: {
 		enabled: false,
-		type: "summary"
+		type: "branch"
 	} }
 };
 const subagentsConfigModule = registerConfig({

package/dist/extension.d.ts

@@ -1,5 +1,5 @@
 import { ResolvedSpawnConfig, resolveSpawnConfig } from "./spawn-config.js";
-import { SubagentToolRuntime, createSubagentToolRuntime, createSubagentTools, registerAgentControllerTool, resolveAvailableAgents, resolveForkMode, sliceForkEntries } from "./agent-controller.js";
+import { SubagentToolRuntime, createBranchSummaryForkEntries, createCompactionForkEntries, createSubagentToolRuntime, createSubagentTools, registerAgentControllerTool, resolveAvailableAgents, resolveForkMode, sliceForkEntries } from "./agent-controller.js";
 import { SubagentAgentPatch, SubagentAgentPatchSchema, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, SubagentsConfigPatch, SubagentsConfigSchema, SubagentsExperimentalConfigPatch, SubagentsExperimentalConfigPatchSchema, SummarizeHistoryConfigPatch, SummarizeHistoryConfigPatchSchema, SummarizeHistoryType, SummarizeHistoryTypeSchema, parseSubagentAgentPatch, parseSubagentsExperimentalConfigPatch } from "./schema.js";
 import { DEFAULT_SUBAGENT_RUNTIME_CONFIG, ResolvedSubagentAgentRuntimeConfig, SubagentAgentRuntimeConfig, SubagentRuntimeConfig, SubagentToolPermissionDecision, SubagentsConfig, SubagentsExperimentalRuntimeConfig, SummarizeHistoryRuntimeConfig, getSubagentAgentRuntimeConfig, getSubagentConfiguredModel, getSummarizeHistoryConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, resolveSubagentAgentRuntimeConfig, subagentsConfigModule } from "./config.js";
 import { INTEGRATED_SUBAGENTS, IntegratedSubagent } from "./catalog.js";
@@ -25,4 +25,4 @@ interface SubagentsCommandContext {
 declare function runSubagentsCommand(ctx: SubagentsCommandContext, pi: Pick<ExtensionAPI, "getThinkingLevel">): Promise<boolean>;
 declare function registerSubagentsExtension(pi: Pick<ExtensionAPI, "appendEntry" | "getThinkingLevel" | "on" | "registerCommand" | "registerTool" | "sendMessage">): void;
 //#endregion
-export { BuildSubagentOverviewInput, DEFAULT_SUBAGENT_RUNTIME_CONFIG, INTEGRATED_SUBAGENTS, IntegratedSubagent, type ResolvedSpawnConfig, ResolvedSubagentAgentRuntimeConfig, type SubagentAgentPatch, SubagentAgentPatchSchema, SubagentAgentRuntimeConfig, SubagentOverview, SubagentOverviewEntry, SubagentRuntimeConfig, SubagentSource, SubagentToolPermissionDecision, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, SubagentToolRuntime, SubagentsCommandContext, SubagentsConfig, type SubagentsConfigPatch, SubagentsConfigSchema, type SubagentsExperimentalConfigPatch, SubagentsExperimentalConfigPatchSchema, SubagentsExperimentalRuntimeConfig, type SummarizeHistoryConfigPatch, SummarizeHistoryConfigPatchSchema, SummarizeHistoryRuntimeConfig, type SummarizeHistoryType, SummarizeHistoryTypeSchema, buildSubagentOverview, createSubagentToolRuntime, createSubagentTools, createSubagentsOverviewComponent, registerSubagentsExtension as default, getSubagentAgentRuntimeConfig, getSubagentConfiguredModel, getSummarizeHistoryConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, parseSubagentAgentPatch, parseSubagentsExperimentalConfigPatch, registerAgentControllerTool, renderSubagentOverview, resolveAvailableAgents, resolveForkMode, resolveSpawnConfig, resolveSubagentAgentRuntimeConfig, runSubagentsCommand, sliceForkEntries, subagentsConfigModule };
+export { BuildSubagentOverviewInput, DEFAULT_SUBAGENT_RUNTIME_CONFIG, INTEGRATED_SUBAGENTS, IntegratedSubagent, type ResolvedSpawnConfig, ResolvedSubagentAgentRuntimeConfig, type SubagentAgentPatch, SubagentAgentPatchSchema, SubagentAgentRuntimeConfig, SubagentOverview, SubagentOverviewEntry, SubagentRuntimeConfig, SubagentSource, SubagentToolPermissionDecision, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, SubagentToolRuntime, SubagentsCommandContext, SubagentsConfig, type SubagentsConfigPatch, SubagentsConfigSchema, type SubagentsExperimentalConfigPatch, SubagentsExperimentalConfigPatchSchema, SubagentsExperimentalRuntimeConfig, type SummarizeHistoryConfigPatch, SummarizeHistoryConfigPatchSchema, SummarizeHistoryRuntimeConfig, type SummarizeHistoryType, SummarizeHistoryTypeSchema, buildSubagentOverview, createBranchSummaryForkEntries, createCompactionForkEntries, createSubagentToolRuntime, createSubagentTools, createSubagentsOverviewComponent, registerSubagentsExtension as default, getSubagentAgentRuntimeConfig, getSubagentConfiguredModel, getSummarizeHistoryConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, parseSubagentAgentPatch, parseSubagentsExperimentalConfigPatch, registerAgentControllerTool, renderSubagentOverview, resolveAvailableAgents, resolveForkMode, resolveSpawnConfig, resolveSubagentAgentRuntimeConfig, runSubagentsCommand, sliceForkEntries, subagentsConfigModule };

package/dist/extension.js

@@ -2,7 +2,7 @@ import { SubagentAgentPatchSchema, SubagentToolPermissionDecisionSchema, Subagen
 import { DEFAULT_SUBAGENT_RUNTIME_CONFIG, getSubagentAgentRuntimeConfig, getSubagentConfiguredModel, getSummarizeHistoryConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, resolveSubagentAgentRuntimeConfig, subagentsConfigModule } from "./config.js";
 import { INTEGRATED_SUBAGENTS } from "./catalog.js";
 import { resolveSpawnConfig } from "./spawn-config.js";
-import { createSubagentToolRuntime, createSubagentTools, registerAgentControllerTool, resolveAvailableAgents, resolveForkMode, sliceForkEntries } from "./agent-controller.js";
+import { createBranchSummaryForkEntries, createCompactionForkEntries, createSubagentToolRuntime, createSubagentTools, registerAgentControllerTool, resolveAvailableAgents, resolveForkMode, sliceForkEntries } from "./agent-controller.js";
 import { buildSubagentOverview, createSubagentsOverviewComponent, renderSubagentOverview } from "./overview.js";
 import { Result } from "better-result";
 import { loadConfig, pickConfig, registerGlobalConfigModule, watchConfig } from "@pi-ohm/core/config";
@@ -109,4 +109,4 @@ function registerSubagentsExtension(pi) {
 }
 
 //#endregion
-export { DEFAULT_SUBAGENT_RUNTIME_CONFIG, INTEGRATED_SUBAGENTS, SubagentAgentPatchSchema, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, SubagentsConfigSchema, SubagentsExperimentalConfigPatchSchema, SummarizeHistoryConfigPatchSchema, SummarizeHistoryTypeSchema, buildSubagentOverview, createSubagentToolRuntime, createSubagentTools, createSubagentsOverviewComponent, registerSubagentsExtension as default, getSubagentAgentRuntimeConfig, getSubagentConfiguredModel, getSummarizeHistoryConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, parseSubagentAgentPatch, parseSubagentsExperimentalConfigPatch, registerAgentControllerTool, renderSubagentOverview, resolveAvailableAgents, resolveForkMode, resolveSpawnConfig, resolveSubagentAgentRuntimeConfig, runSubagentsCommand, sliceForkEntries, subagentsConfigModule };
+export { DEFAULT_SUBAGENT_RUNTIME_CONFIG, INTEGRATED_SUBAGENTS, SubagentAgentPatchSchema, SubagentToolPermissionDecisionSchema, SubagentToolPermissionMapSchema, SubagentsConfigSchema, SubagentsExperimentalConfigPatchSchema, SummarizeHistoryConfigPatchSchema, SummarizeHistoryTypeSchema, buildSubagentOverview, createBranchSummaryForkEntries, createCompactionForkEntries, createSubagentToolRuntime, createSubagentTools, createSubagentsOverviewComponent, registerSubagentsExtension as default, getSubagentAgentRuntimeConfig, getSubagentConfiguredModel, getSummarizeHistoryConfig, isSubagentRuntimeConfig, mergeSubagentRuntimeConfig, normalizeSubagentModelOverride, parseSubagentAgentPatch, parseSubagentsExperimentalConfigPatch, registerAgentControllerTool, renderSubagentOverview, resolveAvailableAgents, resolveForkMode, resolveSpawnConfig, resolveSubagentAgentRuntimeConfig, runSubagentsCommand, sliceForkEntries, subagentsConfigModule };

package/dist/schema.d.ts

@@ -12,16 +12,16 @@ declare const SubagentAgentPatchSchema: Type.TObject<{
   description: Type.TOptional<Type.TString>;
   permissions: Type.TOptional<Type.TRecord<"^.*$", Type.TUnion<[Type.TLiteral<"allow">, Type.TLiteral<"deny">]>>>;
 }>;
-declare const SummarizeHistoryTypeSchema: Type.TUnion<[Type.TLiteral<"compact">, Type.TLiteral<"summary">]>;
+declare const SummarizeHistoryTypeSchema: Type.TUnion<[Type.TLiteral<"branch">, Type.TLiteral<"compact">]>;
 declare const SummarizeHistoryConfigPatchSchema: Type.TObject<{
   enabled: Type.TOptional<Type.TBoolean>;
-  type: Type.TOptional<Type.TUnion<[Type.TLiteral<"compact">, Type.TLiteral<"summary">]>>;
+  type: Type.TOptional<Type.TUnion<[Type.TLiteral<"branch">, Type.TLiteral<"compact">]>>;
   model: Type.TOptional<Type.TString>;
 }>;
 declare const SubagentsExperimentalConfigPatchSchema: Type.TObject<{
   summarize_history: Type.TOptional<Type.TObject<{
     enabled: Type.TOptional<Type.TBoolean>;
-    type: Type.TOptional<Type.TUnion<[Type.TLiteral<"compact">, Type.TLiteral<"summary">]>>;
+    type: Type.TOptional<Type.TUnion<[Type.TLiteral<"branch">, Type.TLiteral<"compact">]>>;
     model: Type.TOptional<Type.TString>;
   }>>;
 }>;

package/dist/schema.js

@@ -16,7 +16,7 @@ const SubagentAgentPatchSchema = Type.Object({
 	description: Type.Optional(NonEmptyStringSchema),
 	permissions: Type.Optional(SubagentToolPermissionMapSchema)
 }, { additionalProperties: false });
-const SummarizeHistoryTypeSchema = Type.Union([Type.Literal("compact"), Type.Literal("summary")]);
+const SummarizeHistoryTypeSchema = Type.Union([Type.Literal("branch"), Type.Literal("compact")]);
 const SummarizeHistoryConfigPatchSchema = Type.Object({
 	enabled: Type.Optional(Type.Boolean()),
 	type: Type.Optional(SummarizeHistoryTypeSchema),
@@ -51,7 +51,7 @@ function toBoolean(value) {
 }
 function toSummarizeHistoryType(value) {
 	const type = toTrimmedString(value)?.toLowerCase();
-	if (type === "compact" || type === "summary") return type;
+	if (type === "branch" || type === "compact") return type;
 	return undefined;
 }
 function normalizeSubagentPermissionMapInput(value) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-ohm/subagents",
-  "version": "0.6.4-dev.27882043826.1.f8cd4e4",
+  "version": "0.6.4-dev.27886562528.1.753a5fd",
   "homepage": "https://github.com/pi-ohm/pi-ohm/tree/dev/packages/subagents#readme",
   "repository": {
     "type": "git",
@@ -36,8 +36,8 @@
     "@earendil-works/pi-agent-core": "0.79.4",
     "@earendil-works/pi-ai": "0.79.4",
     "@earendil-works/pi-coding-agent": "0.79.4",
-    "@pi-ohm/core": "0.6.4-dev.27882043826.1.f8cd4e4",
-    "@pi-ohm/tui": "0.6.4-dev.27882043826.1.f8cd4e4",
+    "@pi-ohm/core": "0.6.4-dev.27886562528.1.753a5fd",
+    "@pi-ohm/tui": "0.6.4-dev.27886562528.1.753a5fd",
     "better-result": "2.9.2",
     "typebox": "^1.0.68",
     "zod": "^4"