@bastani/atomic 0.8.26-alpha.1 → 0.8.26-alpha.10

package/dist/builtin/workflows/src/tui/stage-chat-view.ts

@@ -521,6 +521,7 @@ export class StageChatView implements Component, Focusable {
     }
     if (!this.promptState || this.promptState.prompt.id !== prompt.id) {
       this.promptState = createPromptCardState(prompt);
+      this._seedPromptTextState(prompt);
       this._resetPromptEditor(prompt);
       this._resetPromptScroll();
       return true;
@@ -533,19 +534,49 @@ export class StageChatView implements Component, Focusable {
     this.promptMaxScroll = 0;
   }
 
+  private _promptSeedText(prompt: PendingPrompt): string {
+    const draft = this.store.getStagePromptDraft(this.runId, this.stageId, prompt.id);
+    if (draft !== undefined) return draft;
+    return typeof prompt.initial === "string" ? prompt.initial : "";
+  }
+
+  private _seedPromptTextState(prompt: PendingPrompt): void {
+    if (prompt.kind !== "input" && prompt.kind !== "editor") return;
+    if (!this.promptState || this.promptState.prompt.id !== prompt.id) return;
+    const seed = this._promptSeedText(prompt);
+    this.promptState.rawText = seed;
+    this.promptState.caret = seed.length;
+  }
+
+  private _recordPromptDraft(promptId: string, text: string): void {
+    this.store.recordStagePromptDraft(this.runId, this.stageId, promptId, text);
+  }
+
+  private _recordCurrentPromptDraft(): void {
+    const state = this.promptState;
+    if (!state) return;
+    const prompt = state.prompt;
+    if (prompt.kind !== "input" && prompt.kind !== "editor") return;
+    const text = this.promptEditor && this.promptEditorPromptId === prompt.id
+      ? this.promptEditor.getText()
+      : state.rawText;
+    this._recordPromptDraft(prompt.id, text);
+  }
+
   private _resetPromptEditor(prompt: PendingPrompt): void {
     this._disposePromptEditor();
     if ((prompt.kind !== "input" && prompt.kind !== "editor") || !this.piTui) return;
     const editor = this.piEditorFactory
       ? this.piEditorFactory(this.piTui, editorThemeFromGraphTheme(this.theme), this.piKeybindings)
       : new Editor(this.piTui, editorThemeFromGraphTheme(this.theme), { paddingX: 0 });
-    editor.setText(typeof prompt.initial === "string" ? prompt.initial : "");
+    editor.setText(this.promptState?.prompt.id === prompt.id ? this.promptState.rawText : this._promptSeedText(prompt));
     setEditorPlaceholder(editor, "Type your response…");
     setEditorBorderColor(editor, (text) => hexToAnsi(this.theme.accent) + text + RESET);
     editor.onChange = (text: string) => {
       if (this.promptState?.prompt.id !== prompt.id) return;
       this.promptState.rawText = text;
       this.promptState.caret = text.length;
+      this._recordPromptDraft(prompt.id, text);
       this.requestRender?.();
     };
     editor.onSubmit = (text: string) => {
@@ -634,11 +665,12 @@ export class StageChatView implements Component, Focusable {
     const [command, ...rest] = text.trim().split(/\s+/);
     switch (command) {
       case "/compact": {
+        if (rest.length > 0) return true;
         const handle = this._liveHandle();
         if (!handle) return false;
         await handle.ensureAttached();
         if (!handle.agentSession) return false;
-        await handle.agentSession.compact(rest.join(" ") || undefined);
+        await handle.agentSession.compact();
         return true;
       }
       case "/quit":
@@ -1248,11 +1280,14 @@ export class StageChatView implements Component, Focusable {
       return;
     }
     const action = handlePromptCardInput(data, state, this._promptKeybindings());
+    const prompt = state.prompt;
+    if (prompt.kind === "input" || prompt.kind === "editor") {
+      this._recordPromptDraft(prompt.id, state.rawText);
+    }
     if (action.kind === "noop") {
       this.requestRender?.();
       return;
     }
-    const prompt = state.prompt;
     const response = action.kind === "submit"
       ? action.response
       : defaultResponseFor(prompt);
@@ -1306,6 +1341,7 @@ export class StageChatView implements Component, Focusable {
     const readOnlyPromptArchive = readOnlyArchive && stage?.promptFootprint !== undefined;
     if (matchesKey(data, Key.ctrl("d"))) {
       if (!this.promptState && this.chatHost.hasInputText()) return this.chatHost.handleInput(data);
+      this._recordCurrentPromptDraft();
       this.onDetach();
       return true;
     }

package/dist/builtin/workflows/src/tui/store-widget-installer.ts

@@ -160,121 +160,125 @@ export function installToolExecutionHooks(pi: LiveWidgetAPI, storeInstance: Stor
   const extensionOn = pi.on;
   if (typeof eventBusOn !== "function" && typeof extensionOn !== "function") return;
 
-  const activeAskUserQuestionCalls = new Map<string, { runId: string; stageId: string; callId: string }>();
+  interface StageScope {
+    readonly runId: string;
+    readonly stageId: string;
+  }
 
-  function resolveIds(payload: ToolExecutionStartPayload, includeAwaitingInput = false): { runId: string; stageId: string } | null {
-    const runId = payload.runId ?? payload.run_id ?? storeInstance.activeRunId();
-    if (!runId) return null;
+  interface ActiveToolCall extends StageScope {
+    readonly callId: string;
+    readonly name: string;
+    readonly startedAt: number;
+  }
 
-    const stageId = payload.stageId ?? payload.stage_id;
-    if (stageId) return { runId, stageId };
+  const terminalRunStatuses = new Set(["completed", "failed", "killed"]);
+  const terminalStageStatuses = new Set(["completed", "failed", "skipped"]);
+  const activeToolCalls = new Map<string, ActiveToolCall>();
 
-    const run = storeInstance.runs().find((candidate) => candidate.id === runId);
-    const runningStage = run?.stages.find((s) => s.status === "running");
-    if (runningStage) return { runId, stageId: runningStage.id };
+  function activeCallKey(runId: string, stageId: string, callId: string): string {
+    return `${runId}\0${stageId}\0${callId}`;
+  }
 
-    if (includeAwaitingInput) {
-      const awaitingStage = run?.stages.find((s) => s.status === "awaiting_input");
-      if (awaitingStage) return { runId, stageId: awaitingStage.id };
+  function firstNonEmptyString(...values: readonly unknown[]): string | null {
+    for (const value of values) {
+      if (typeof value === "string" && value.length > 0) return value;
     }
-
     return null;
   }
 
-  function activeCallKey(runId: string, stageId: string, callId: string): string {
-    return `${runId}:${stageId}:${callId}`;
+  function resolveExplicitStageScope(payload: ToolExecutionStartPayload): StageScope | null {
+    const runId = firstNonEmptyString(payload.runId, payload.run_id);
+    const stageId = firstNonEmptyString(payload.stageId, payload.stage_id);
+    if (runId === null || stageId === null) return null;
+    return { runId, stageId };
   }
 
-  function findActiveAskCall(payload: ToolExecutionStartPayload): { runId: string; stageId: string; callId: string } | undefined {
-    const runId = payload.runId ?? payload.run_id;
-    const stageId = payload.stageId ?? payload.stage_id;
-    const callId = toolCallId(payload);
+  function hasLiveStageScope(scope: StageScope, snap: StoreSnapshot): boolean {
+    const run = snap.runs.find((candidate) => candidate.id === scope.runId);
+    if (!run || run.endedAt !== undefined || terminalRunStatuses.has(run.status)) return false;
+    const stage = run.stages.find((candidate) => candidate.id === scope.stageId);
+    return stage !== undefined && !terminalStageStatuses.has(stage.status);
+  }
 
-    if (runId !== undefined && stageId !== undefined) {
-      return activeAskUserQuestionCalls.get(activeCallKey(runId, stageId, callId));
+  function pruneActiveToolCalls(snap: StoreSnapshot): void {
+    for (const [key, call] of activeToolCalls) {
+      if (!hasLiveStageScope(call, snap)) activeToolCalls.delete(key);
     }
-
-    const matches = [...activeAskUserQuestionCalls.values()].filter((entry) => {
-      if (entry.callId !== callId) return false;
-      if (runId !== undefined && entry.runId !== runId) return false;
-      if (stageId !== undefined && entry.stageId !== stageId) return false;
-      return true;
-    });
-    return matches.length === 1 ? matches[0] : undefined;
   }
 
-  function stageHasActiveAskCall(runId: string, stageId: string): boolean {
-    return [...activeAskUserQuestionCalls.values()].some(
-      (entry) => entry.runId === runId && entry.stageId === stageId,
-    );
-  }
+  function activeToolCallForPayload(payload: ToolExecutionStartPayload): { key: string; call: ActiveToolCall } | null {
+    const scope = resolveExplicitStageScope(payload);
+    if (!scope) return null;
 
-  function recordAskUserQuestionStart(payload: ToolExecutionStartPayload, ids: { runId: string; stageId: string }): void {
-    if (!isAskUserQuestionToolName(toolName(payload))) return;
-    const callId = toolCallId(payload);
-    activeAskUserQuestionCalls.set(activeCallKey(ids.runId, ids.stageId, callId), {
-      ...ids,
-      callId,
-    });
-    storeInstance.recordStageAwaitingInput(ids.runId, ids.stageId, true, payload.ts);
+    const key = activeCallKey(scope.runId, scope.stageId, toolCallId(payload));
+    const call = activeToolCalls.get(key);
+    return call ? { key, call } : null;
   }
 
-  function recordAskUserQuestionEnd(payload: ToolExecutionStartPayload, ids: { runId: string; stageId: string } | null): void {
-    const activeCall = findActiveAskCall(payload);
-    const resolvedIds = activeCall ?? ids;
-    if (resolvedIds === null || resolvedIds === undefined) return;
-
-    const shouldClear = activeCall !== undefined || isAskUserQuestionToolName(toolName(payload));
-    if (!shouldClear) return;
-
-    activeAskUserQuestionCalls.delete(activeCallKey(resolvedIds.runId, resolvedIds.stageId, toolCallId(payload)));
-    if (!stageHasActiveAskCall(resolvedIds.runId, resolvedIds.stageId)) {
-      storeInstance.recordStageAwaitingInput(resolvedIds.runId, resolvedIds.stageId, false);
-    }
-  }
+  storeInstance.subscribe(pruneActiveToolCalls);
 
   function recordToolStart(payload: unknown): void {
     if (!isToolExecutionPayload(payload)) return;
 
-    const ids = resolveIds(payload);
-    if (!ids) return;
+    const snap = storeInstance.snapshot();
+    pruneActiveToolCalls(snap);
+
+    const scope = resolveExplicitStageScope(payload);
+    if (!scope || !hasLiveStageScope(scope, snap)) return;
 
-    storeInstance.recordToolStart(ids.runId, ids.stageId, {
-      name: toolName(payload),
+    const callId = toolCallId(payload);
+    const key = activeCallKey(scope.runId, scope.stageId, callId);
+    if (activeToolCalls.has(key)) return;
+
+    const name = toolName(payload);
+    const startedAt = payload.ts ?? Date.now();
+    activeToolCalls.set(key, { ...scope, callId, name, startedAt });
+    storeInstance.recordToolStart(scope.runId, scope.stageId, {
+      name,
       input: toolInput(payload),
-      startedAt: payload.ts ?? Date.now(),
+      startedAt,
     });
-    recordAskUserQuestionStart(payload, ids);
+  }
+
+  function recordToolUpdate(payload: unknown): void {
+    if (!isToolExecutionPayload(payload)) return;
+
+    pruneActiveToolCalls(storeInstance.snapshot());
+
+    if (!activeToolCallForPayload(payload)) return;
+    // Updates are attach-only until the store has an explicit update API.
   }
 
   function recordToolEnd(payload: unknown): void {
     if (!isToolExecutionPayload(payload)) return;
 
-    const activeAskCall = findActiveAskCall(payload);
-    const ids = activeAskCall ?? resolveIds(payload, false);
-    if (!ids) return;
+    pruneActiveToolCalls(storeInstance.snapshot());
 
-    storeInstance.recordToolEnd(ids.runId, ids.stageId, {
-      name: toolName(payload),
+    const active = activeToolCallForPayload(payload);
+    if (!active) return;
+
+    storeInstance.recordToolEnd(active.call.runId, active.call.stageId, {
+      name: active.call.name,
       input: toolInput(payload),
-      startedAt: payload.ts ?? Date.now(),
+      startedAt: active.call.startedAt,
       endedAt: payload.endedAt ?? payload.ended_at ?? Date.now(),
       output: payload.output,
     });
-    recordAskUserQuestionEnd(payload, activeAskCall ?? ids);
+    activeToolCalls.delete(active.key);
   }
 
   const safeStart = safelyHandle(recordToolStart);
+  const safeUpdate = safelyHandle(recordToolUpdate);
   const safeEnd = safelyHandle(recordToolEnd);
 
   if (typeof eventBusOn === "function") {
     eventBusOn.call(pi.events, "tool_execution_start", safeStart);
-    eventBusOn.call(pi.events, "tool_execution_update", safeStart);
+    eventBusOn.call(pi.events, "tool_execution_update", safeUpdate);
     eventBusOn.call(pi.events, "tool_execution_end", safeEnd);
   }
   if (typeof extensionOn === "function") {
     extensionOn.call(pi, "tool_execution_start", safeStart);
-    extensionOn.call(pi, "tool_execution_update", safeStart);
+    extensionOn.call(pi, "tool_execution_update", safeUpdate);
     extensionOn.call(pi, "tool_execution_end", safeEnd);
     extensionOn.call(pi, "tool_call", safeStart);
     extensionOn.call(pi, "tool_result", safeEnd);
@@ -306,7 +310,3 @@ function toolCallId(payload: ToolExecutionStartPayload): string {
 function toolInput(payload: ToolExecutionStartPayload): Record<string, unknown> | undefined {
   return payload.input ?? payload.args;
 }
-
-function isAskUserQuestionToolName(name: string): boolean {
-  return name.toLowerCase().replace(/[^a-z0-9]/g, "") === "askuserquestion";
-}

package/dist/core/agent-session.d.ts

@@ -15,7 +15,7 @@
 import type { Agent, AgentEvent, AgentMessage, AgentState, AgentTool, ThinkingLevel } from "@earendil-works/pi-agent-core";
 import type { Api, ImageContent, Model, TextContent } from "@earendil-works/pi-ai";
 import { type BashResult } from "./bash-executor.ts";
-import { type CompactionResult } from "./compaction/index.ts";
+import { type CompactionResult, type ContextCompactionResult } from "./compaction/index.ts";
 import { type ContextUsage, type ExtensionCommandContextActions, type ExtensionErrorListener, ExtensionRunner, type ExtensionUIContext, type InputSource, type OrchestrationContext, type ReplacedSessionContext, type SendMessageOptions, type SessionStartEvent, type ShutdownHandler, type ToolDefinition, type ToolInfo } from "./extensions/index.ts";
 import type { CustomMessage } from "./messages.ts";
 import type { ModelRegistry } from "./model-registry.ts";
@@ -44,6 +44,9 @@ export type AgentSessionEvent = AgentEvent | {
 } | {
     type: "compaction_start";
     reason: "manual" | "threshold" | "overflow";
+} | {
+    type: "context_compaction_start";
+    reason: "manual";
 } | {
     type: "session_info_changed";
     name: string | undefined;
@@ -58,10 +61,17 @@ export type AgentSessionEvent = AgentEvent | {
 } | {
     type: "compaction_end";
     reason: "manual" | "threshold" | "overflow";
-    result: CompactionResult | undefined;
+    result: CompactionResult | ContextCompactionResult | undefined;
     aborted: boolean;
     willRetry: boolean;
     errorMessage?: string;
+} | {
+    type: "context_compaction_end";
+    reason: "manual";
+    result: ContextCompactionResult | undefined;
+    aborted: boolean;
+    willRetry: false;
+    errorMessage?: string;
 } | {
     type: "auto_retry_start";
     attempt: number;
@@ -473,12 +483,17 @@ export declare class AgentSession {
      * Saves to settings.
      */
     setFollowUpMode(mode: "all" | "one-at-a-time"): void;
+    private _applyContextVerbatimCompaction;
+    /**
+     * Manually compact the session context using deletion-only verbatim context compaction.
+     * Aborts current agent operation first. Custom summary instructions are not accepted.
+     */
+    compact(customInstructions?: string): Promise<ContextCompactionResult>;
     /**
-     * Manually compact the session context.
-     * Aborts current agent operation first.
-     * @param customInstructions Optional instructions for the compaction summary
+     * Manually compact the session context by applying validated logical deletions.
+     * Retained transcript entries/content blocks stay verbatim; no user prompt text is accepted.
      */
-    compact(customInstructions?: string): Promise<CompactionResult>;
+    contextCompact(): Promise<ContextCompactionResult>;
     /**
      * Cancel in-progress compaction (manual or auto).
      */
@@ -488,6 +503,18 @@ export declare class AgentSession {
      */
     abortBranchSummary(): void;
     private _checkCompaction;
+    /**
+     * Internal: remove the trailing overflow error from retry context if it is still present.
+     */
+    private _dropTrailingOverflowAssistantErrorIfPresent;
+    /**
+     * Internal: schedule a live post-event continuation probe after compaction_end listeners can flush queues.
+     */
+    private _schedulePostAutoCompactionContinuationProbe;
+    /**
+     * Internal: resume generation after successful auto-compaction only when active work remains.
+     */
+    private _resumeAfterAutoCompaction;
     private _runAutoCompaction;
     /**
      * Toggle auto-compaction setting.