@bastani/atomic 0.8.6-0 → 0.8.7-0

package/dist/builtin/workflows/src/extension/index.ts

@@ -1173,10 +1173,19 @@ function factory(pi: ExtensionAPI): void {
   // noopOverlay returned when pi.ui?.custom is absent (degraded runtime).
   const overlay: GraphOverlayPort = buildGraphOverlayAdapter(pi, store, {
     onKillRun: (runId) => {
-      destroyRun(runId, {
+      const run = store.runs().find((r) => r.id === runId);
+      const result = destroyRun(runId, {
         cancellation: cancellationRegistry,
         persistence: persistenceRef.current,
       });
+      if (run && result.ok) {
+        emitChatSurface(pi, {
+          kind: "killed",
+          run,
+          previousStatus: result.previousStatus,
+          wasInFlight: result.wasInFlight,
+        });
+      }
     },
   });
 
@@ -1453,6 +1462,14 @@ function factory(pi: ExtensionAPI): void {
             cancellation: cancellationRegistry,
             persistence: persistenceRef.current,
           });
+          if (killed.ok) {
+            emitChatSurface(pi, {
+              kind: "killed",
+              run,
+              previousStatus: killed.previousStatus,
+              wasInFlight: killed.wasInFlight,
+            });
+          }
           print(
             killed.ok
               ? `Run ${killed.runId.slice(0, 8)} killed and removed.`
@@ -1632,6 +1649,14 @@ function factory(pi: ExtensionAPI): void {
         persistence: persistenceRef.current,
       });
       if (result.ok) {
+        if (run) {
+          emitChatSurface(pi, {
+            kind: "killed",
+            run,
+            previousStatus: result.previousStatus,
+            wasInFlight: result.wasInFlight,
+          });
+        }
         print(
           `Run ${result.runId.slice(0, 8)} killed and removed (was ${result.previousStatus}).`,
         );
@@ -1696,9 +1721,12 @@ function factory(pi: ExtensionAPI): void {
         stageId = byName.id;
       }
       overlay.open(runId, overlaySurfaceFromContext(ctx), stageId);
+      const attachedStage = stageId ? run?.stages.find((s) => s.id === stageId) : undefined;
       print(
         stageId
-          ? `Attached to ${runId.slice(0, 8)} stage ${stageId.slice(0, 8)}. ctrl+d return to graph · esc close.`
+          ? attachedStage?.status === "paused"
+            ? `Attached to ${runId.slice(0, 8)} stage ${stageId.slice(0, 8)}. ctrl+d close · esc close.`
+            : `Attached to ${runId.slice(0, 8)} stage ${stageId.slice(0, 8)}. ctrl+d return to graph · esc close.`
           : `Attached to ${runId.slice(0, 8)}. ↵ chat · ctrl+d detach.`,
       );
       return true;

package/dist/builtin/workflows/src/runs/background/status.ts

@@ -70,6 +70,9 @@ export interface RunDetail {
   readonly startedAt: number;
   readonly endedAt?: number;
   readonly durationMs?: number;
+  readonly pausedDurationMs?: number;
+  readonly pausedAt?: number;
+  readonly resumedAt?: number;
   readonly inputs: Readonly<Record<string, unknown>>;
   readonly stages: readonly RunSnapshot["stages"][number][];
   readonly result?: Record<string, unknown>;
@@ -433,6 +436,9 @@ export function inspectRun(
     startedAt: copy.startedAt,
     endedAt: copy.endedAt,
     durationMs: copy.durationMs,
+    pausedDurationMs: copy.pausedDurationMs,
+    pausedAt: copy.pausedAt,
+    resumedAt: copy.resumedAt,
     inputs: copy.inputs,
     stages: copy.stages,
     result: copy.result,

package/dist/builtin/workflows/src/runs/foreground/executor.ts

@@ -51,6 +51,7 @@ import {
   type WorktreeSetup,
 } from "../shared/worktree.js";
 import { store as defaultStore } from "../../shared/store.js";
+import { elapsedStageMs } from "../../shared/timing.js";
 import {
   appendRunStart,
   appendStageStart,
@@ -1520,10 +1521,7 @@ export async function run<TInputs extends Record<string, unknown>>(
           throw err;
         } finally {
           stageSnapshot.endedAt = Date.now();
-          stageSnapshot.durationMs =
-            stageSnapshot.startedAt !== undefined
-              ? stageSnapshot.endedAt - stageSnapshot.startedAt
-              : undefined;
+          stageSnapshot.durationMs = elapsedStageMs(stageSnapshot, stageSnapshot.endedAt);
 
           const finalModelMeta = innerCtx.__modelFallbackMeta();
           if (finalModelMeta.model !== undefined) stageSnapshot.model = finalModelMeta.model;

package/dist/builtin/workflows/src/runs/foreground/stage-runner.ts

@@ -174,7 +174,7 @@ type MessageWithTextContent = {
   readonly content?: string | readonly TextLikeContent[];
 };
 
-function extractAssistantText(message: AgentSession["messages"][number]): string {
+function extractMessageText(message: AgentSession["messages"][number]): string {
   const { content } = message as MessageWithTextContent;
   if (typeof content === "string") return content;
   if (Array.isArray(content)) {
@@ -186,11 +186,11 @@ function extractAssistantText(message: AgentSession["messages"][number]): string
   return "";
 }
 
-function lastAssistantTextFromMessages(messages: AgentSession["messages"]): string | undefined {
+function lastOutputTextFromMessages(messages: AgentSession["messages"]): string | undefined {
   for (let index = messages.length - 1; index >= 0; index -= 1) {
     const message = messages[index];
-    if (!message || message.role !== "assistant") continue;
-    const text = extractAssistantText(message).trim();
+    if (!message || (message.role !== "assistant" && message.role !== "toolResult")) continue;
+    const text = extractMessageText(message).trim();
     if (text) return text;
   }
   return undefined;
@@ -217,7 +217,7 @@ function lastAssistantTextFromSession(
   if (!activeSession) return fallback;
   const direct = activeSession.getLastAssistantText?.();
   if (direct !== undefined && direct.trim()) return direct;
-  return lastAssistantTextFromMessages(activeSession.messages) ?? direct ?? fallback;
+  return lastOutputTextFromMessages(activeSession.messages) ?? direct ?? fallback;
 }
 
 const DEFAULT_MAX_OUTPUT_BYTES = 200 * 1024;

package/dist/builtin/workflows/src/shared/store-types.ts

@@ -101,6 +101,8 @@ export interface StageSnapshot {
   attachable?: boolean;
   /** True while a user pane is actively attached to this stage. */
   attached?: boolean;
+  /** Milliseconds spent paused across completed pause intervals. */
+  pausedDurationMs?: number;
   /** Timestamp set when a controlled pause begins; cleared on resume. */
   pausedAt?: number;
   /** Timestamp recorded on the most recent resume from a paused state. */
@@ -116,6 +118,12 @@ export interface RunSnapshot {
   startedAt: number;
   endedAt?: number;
   durationMs?: number;
+  /** Milliseconds spent paused across completed pause intervals. */
+  pausedDurationMs?: number;
+  /** Timestamp set when a controlled pause begins; cleared on resume. */
+  pausedAt?: number;
+  /** Timestamp recorded on the most recent resume from a paused state. */
+  resumedAt?: number;
   result?: Record<string, unknown>;
   error?: string;
   /**

package/dist/builtin/workflows/src/shared/store.ts

@@ -13,6 +13,7 @@ import type {
   RunStatus,
   WorkflowNotice,
 } from "./store-types.js";
+import { accumulatePausedDurationMs, elapsedRunMs } from "./timing.js";
 
 /** Statuses that represent a terminal run state — cannot be overwritten. */
 const TERMINAL_STATUSES: ReadonlySet<RunStatus> = new Set(["completed", "failed", "killed"]);
@@ -263,6 +264,14 @@ export function createStore(): Store {
       if (!existing) return;
       existing.status = stage.status;
       existing.endedAt = stage.endedAt;
+      if (existing.endedAt !== undefined && existing.pausedAt !== undefined) {
+        existing.pausedDurationMs = accumulatePausedDurationMs(
+          existing.pausedDurationMs,
+          existing.pausedAt,
+          existing.endedAt,
+        );
+        existing.pausedAt = undefined;
+      }
       existing.durationMs = stage.durationMs;
       existing.result = stage.result;
       existing.error = stage.error;
@@ -283,7 +292,15 @@ export function createStore(): Store {
       if (TERMINAL_STATUSES.has(run.status)) return false;
       run.status = status;
       run.endedAt = Date.now();
-      run.durationMs = run.endedAt - run.startedAt;
+      if (run.pausedAt !== undefined) {
+        run.pausedDurationMs = accumulatePausedDurationMs(
+          run.pausedDurationMs,
+          run.pausedAt,
+          run.endedAt,
+        );
+        run.pausedAt = undefined;
+      }
+      run.durationMs = elapsedRunMs(run, run.endedAt);
       if (status === "completed" && result !== undefined) {
         run.result = result;
       }
@@ -547,8 +564,16 @@ export function createStore(): Store {
       const stage = findStage(run, stageId);
       if (!stage) return false;
       if (stage.status !== "paused" && stage.status !== "blocked") return false;
+      const resumedTs = resumedAt ?? Date.now();
       stage.status = "running";
-      stage.resumedAt = resumedAt ?? Date.now();
+      if (stage.startedAt !== undefined) {
+        stage.pausedDurationMs = accumulatePausedDurationMs(
+          stage.pausedDurationMs,
+          stage.pausedAt,
+          resumedTs,
+        );
+      }
+      stage.resumedAt = resumedTs;
       stage.pausedAt = undefined;
       delete stage.blockedByStageId;
       delete stage.awaitingInputSince;
@@ -557,23 +582,33 @@ export function createStore(): Store {
       return true;
     },
 
-    recordRunPaused(runId: string, _pausedAt?: number): boolean {
+    recordRunPaused(runId: string, pausedAt?: number): boolean {
       const run = findRun(runId);
       if (!run) return false;
       if (TERMINAL_STATUSES.has(run.status)) return false;
       if (run.status === "paused") return false;
       run.status = "paused";
+      run.pausedAt = pausedAt ?? Date.now();
+      run.resumedAt = undefined;
       _version++;
       notify();
       return true;
     },
 
-    recordRunResumed(runId: string, _resumedAt?: number): boolean {
+    recordRunResumed(runId: string, resumedAt?: number): boolean {
       const run = findRun(runId);
       if (!run) return false;
       if (TERMINAL_STATUSES.has(run.status)) return false;
       if (run.status !== "paused") return false;
+      const resumedTs = resumedAt ?? Date.now();
       run.status = "running";
+      run.pausedDurationMs = accumulatePausedDurationMs(
+        run.pausedDurationMs,
+        run.pausedAt,
+        resumedTs,
+      );
+      run.resumedAt = resumedTs;
+      run.pausedAt = undefined;
       _version++;
       notify();
       return true;

package/dist/builtin/workflows/src/shared/timing.ts

@@ -0,0 +1,48 @@
+interface StageTimerSnapshot {
+  readonly startedAt?: number;
+  readonly durationMs?: number;
+  readonly pausedDurationMs?: number;
+  readonly pausedAt?: number;
+}
+
+interface RunTimerSnapshot {
+  readonly startedAt: number;
+  readonly durationMs?: number;
+  readonly pausedDurationMs?: number;
+  readonly pausedAt?: number;
+}
+
+function nonNegative(ms: number): number {
+  return Math.max(0, ms);
+}
+
+function elapsedFromStart(
+  startedAt: number,
+  now: number,
+  pausedDurationMs: number | undefined,
+  pausedAt: number | undefined,
+): number {
+  const completedPausedSegment = pausedDurationMs ?? 0;
+  const activePausedSegment = pausedAt === undefined ? 0 : nonNegative(now - pausedAt);
+  return nonNegative(now - startedAt - completedPausedSegment - activePausedSegment);
+}
+
+export function accumulatePausedDurationMs(
+  pausedDurationMs: number | undefined,
+  pausedAt: number | undefined,
+  resumedAt: number,
+): number {
+  if (pausedAt === undefined) return pausedDurationMs ?? 0;
+  return (pausedDurationMs ?? 0) + nonNegative(resumedAt - pausedAt);
+}
+
+export function elapsedStageMs(stage: StageTimerSnapshot, now = Date.now()): number | undefined {
+  if (stage.durationMs !== undefined) return nonNegative(stage.durationMs);
+  if (stage.startedAt === undefined) return undefined;
+  return elapsedFromStart(stage.startedAt, now, stage.pausedDurationMs, stage.pausedAt);
+}
+
+export function elapsedRunMs(run: RunTimerSnapshot, now = Date.now()): number {
+  if (run.durationMs !== undefined) return nonNegative(run.durationMs);
+  return elapsedFromStart(run.startedAt, now, run.pausedDurationMs, run.pausedAt);
+}

package/dist/builtin/workflows/src/tui/chat-surface-message.ts

@@ -27,13 +27,14 @@
 
 import type { ExtensionAPI } from "../extension/index.js";
 import type { RunDetail } from "../runs/background/status.js";
-import type { RunSnapshot } from "../shared/store-types.js";
+import type { RunSnapshot, RunStatus } from "../shared/store-types.js";
 import type { GraphTheme } from "./graph-theme.js";
 import type { WorkflowListEntry } from "./workflow-list.js";
 import { renderDispatchConfirm } from "./dispatch-confirm.js";
 import { renderRunDetail } from "./run-detail.js";
 import { renderStatusList } from "./status-list.js";
 import { renderWorkflowList } from "./workflow-list.js";
+import { renderWorkflowKilledNotice } from "./session-confirm.js";
 
 /** Custom message type wired to {@link registerChatSurfaceRenderer}. */
 export const CHAT_SURFACE_CUSTOM_TYPE = "workflows:chat-surface";
@@ -78,11 +79,20 @@ export interface DetailPayload {
   detail: RunDetail;
 }
 
+/** Inline notice after a workflow run is destructively killed and removed. */
+export interface KilledPayload {
+  kind: "killed";
+  run: RunSnapshot;
+  previousStatus: RunStatus;
+  wasInFlight: boolean;
+}
+
 export type ChatSurfacePayload =
   | DispatchPayload
   | StatusPayload
   | ListPayload
-  | DetailPayload;
+  | DetailPayload
+  | KilledPayload;
 
 // ---------------------------------------------------------------------------
 // Renderer registration
@@ -177,6 +187,7 @@ function describePayload(payload: ChatSurfacePayload): string {
     case "status":   return `status · ${payload.runs.length} run${payload.runs.length === 1 ? "" : "s"}`;
     case "list":     return `workflows · ${payload.entries.length} registered`;
     case "detail":   return `run detail · ${payload.detail.runId.slice(0, 8)}`;
+    case "killed":   return `workflow killed · ${payload.run.id.slice(0, 8)}`;
   }
 }
 
@@ -220,5 +231,13 @@ function renderPayload(
       // hint is unused — its surface mirrors the orchestrator panel
       // (outline-pill chrome), not the flex chat band.
       return renderRunDetail(payload.detail, { theme });
+    case "killed":
+      return renderWorkflowKilledNotice({
+        width,
+        theme,
+        run: payload.run,
+        previousStatus: payload.previousStatus,
+        wasInFlight: payload.wasInFlight,
+      }).join("\n");
   }
 }

package/dist/builtin/workflows/src/tui/graph-view.ts

@@ -30,6 +30,7 @@ import type {
   StoreSnapshot,
   RunSnapshot,
 } from "../shared/store-types.js";
+import { elapsedStageMs } from "../shared/timing.js";
 import type { GraphTheme } from "./graph-theme.js";
 import type { SwitcherState } from "./switcher.js";
 import type { LayoutNode } from "./layout.js";
@@ -146,8 +147,8 @@ const OVERLAY_VERTICAL_MARGIN_ROWS = 1;
 
 /**
  * Animation tick period. Overlay re-renders fire on this cadence so
- * duration counters (rendered from `Date.now() - stage.startedAt`)
- * tick and the running-stage border lerps between `borderDim` and
+ * duration counters tick from active elapsed time (freezing while paused)
+ * and the running-stage border lerps between `borderDim` and
  * `warning` without a key press. The host-supplied `requestRender`
  * gate prevents work while the overlay is hidden or unfocused.
  */
@@ -964,10 +965,8 @@ export class GraphView implements Component {
   }
 
   private _duration(stage: StageSnapshot): string {
-    if (stage.durationMs != null) return fmtDuration(stage.durationMs);
-    if (stage.startedAt != null)
-      return fmtDuration(Date.now() - stage.startedAt);
-    return "";
+    const elapsed = elapsedStageMs(stage);
+    return elapsed === undefined ? "" : fmtDuration(elapsed);
   }
 
   private _counts(run: RunSnapshot): {
@@ -1051,13 +1050,13 @@ export class GraphView implements Component {
     // Vertical-graph navigation: up/down step between depth levels
     // (col), left/right step between siblings at the same depth (row).
     // j/k preserved as a flat-order fallback for muscle memory.
-    if (matchesKey(data, "down") || data === "\x1b[B")
+    if (matchesKey(data, "down"))
       return this._moveByDepth(+1);
-    if (matchesKey(data, "up") || data === "\x1b[A")
+    if (matchesKey(data, "up"))
       return this._moveByDepth(-1);
-    if (matchesKey(data, "right") || data === "\x1b[C")
+    if (matchesKey(data, "right"))
       return this._moveBySibling(+1);
-    if (matchesKey(data, "left") || data === "\x1b[D")
+    if (matchesKey(data, "left"))
       return this._moveBySibling(-1);
     if (matchesKey(data, "j")) {
       this._setFocusedIndex(Math.min(this.focusedIndex + 1, stageCount - 1));
@@ -1082,7 +1081,7 @@ export class GraphView implements Component {
       this.switcherState = { query: "", selectedIndex: 0 };
       return true;
     }
-    if (matchesKey(data, "enter") || data === "\r" || data === "\n") {
+    if (matchesKey(data, "enter")) {
       // Enter attaches the popup interior to the focused stage. The
       // attach shell swaps in the stage-chat view without remounting
       // the overlay; without a callback, fall back to the legacy
@@ -1093,7 +1092,7 @@ export class GraphView implements Component {
     }
     // `ctrl+d` detaches the whole popup (host hides the overlay). This
     // is the graph-mode counterpart of the in-chat back affordance.
-    if (data === "\x04") {
+    if (matchesKey(data, "ctrl+d")) {
       if (this.onDetach) {
         this.onDetach();
       } else if (this.onHide) {
@@ -1115,7 +1114,7 @@ export class GraphView implements Component {
       this.onHide();
       return true;
     }
-    if (matchesKey(data, "escape") || data === "\x1b" || data === "\x03") {
+    if (matchesKey(data, "escape") || matchesKey(data, "ctrl+c")) {
       this.onClose?.();
       return true;
     }
@@ -1126,11 +1125,11 @@ export class GraphView implements Component {
     const run = this._getCurrentRun();
     const stages = run?.stages ?? [];
 
-    if (matchesKey(data, "escape") || data === "\x1b") {
+    if (matchesKey(data, "escape")) {
       this.switcherOpen = false;
       return true;
     }
-    if (matchesKey(data, "enter") || data === "\r" || data === "\n") {
+    if (matchesKey(data, "enter")) {
       const filtered = filterStages(stages, this.switcherState.query);
       const selected = filtered[this.switcherState.selectedIndex];
       if (selected) {
@@ -1149,7 +1148,7 @@ export class GraphView implements Component {
       this.switcherOpen = false;
       return true;
     }
-    if (matchesKey(data, "down") || data === "\x1b[B") {
+    if (matchesKey(data, "down")) {
       const filtered = filterStages(stages, this.switcherState.query);
       this.switcherState = {
         ...this.switcherState,
@@ -1160,14 +1159,14 @@ export class GraphView implements Component {
       };
       return true;
     }
-    if (matchesKey(data, "up") || data === "\x1b[A") {
+    if (matchesKey(data, "up")) {
       this.switcherState = {
         ...this.switcherState,
         selectedIndex: Math.max(this.switcherState.selectedIndex - 1, 0),
       };
       return true;
     }
-    if (data === "\x7f" || data === "\b") {
+    if (matchesKey(data, "backspace")) {
       this.switcherState = {
         query: this.switcherState.query.slice(0, -1),
         selectedIndex: 0,

package/dist/builtin/workflows/src/tui/inline-form-card.ts

@@ -25,7 +25,7 @@
  *   ╰──────────────────────────────────────────────────────────────────╯
  *     integer  ·  optional  ·  loop count
  *
- *   ╭ EDIT ╮  tab next  ·  shift+tab prev  ·  ctrl+enter run  ·  esc cancel
+ *   ╭ EDIT ╮  tab next  ·  shift+tab prev  ·  ctrl+x run  ·  esc cancel
  *   │ EDIT │
  *   ╰──────╯
  *
@@ -193,7 +193,7 @@ function renderFooterBand(theme: GraphTheme, width: number): string[] {
   const hints: Array<{ key: string; label: string }> = [
     { key: "tab", label: "Next" },
     { key: "shift+tab", label: "Prev" },
-    { key: "ctrl+enter", label: "Run" },
+    { key: "ctrl+x", label: "Run" },
     { key: "esc", label: "Cancel" },
   ];
   const sep = `${chromeBg}  ${dim}·${RESET}${chromeBg}  `;

package/dist/builtin/workflows/src/tui/inline-form-editor.ts

@@ -16,13 +16,13 @@
  *   space               — boolean toggle
  *   enter               — newline (text) | otherwise next field
  *   printable ASCII     — insert at caret (text/string/number)
- *   ctrl+enter          — submit form (if valid)
+ *   ctrl+x          — submit form (if valid)
  *   esc / ctrl+c        — cancel form
  *
  * Editor-mode keys (cursor movement, word jumps, deletions) route through
  * the Pi `KeybindingsManager` injected by the host at factory time, so any
  * user-configured keybinding overrides surfaces here as well. Form-level
- * keys (tab/shift+tab/ctrl+enter/esc/ctrl+c) stay as raw byte checks because
+ * keys (tab/shift+tab/ctrl+x/esc/ctrl+c) stay as raw byte checks because
  * they are workflow form contract, not Pi-configurable actions.
  *
  * On submit/cancel the editor calls back to the orchestrator which:
@@ -57,14 +57,14 @@ import {
   wordLeft,
   wordRight,
 } from "./keybindings-adapter.js";
-import { matchesKey, visibleWidth } from "./text-helpers.js";
+import { decodePrintableKey, matchesKey, visibleWidth } from "./text-helpers.js";
 
 export type FormEditorOutcome = "submit" | "cancel";
 
 export interface InlineFormEditorOpts {
   formId: string;
   theme: GraphTheme;
-  /** Called when Ctrl+Enter passes validation or cancel fires. */
+  /** Called when Ctrl+X passes validation or cancel fires. */
   onExit: (outcome: FormEditorOutcome) => void;
   /**
    * Pi's `KeybindingsManager` injected as the third arg of the editor
@@ -433,14 +433,14 @@ export class InlineFormEditor implements PiEditorComponent {
     // editor actions, so they stay as raw byte checks:
     //   esc        (\x1b)        — cancel form
     //   ctrl+c     (\x03)        — cancel form
-    //   ctrl+enter                — submit form
+    //   ctrl+x                — submit form
     //   tab        (\t)          — focus next field
     //   shift+tab  (\x1b[Z)      — focus previous field
-    if (data === "\x03" || matchesKey(data, "escape")) {
+    if (matchesKey(data, "ctrl+c") || matchesKey(data, "escape")) {
       this.opts.onExit("cancel");
       return true;
     }
-    if (matchesKey(data, "ctrl+enter")) {
+    if (matchesKey(data, "ctrl+x")) {
       if (this.allValid(state)) this.opts.onExit("submit");
       else this.focusFirstInvalid(state);
       return true;
@@ -475,7 +475,7 @@ export class InlineFormEditor implements PiEditorComponent {
       state.rawText[field.name] = choices[(i - 1 + choices.length) % choices.length]!;
       return true;
     }
-    if (matchesAction(this.kb, data, "tui.editor.cursorRight") || data === " ") {
+    if (matchesAction(this.kb, data, "tui.editor.cursorRight") || matchesKey(data, "space")) {
       state.rawText[field.name] = choices[(i + 1) % choices.length]!;
       return true;
     }
@@ -499,7 +499,7 @@ export class InlineFormEditor implements PiEditorComponent {
     state: InlineFormState,
   ): boolean {
     if (
-      data === " " ||
+      matchesKey(data, "space") ||
       matchesAction(this.kb, data, "tui.editor.cursorLeft") ||
       matchesAction(this.kb, data, "tui.editor.cursorRight")
     ) {
@@ -654,12 +654,15 @@ export class InlineFormEditor implements PiEditorComponent {
       return true;
     }
 
-    // Printable insertion — no Pi action, raw grapheme check. Numeric
-    // fields accept the same printable range as text; per-field validation
-    // catches non-numeric content at submit time.
-    if (isPrintableGrapheme(data)) {
-      state.rawText[name] = cur.slice(0, caret) + data + cur.slice(caret);
-      state.caret = caret + data.length;
+    // Printable insertion — accept raw graphemes and terminal-encoded
+    // printable keys (CSI-u / Kitty). VSCode's integrated terminal can emit
+    // printable keys as escape sequences when modifyOtherKeys is active.
+    // Numeric fields accept the same printable range as text; per-field
+    // validation catches non-numeric content at submit time.
+    const printable = decodePrintableKey(data) ?? data;
+    if (isPrintableGrapheme(printable)) {
+      state.rawText[name] = cur.slice(0, caret) + printable + cur.slice(caret);
+      state.caret = caret + printable.length;
       return true;
     }
     return false;