@dimi-agent/cli 0.6.1 → 0.6.3

package/dist/main.mjs

@@ -224811,17 +224811,22 @@ var init_sdk_rpc_client = __esmMin((() => {
 		}
 		/**
 		* Build one canonical v2 resume snapshot from the live restored scopes.
-		* Replay is the restored context history; task and todo state come from
-		* their owning services instead of a second pass over the wire journal.
+		* Replay is the full message history folded from the agent's wire journal —
+		* NOT the live context memory, which after a compaction collapses into
+		* `[...keptUserMessages, compaction_summary]` and would lose the compacted
+		* prefix. `context` keeps the folded (live) context for token accounting;
+		* task and todo state come from their owning services instead of a second
+		* pass over the wire journal.
 		*/
 		async resumedAgentState(session, agent, type, replayTurnLimit) {
 			const facade = this.klient.session(session.id).agent(agent.id);
 			const ctx = session.accessor.get(ISessionContext);
-			const [context, plan, usage, tasks] = await Promise.all([
+			const [context, plan, usage, tasks, replay] = await Promise.all([
 				facade.getContext(),
 				facade.getPlan(),
 				facade.getUsage(),
-				facade.getTasks({ activeOnly: false })
+				facade.getTasks({ activeOnly: false }),
+				this.buildReplayFromWire(agent)
 			]);
 			const profile = agent.accessor.get(IAgentProfileService).data();
 			return {
@@ -224835,11 +224840,7 @@ var init_sdk_rpc_client = __esmMin((() => {
 					systemPrompt: profile.systemPrompt
 				},
 				context,
-				replay: limitAgentReplayByTurns(context.history.map((message, time) => ({
-					type: "message",
-					message,
-					time
-				})), replayTurnLimit),
+				replay: limitAgentReplayByTurns(replay, replayTurnLimit),
 				permission: {
 					mode: agent.accessor.get(IAgentPermissionModeService).mode,
 					rules: [...agent.accessor.get(IAgentPermissionRulesService).rules]
@@ -224853,6 +224854,63 @@ var init_sdk_rpc_client = __esmMin((() => {
 			};
 		}
 		/**
+		* Fold the agent's full message history from its wire journal.
+		*
+		* The wire journal is the source of truth for message history: it keeps
+		* every `context.append_message` / `context.append_loop_event` record, and
+		* a `context.apply_compaction` record only marks a compaction point instead
+		* of rewriting the past. Folding it yields the complete pre-compaction
+		* history with a summary marker at each compaction, which is what replay
+		* should render. The live context memory (`facade.getContext()`) is the
+		* model's folded context and is deliberately NOT used here — it would hide
+		* everything compacted away.
+		*/
+		async buildReplayFromWire(agent) {
+			await agent.accessor.get(IWireService).flush();
+			const scope = agent.accessor.get(IAgentScopeContext).scope();
+			const reducer = createContextTranscriptReducer();
+			const applyCompactionRecords = [];
+			for await (const record of this.engineAccessor.get(IAppendLogStore).read(scope, AGENT_WIRE_RECORD_KEY)) {
+				if (record.type === "context.apply_compaction") applyCompactionRecords.push(record);
+				reducer.add(record);
+			}
+			const { entries, times } = reducer.result();
+			const replay = [];
+			let compactionIndex = 0;
+			for (let i = 0; i < entries.length; i++) {
+				const message = entries[i];
+				const time = times[i];
+				if (message.origin?.kind === "compaction_summary") {
+					const record = applyCompactionRecords[compactionIndex];
+					compactionIndex += 1;
+					if (record !== void 0) {
+						const compaction = readContextCompactionRecord(record);
+						replay.push({
+							type: "compaction",
+							result: {
+								summary: compaction.summary,
+								contextSummary: compaction.contextSummary,
+								compactedCount: compaction.compactedCount,
+								tokensBefore: compaction.tokensBefore,
+								tokensAfter: compaction.tokensAfter,
+								keptUserMessageCount: compaction.keptUserMessageCount,
+								keptHeadUserMessageCount: compaction.keptHeadUserMessageCount,
+								droppedCount: compaction.droppedCount
+							},
+							time: time ?? 0
+						});
+						continue;
+					}
+				}
+				replay.push({
+					type: "message",
+					message,
+					time: time ?? 0
+				});
+			}
+			return replay;
+		}
+		/**
 		* Every v2 workspace-id bucket addressing `workDir` (already normalized):
 		* the registered workspace's alias set when the catalog knows the root, or
 		* the freshly minted bucket key for index-only sessions (mirrors how v1's
@@ -378194,6 +378252,21 @@ var init_tool_call = __esmMin((() => {
 		get toolCallView() {
 			return this.toolCall;
 		}
+		/**
+		* Whether this call has reached a terminal state. Ordinary tools finish when
+		* their result lands; agent and read cards derive their phase from events
+		* (subagent lifecycle / read status), falling back to the result. Used by
+		* transcript folding to avoid collapsing calls the user still needs to
+		* watch (a running agent would otherwise disappear into the summary line).
+		*/
+		isFinished() {
+			if (this.toolCall.name === "Agent" || this.toolCall.name === "AgentSwarm") {
+				const phase = this.getSubagentSnapshot().phase;
+				return phase === "done" || phase === "failed" || phase === "backgrounded";
+			}
+			if (this.toolCall.name === "Read") return this.getReadSnapshot().phase !== "pending";
+			return this.result !== void 0;
+		}
 		/** Notifies the listener when internal state changes, if a group is attached. */
 		notifySnapshotChange() {
 			this.onSnapshotChange?.();
@@ -386868,6 +386941,10 @@ var init_session_replay = __esmMin((() => {
 				return;
 			}
 			if (message.origin?.kind === "injection") return;
+			if (message.origin?.kind === "compaction_summary") {
+				this.renderCompactionSummary(context, message);
+				return;
+			}
 			if (message.origin?.kind === "task") {
 				this.flushAssistant(context);
 				const info = this.host.sessionEventHandler.backgroundTasks.get(message.origin.taskId);
@@ -387036,6 +387113,21 @@ var init_session_replay = __esmMin((() => {
 				}
 			});
 		}
+		/**
+		* Render a `compaction_summary` user message folded into the model context
+		* (the resume snapshot's context history carries it after compaction). The
+		* message text is the model-facing summary; token counts are unknown here,
+		* so only the summary is surfaced. The snapshot is still rebuilt from the
+		* wire journal on resume (see `resumedAgentState`), so this branch is a
+		* fallback for snapshots that were built from a folded context.
+		*/
+		renderCompactionSummary(context, message) {
+			this.flushAssistant(context);
+			this.host.appendTranscriptEntry({
+				...replayEntry(context, "status", "Compaction complete", "plain"),
+				compactionData: { summary: contentPartsToText(message.content) }
+			});
+		}
 		renderHookResult(context, message) {
 			if (message.origin?.kind !== "hook_result") return;
 			this.flushAssistant(context);
@@ -387216,6 +387308,82 @@ var init_terminal_notification = __esmMin((() => {
 	init_terminal();
 }));
 //#endregion
+//#region src/tui/utils/transcript-window.ts
+/**
+* Read a non-negative integer env var, falling back to `fallback` when it is
+* unset, empty, negative, or not an integer. `0` is a valid value (call sites
+* treat it as "feature disabled").
+*/
+function readEnvInt(name, fallback) {
+	const raw = process.env[name];
+	if (raw === void 0 || raw.trim() === "") return fallback;
+	const value = Number(raw);
+	if (!Number.isInteger(value) || value < 0) return fallback;
+	return value;
+}
+/**
+* Group consecutive entries into turns by `turnId`. Entries with the same
+* non-undefined `turnId` that are adjacent belong to the same turn.
+*
+* Entries with an undefined `turnId` are buffered and attached to the *next*
+* defined turn. This matters because a user message is appended (with
+* `turnId: undefined`) before its turn actually starts, so without this
+* buffering every user message would become its own single-entry turn at the
+* front and get trimmed first. Any undefined entries left at the tail (no
+* following turn) become their own turn.
+*/
+function groupTurns(entries) {
+	const turns = [];
+	let current;
+	let pendingUndefined = [];
+	for (const entry of entries) {
+		const turnId = entry.turnId;
+		if (turnId === void 0) {
+			pendingUndefined.push(entry);
+			continue;
+		}
+		if (current !== void 0 && current.turnId === turnId) current.entries.push(entry);
+		else {
+			current = {
+				turnId,
+				entries: [...pendingUndefined, entry]
+			};
+			pendingUndefined = [];
+			turns.push(current);
+		}
+	}
+	if (pendingUndefined.length > 0) turns.push({
+		turnId: void 0,
+		entries: pendingUndefined
+	});
+	return turns;
+}
+/**
+* Decide which entries to destroy so the remaining turns fit within
+* `maxTurns`. Returns an empty set when the turn count is within
+* `maxTurns + hysteresis`. Oldest turns are removed first; the most recent
+* turn is never removed (it is the active / just-finished turn).
+*/
+function turnsToTrim(turns, maxTurns, hysteresis) {
+	const toRemove = /* @__PURE__ */ new Set();
+	if (turns.length <= maxTurns + hysteresis) return toRemove;
+	let remaining = turns.length;
+	for (let i = 0; i < turns.length - 1 && remaining > maxTurns; i++) {
+		const turn = turns[i];
+		for (const entry of turn.entries) toRemove.add(entry);
+		remaining--;
+	}
+	return toRemove;
+}
+var TRANSCRIPT_MAX_TURNS, TRANSCRIPT_EXPAND_TURNS, TRANSCRIPT_HYSTERESIS, TRANSCRIPT_KEEP_RECENT_STEPS, TRANSCRIPT_KEEP_TRAILING_TOOL_CALLS;
+var init_transcript_window = __esmMin((() => {
+	TRANSCRIPT_MAX_TURNS = readEnvInt("DIMI_CODE_TUI_MAX_TURNS", 15);
+	TRANSCRIPT_EXPAND_TURNS = readEnvInt("DIMI_CODE_TUI_EXPAND_TURNS", 3);
+	TRANSCRIPT_HYSTERESIS = readEnvInt("DIMI_CODE_TUI_HYSTERESIS", 5);
+	TRANSCRIPT_KEEP_RECENT_STEPS = readEnvInt("DIMI_CODE_TUI_KEEP_RECENT_STEPS", 30);
+	TRANSCRIPT_KEEP_TRAILING_TOOL_CALLS = readEnvInt("DIMI_CODE_TUI_KEEP_TRAILING_TOOL_CALLS", 2);
+}));
+//#endregion
 //#region src/tui/controllers/streaming-ui.ts
 var StreamingUIController;
 var init_streaming_ui = __esmMin((() => {
@@ -387231,6 +387399,7 @@ var init_streaming_ui = __esmMin((() => {
 	init_event_payload();
 	init_terminal_notification();
 	init_transcript_id();
+	init_transcript_window();
 	StreamingUIController = class {
 		host;
 		flushTimer;
@@ -387714,6 +387883,7 @@ var init_streaming_ui = __esmMin((() => {
 				state.transcriptContainer.addChild(tc);
 				state.ui.requestRender();
 			}
+			this.host.foldTrailingToolCalls(TRANSCRIPT_KEEP_TRAILING_TOOL_CALLS);
 			if (toolCall.name === "ExitPlanMode" && typeof toolCall.args["plan"] !== "string") {
 				const session = this.host.requireSession();
 				(async () => {
@@ -390462,81 +390632,6 @@ var init_tmux_keyboard = __esmMin((() => {
 	TMUX_EXTENDED_KEYS_FORMAT_XTERM_WARNING = "tmux extended-keys-format is xterm. Dimi works best with csi-u. Add `set -g extended-keys-format csi-u` to ~/.tmux.conf and restart tmux.";
 }));
 //#endregion
-//#region src/tui/utils/transcript-window.ts
-/**
-* Read a non-negative integer env var, falling back to `fallback` when it is
-* unset, empty, negative, or not an integer. `0` is a valid value (call sites
-* treat it as "feature disabled").
-*/
-function readEnvInt(name, fallback) {
-	const raw = process.env[name];
-	if (raw === void 0 || raw.trim() === "") return fallback;
-	const value = Number(raw);
-	if (!Number.isInteger(value) || value < 0) return fallback;
-	return value;
-}
-/**
-* Group consecutive entries into turns by `turnId`. Entries with the same
-* non-undefined `turnId` that are adjacent belong to the same turn.
-*
-* Entries with an undefined `turnId` are buffered and attached to the *next*
-* defined turn. This matters because a user message is appended (with
-* `turnId: undefined`) before its turn actually starts, so without this
-* buffering every user message would become its own single-entry turn at the
-* front and get trimmed first. Any undefined entries left at the tail (no
-* following turn) become their own turn.
-*/
-function groupTurns(entries) {
-	const turns = [];
-	let current;
-	let pendingUndefined = [];
-	for (const entry of entries) {
-		const turnId = entry.turnId;
-		if (turnId === void 0) {
-			pendingUndefined.push(entry);
-			continue;
-		}
-		if (current !== void 0 && current.turnId === turnId) current.entries.push(entry);
-		else {
-			current = {
-				turnId,
-				entries: [...pendingUndefined, entry]
-			};
-			pendingUndefined = [];
-			turns.push(current);
-		}
-	}
-	if (pendingUndefined.length > 0) turns.push({
-		turnId: void 0,
-		entries: pendingUndefined
-	});
-	return turns;
-}
-/**
-* Decide which entries to destroy so the remaining turns fit within
-* `maxTurns`. Returns an empty set when the turn count is within
-* `maxTurns + hysteresis`. Oldest turns are removed first; the most recent
-* turn is never removed (it is the active / just-finished turn).
-*/
-function turnsToTrim(turns, maxTurns, hysteresis) {
-	const toRemove = /* @__PURE__ */ new Set();
-	if (turns.length <= maxTurns + hysteresis) return toRemove;
-	let remaining = turns.length;
-	for (let i = 0; i < turns.length - 1 && remaining > maxTurns; i++) {
-		const turn = turns[i];
-		for (const entry of turn.entries) toRemove.add(entry);
-		remaining--;
-	}
-	return toRemove;
-}
-var TRANSCRIPT_MAX_TURNS, TRANSCRIPT_EXPAND_TURNS, TRANSCRIPT_HYSTERESIS, TRANSCRIPT_KEEP_RECENT_STEPS;
-var init_transcript_window = __esmMin((() => {
-	TRANSCRIPT_MAX_TURNS = readEnvInt("DIMI_CODE_TUI_MAX_TURNS", 15);
-	TRANSCRIPT_EXPAND_TURNS = readEnvInt("DIMI_CODE_TUI_EXPAND_TURNS", 3);
-	TRANSCRIPT_HYSTERESIS = readEnvInt("DIMI_CODE_TUI_HYSTERESIS", 5);
-	TRANSCRIPT_KEEP_RECENT_STEPS = readEnvInt("DIMI_CODE_TUI_KEEP_RECENT_STEPS", 30);
-}));
-//#endregion
 //#region src/tui/dimi-tui.ts
 function loadingTipKind(mode) {
 	if (mode === "waiting" || mode === "tool") return "moon";
@@ -391895,6 +391990,7 @@ var init_dimi_tui = __esmMin((() => {
 				markTranscriptComponent(component, entry);
 				this.state.transcriptContainer.addChild(component);
 			}
+			if (entry.kind === "tool_call") this.foldTrailingToolCalls(TRANSCRIPT_KEEP_TRAILING_TOOL_CALLS);
 			const trimmed = this.trimTranscriptWindow();
 			const merged = this.mergeCurrentTurnSteps();
 			if (component || trimmed || merged) this.state.ui.requestRender();
@@ -391999,6 +392095,21 @@ var init_dimi_tui = __esmMin((() => {
 			return this.foldCurrentTurnSteps(TRANSCRIPT_KEEP_RECENT_STEPS);
 		}
 		collapseTrailingToolCalls() {
+			this.foldTrailingToolCalls(0);
+		}
+		/**
+		* Fold the trailing contiguous run of tool calls, keeping the most recent
+		* `keepExpanded` calls expanded. `keepExpanded = 0` collapses the whole run
+		* (used when visible content follows, e.g. an assistant message or turn
+		* end); a positive cap folds progressively while the run is still growing
+		* so older calls merge into the summary immediately instead of staying
+		* expanded until the run ends.
+		*
+		* Only finished calls fold — a call that is still running (streaming args,
+		* a live subagent, a pending read) stays visible because its progress is
+		* live information the user is watching.
+		*/
+		foldTrailingToolCalls(keepExpanded) {
 			const children = this.state.transcriptContainer.children;
 			let start = children.length;
 			const toolCalls = [];
@@ -392020,21 +392131,49 @@ var init_dimi_tui = __esmMin((() => {
 			const standaloneNames = new Set(["AllDone", "WaitFor"]);
 			const standaloneCalls = new Set(toolCalls.filter((call) => standaloneNames.has(call.toolCallView.name)));
 			const sequenceCalls = toolCalls.filter((call) => !standaloneCalls.has(call));
+			if (sequenceCalls.length === 0) return;
+			const foldCount = sequenceCalls.length - keepExpanded;
+			if (foldCount <= 0) return;
 			const components = children.slice(start);
 			const standalone = [];
 			const sequenceComponents = [];
+			const keptComponents = [];
+			let remainingToFold = foldCount;
+			let stoppedAtUnfinished = false;
 			for (const component of components) {
-				if (component instanceof ToolCallSequenceComponent) {
-					sequenceComponents.push(...component.children);
-					component.clear();
+				if (stoppedAtUnfinished) {
+					keptComponents.push(component);
 					continue;
 				}
-				if (component instanceof ToolCallComponent && standaloneCalls.has(component)) standalone.push(component);
-				else sequenceComponents.push(component);
-			}
-			if (sequenceCalls.length === 0) return;
-			const sequence = new ToolCallSequenceComponent(sequenceComponents, sequenceCalls, this.state.toolDisplayMode);
-			children.splice(start, components.length, sequence, ...standalone);
+				if (component instanceof ToolCallComponent && standaloneCalls.has(component)) {
+					standalone.push(component);
+					continue;
+				}
+				const calls = toolCallsIn(component);
+				const callCount = calls?.filter((call) => !standaloneCalls.has(call)).length ?? 0;
+				const hasUnfinished = calls?.some((call) => !call.isFinished()) ?? false;
+				if (remainingToFold > 0 && hasUnfinished) {
+					keptComponents.push(component);
+					stoppedAtUnfinished = true;
+					continue;
+				}
+				if (remainingToFold > 0) {
+					if (component instanceof ToolCallSequenceComponent) {
+						sequenceComponents.push(...component.children);
+						component.clear();
+					} else sequenceComponents.push(component);
+					remainingToFold -= callCount;
+				} else keptComponents.push(component);
+			}
+			if (sequenceComponents.length === 0) return;
+			const foldedCalls = [];
+			for (const component of sequenceComponents) {
+				const componentCalls = toolCallsIn(component);
+				if (componentCalls !== void 0) foldedCalls.push(...componentCalls.filter((call) => !standaloneCalls.has(call)));
+			}
+			if (foldedCalls.length === 0) return;
+			const sequence = new ToolCallSequenceComponent(sequenceComponents, foldedCalls, this.state.toolDisplayMode);
+			children.splice(start, components.length, sequence, ...standalone, ...keptComponents);
 			this.state.transcriptContainer.invalidate();
 		}
 		foldCurrentTurnSteps(keepSteps) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dimi-agent/cli",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "The Starting Point for Next-Gen Agents",
   "keywords": [
     "agent",
@@ -60,12 +60,12 @@
     "tsx": "^4.21.0",
     "yazl": "^3.3.1",
     "zod": "^4.3.6",
-    "@dimi-agent/agent-core-v2": "^0.1.0",
+    "@dimi-agent/dimi-oauth": "^0.1.0",
     "@dimi-agent/dimi-telemetry": "^0.1.0",
+    "@dimi-agent/agent-core-v2": "^0.1.0",
     "@dimi-agent/dimi-sdk": "^0.2.0",
     "@dimi-agent/dimi-web": "^0.1.0",
     "@dimi-agent/kap-server": "^0.1.0",
-    "@dimi-agent/dimi-oauth": "^0.1.0",
     "@dimi-agent/pi-tui": "^0.1.0",
     "@dimi-agent/remote": "^0.1.0"
   },