@lazyingart/agintiflow 0.12.3 → 0.12.5

package/README.md

@@ -67,7 +67,7 @@ aginti
 aginti chat
 ```
 
-Inside chat, type normal requests such as `write a small Python CLI app with tests`. The default is Docker workspace mode with approved package installs, so coding, plotting, and LaTeX tasks can set up project-local tools without touching the host. Use `/help` for commands, `/login` or `/auth` to paste a provider key, `/instructions` to inspect `AGINTI.md`, `/latex on` for PDF work, `/docker off` only when you intentionally want host mode, `/sessions` to list project runs, and `/resume latest` or `/resume <session-id>` to continue work. Type `/` then Tab for command completion. `Ctrl+J` inserts a new line in the colored input panel, Enter sends, arrow keys move through wrapped multiline input, and `Ctrl+A`/`Ctrl+E` jump to the current line start/end. Assistant responses render common Markdown, including headings, inline code, bold text, lists, quotes, code fences, and tables. Esc or Ctrl+C stops the active run cleanly and prints the resume command.
+Inside chat, type normal requests such as `write a small Python CLI app with tests`. The default is Docker workspace mode with approved package installs, so coding, plotting, and LaTeX tasks can set up project-local tools without touching the host. Use `/help` for commands, `/login` or `/auth` to paste a provider key, `/instructions` to inspect `AGINTI.md`, `/latex on` for PDF work, `/docker off` only when you intentionally want host mode, `/sessions` to list project runs, and `/resume latest` or `/resume <session-id>` to continue work. Type `/` then Tab for command completion. `Ctrl+J` inserts a new line in the colored input panel, Enter sends, arrow keys move through wrapped multiline input, and `Ctrl+A`/`Ctrl+E` jump to the current line start/end. During an active run, Enter sends the draft as an ASAP pipe message (`→`) and Tab queues it for after the run (`↳`); ASAP messages are consumed first, Alt+Up edits the last piped message, and Shift+Left edits the last after-finish queued message. The input panel always shows the current `cwd` footer. Assistant responses start on a fresh line after the `aginti>` header and render common Markdown, including headings, inline code, bold text, lists, quotes, code fences, and tables. Esc or Ctrl+C stops the active run cleanly and prints the resume command.
 
 `aginti init` creates `AGINTI.md` at the project root. This is the editable project-instruction file for both CLI and web runs, similar to `AGENTS.md` or project memory in other agents. Keep durable preferences, commands, and constraints there, but never secrets. You can edit it manually or ask in chat, for example: `update AGINTI.md to remember that this project uses pytest and npm run check`.
 
@@ -365,7 +365,7 @@ Package policy values:
 
 Toolchain commands such as `python3 plot.py`, `latexmk -pdf paper.tex`, and `pdflatex -interaction=nonstopmode -halt-on-error paper.tex` are allowlisted only when the shell tool is enabled. In Docker mode the project folder is mounted as `/workspace`; any file written to `/workspace/report.pdf` appears on the host as `<your-project>/report.pdf`. CLI runs print both the host workspace and the Docker mapping before execution. File and canvas tools accept both normal relative paths and Docker virtual paths like `/workspace/report.pdf`, while other absolute host paths remain blocked.
 
-The web chat mirrors the CLI session store. Enter sends, Ctrl+J inserts a newline, Tab submits/queues the message, and Esc stops the active run. Queued input is written to `.sessions/<session-id>/inbox.jsonl`; the running agent drains that pipe between steps and after tool calls. Generated local sites should use the built-in `preview_workspace` or `open_workspace_file` tools; AgInTiFlow avoids transient localhost servers inside Docker because those containers stop between commands and their ports are not host-published.
+The web chat mirrors the CLI session store. Enter sends, Ctrl+J inserts a newline, Tab submits/queues the message, and Esc stops the active run. CLI live input has two pending lanes: ASAP pipe messages (`→`) are written to `.sessions/<session-id>/inbox.jsonl` and drained before normal queued items at safe runner boundaries, while after-finish messages (`↳`) run as the next prompt once the current task fully finishes. Generated local sites should use the built-in `preview_workspace` or `open_workspace_file` tools; AgInTiFlow avoids transient localhost servers inside Docker because those containers stop between commands and their ports are not host-published.
 
 Safe preflight endpoints:
 

package/docs/agent-runtime-pipe.md

@@ -9,6 +9,8 @@ AgInTiFlow keeps CLI and web runs equivalent by using the project folder as the
 
 When a run is active, the web chat and `aginti queue <session-id> "..."` append messages to the inbox instead of trying to mutate the running process directly. The runner drains the inbox at safe boundaries: before each model step and after tool execution. This mirrors the event-queue style used by mature agent UIs while keeping the backend decoupled from any specific frontend.
 
+The interactive CLI keeps the input panel visible while a run is working. Enter sends the current draft as an ASAP pipe message and displays it as `→`; the runner drains those messages before normal inbox items. Tab stores the draft as an after-finish queue item and displays it as `↳`; those prompts run only after the current run completes. Alt+Up moves the last pending `→` message back into the editor, and Shift+Left moves the last pending `↳` message back into the editor. The current command cwd is rendered below the input panel in both idle and running states.
+
 Runs can be stopped without corrupting session state. The CLI listens for Esc or Ctrl+C during an active run, and the web UI exposes a Stop button plus Esc. Both paths send an abort signal, persist `session.stopped`, and leave the session resumable through `aginti resume <session-id>`.
 
 Default execution is Docker workspace mode with package installs approved inside the sandbox. The project is mounted at `/workspace`; persistent agent toolchain folders are mounted at `/aginti-home`, `/aginti-cache`, and `/aginti-env` from `~/.agintiflow/docker/`. Python, conda, and other language-level environments should be installed under `/aginti-env` so they survive across runs. Apt/apk package changes are ephemeral unless the Docker image is rebuilt.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.12.3",
+  "version": "0.12.5",
   "type": "module",
   "description": "AgInTiFlow is a resumable Playwright website-control agent with OpenAI-compatible tool calling.",
   "license": "Apache-2.0",

package/scripts/smoke-cli-chat.js

@@ -84,6 +84,17 @@ try {
   if (hugePromptLayout.renderedRows.length > 12 || !hugePromptLayout.renderedRows.some((line) => line.includes("earlier input row"))) {
     throw new Error("terminal prompt layout did not bound redraw size for large prompts");
   }
+  const queuedPromptLayout = buildPromptLayout("follow up", 9, 90, 24, {
+    commandCwd: "/tmp/aginti-project",
+    pendingAsap: [{ content: "apply this to the running task" }],
+    pendingQueued: [{ content: "run this after the current task" }],
+  });
+  const queuedText = queuedPromptLayout.renderedRows
+    .map((line) => line.replace(/\x1b\[[0-9;?]*[ -/]*[@-~]/g, ""))
+    .join("\n");
+  if (!queuedText.includes("→ apply this") || !queuedText.includes("↳ run this") || !queuedText.includes("cwd   /tmp/aginti-project")) {
+    throw new Error("terminal prompt layout did not render live input queue and cwd footer");
+  }
 
   await runCli(["init"], "");
   const instructions = await fs.readFile(path.join(tempRoot, "AGINTI.md"), "utf8");
@@ -111,6 +122,9 @@ try {
   if (!result.stdout.includes("status=running workingOn=") || !result.stdout.includes("status=idle session=")) {
     throw new Error("interactive chat did not print simple run status updates");
   }
+  if (!/aginti>\s+\|\r?\nMock run complete\./.test(result.stdout)) {
+    throw new Error("assistant response did not start on a fresh line after the aginti header");
+  }
 
   const latest = await runCli(["resume"], "/exit\n");
   if (!latest.stdout.includes("session=") || !latest.stdout.includes("Interactive agent chat")) {
@@ -122,7 +136,7 @@ try {
       {
         ok: true,
         projectRoot: tempRoot,
-        checks: ["markdown-render", "prompt-layout", "aginti-md", "instructions-command", "instructions-chat-edit", "interactive-chat", "mock-file-write", "run-status", "resume-latest"],
+        checks: ["markdown-render", "prompt-layout", "live-input-layout", "agent-response-newline", "aginti-md", "instructions-command", "instructions-chat-edit", "interactive-chat", "mock-file-write", "run-status", "resume-latest"],
       },
       null,
       2

package/scripts/smoke-inbox.js

@@ -12,20 +12,24 @@ function assert(condition, message) {
 
 try {
   const store = new SessionStore(path.join(tempRoot, ".sessions"), "inbox-smoke");
-  await store.appendInbox("first queued message", { source: "test" });
+  const first = await store.appendInbox("first queued message", { source: "test" });
   await store.appendInbox("second queued message", { source: "test" });
+  await store.appendInbox("urgent piped message", { source: "test", priority: "asap" });
+
+  assert(first?.id, "appendInbox did not return an inbox id");
 
   const drained = await store.drainInbox();
-  assert(drained.length === 2, "inbox did not drain both messages");
-  assert(drained[0].content === "first queued message", "first queued message mismatch");
-  assert(drained[1].content === "second queued message", "second queued message mismatch");
+  assert(drained.length === 3, "inbox did not drain all messages");
+  assert(drained[0].content === "urgent piped message", "asap message was not drained first");
+  assert(drained[1].content === "first queued message", "first queued message mismatch");
+  assert(drained[2].content === "second queued message", "second queued message mismatch");
   assert((await store.drainInbox()).length === 0, "inbox was not cleared after drain");
 
   console.log(
     JSON.stringify(
       {
         ok: true,
-        checks: ["session-inbox-append", "session-inbox-drain"],
+        checks: ["session-inbox-append", "session-inbox-drain", "session-inbox-asap-priority"],
       },
       null,
       2

package/src/agent-runner.js

@@ -727,12 +727,16 @@ async function injectQueuedUserMessages(store, state, observers) {
       content: `Additional user message received while this run was active:\n${content}`,
     });
     await store.appendEvent("conversation.queued_input_applied", {
+      id: item.id || "",
       prompt: content,
       source: item.source || "inbox",
+      priority: item.priority || "normal",
     });
     observers.event("conversation.queued_input_applied", {
+      id: item.id || "",
       prompt: content,
       source: item.source || "inbox",
+      priority: item.priority || "normal",
     });
   }
 }

package/src/interactive-cli.js

@@ -8,6 +8,7 @@ import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./command-p
 import { defaultMaxStepsForProfile, normalizeTaskProfile } from "./task-profiles.js";
 import { recommendedMaxStepsForTask } from "./engineering-guidance.js";
 import { promptAndSaveDeepSeekKey, promptHidden, shouldPromptForDeepSeek } from "./auth-onboarding.js";
+import { SessionStore } from "./session-store.js";
 
 const useColor = Boolean(input.isTTY && output.isTTY && process.env.AGINTIFLOW_NO_COLOR !== "1");
 const ansi = {
@@ -56,6 +57,7 @@ const SLASH_COMMANDS = [
   "/exit",
 ];
 const promptHistory = [];
+let activeRunInput = null;
 
 function color(value, ...codes) {
   if (!useColor || codes.length === 0) return String(value);
@@ -70,6 +72,14 @@ function label(name, bgCode) {
   return color(` ${name} `, bgCode, ansi.bold);
 }
 
+function outputLine(line = "") {
+  if (activeRunInput) {
+    activeRunInput.printLine(String(line));
+    return;
+  }
+  console.log(line);
+}
+
 function terminalWidth() {
   return Math.max(Number(output.columns) || 80, 40);
 }
@@ -133,6 +143,11 @@ function clamp(value, min, max) {
   return Math.min(Math.max(value, min), max);
 }
 
+function compactLine(value = "", limit = 96) {
+  const text = stripAnsi(String(value || "").replace(/\s+/g, " ").trim());
+  return text.length <= limit ? text : `${text.slice(0, Math.max(limit - 1, 1))}…`;
+}
+
 export function stripMarkdown(text) {
   const lines = String(text || "").split(/\r?\n/);
   let inFence = false;
@@ -265,26 +280,29 @@ function printWrapped(prefix, text, { stripCode = "" } = {}) {
   const lines = rendered.split("\n");
   const visible = stripAnsi(prefix).length;
   const gutter = `${" ".repeat(Math.max(visible - 2, 0))}${stripCode ? color("|", stripCode) : "|"} `;
-  console.log(`${prefix}${lines[0] || ""}`);
+  outputLine(`${prefix}${lines[0] || ""}`);
   for (const line of lines.slice(1)) {
-    console.log(`${gutter}${line}`);
+    outputLine(`${gutter}${line}`);
   }
 }
 
 function printAgentMessage(text) {
-  printWrapped(rolePrefix("aginti>", ansi.agentBg), text, { stripCode: ansi.agentBg });
+  outputLine(rolePrefix("aginti>", ansi.agentBg).trimEnd());
+  const rendered = stripMarkdown(text);
+  const lines = rendered.split("\n");
+  for (const line of lines) outputLine(line);
 }
 
 function printSystemLine(text) {
   if (!String(text || "").trim()) {
-    console.log("");
+    outputLine("");
     return;
   }
-  console.log(`${label("state", ansi.systemBg)} ${color(text, ansi.dim)}`);
+  outputLine(`${label("state", ansi.systemBg)} ${color(text, ansi.dim)}`);
 }
 
 function printHeading(text) {
-  console.log(color(stripMarkdown(text), ansi.bold, ansi.cyan));
+  outputLine(color(stripMarkdown(text), ansi.bold, ansi.cyan));
 }
 
 function shimmerText(text, frame) {
@@ -361,7 +379,9 @@ function printHelp() {
       "",
       "Type a normal request to run the agent. Example: write a Python CLI app with tests",
       "Type / then Tab to autocomplete commands.",
-      "While a run is active, press Esc or Ctrl+C once to stop gracefully and print a resume command.",
+      "While a run is active, Enter pipes a message into the current run (→), Tab queues it after finish (↳).",
+      "Alt+Up edits the last piped message; Shift+Left edits the last queued message.",
+      "Esc or Ctrl+C stops gracefully and prints a resume command.",
     ].join("\n")
   );
 }
@@ -398,7 +418,7 @@ function promptVisibleWindow(rows, cursorRow, height = terminalHeight()) {
   };
 }
 
-export function buildPromptLayout(buffer = "", cursor = 0, width = terminalWidth(), height = terminalHeight()) {
+export function buildPromptLayout(buffer = "", cursor = 0, width = terminalWidth(), height = terminalHeight(), options = {}) {
   const safeBuffer = String(buffer || "");
   const safeCursor = clamp(Number(cursor) || 0, 0, safeBuffer.length);
   const lineWidth = editorWidth(width);
@@ -494,6 +514,17 @@ export function buildPromptLayout(buffer = "", cursor = 0, width = terminalWidth
   const renderedRows = [];
   let renderedCursorRow = cursorRow - visible.start;
 
+  const pendingAsap = Array.isArray(options.pendingAsap) ? options.pendingAsap : [];
+  const pendingQueued = Array.isArray(options.pendingQueued) ? options.pendingQueued : [];
+  for (const item of pendingAsap.slice(-4)) {
+    renderedRows.push(panelLine(`  → ${compactLine(item.content || item, lineWidth - 6)}`, ansi.systemBg, lineWidth));
+    renderedCursorRow += 1;
+  }
+  for (const item of pendingQueued.slice(-4)) {
+    renderedRows.push(panelLine(`  ↳ ${compactLine(item.content || item, lineWidth - 6)}`, ansi.systemBg, lineWidth));
+    renderedCursorRow += 1;
+  }
+
   if (visible.topHidden > 0) {
     renderedRows.push(panelLine(`  ... ${visible.topHidden} earlier input row${visible.topHidden === 1 ? "" : "s"}`, ansi.systemBg, lineWidth));
     renderedCursorRow += 1;
@@ -511,6 +542,9 @@ export function buildPromptLayout(buffer = "", cursor = 0, width = terminalWidth
   if (suggestions.length > 0) {
     renderedRows.push(panelLine(` hint  ${suggestions.join("  ")}`, ansi.systemBg, lineWidth));
   }
+  if (options.commandCwd) {
+    renderedRows.push(panelLine(` cwd   ${options.commandCwd}`, ansi.systemBg, lineWidth));
+  }
 
   return {
     rows,
@@ -546,18 +580,47 @@ function clearRenderedPrompt(previous) {
   }
 }
 
-function renderPromptBuffer(buffer, cursor, previous = { lineCount: 0, cursorRow: 0 }) {
-  output.write(ansi.cursorHide);
-  clearRenderedPrompt(previous);
-  const layout = buildPromptLayout(buffer, cursor);
-  output.write(layout.renderedRows.join("\n"));
+function moveFromPromptCursorToTop(previous) {
+  if (!previous.lineCount) return;
+  const below = previous.lineCount - 1 - previous.cursorRow;
+  if (below > 0) output.write(`\x1b[${below}B`);
+  const up = previous.lineCount - 1;
+  if (up > 0) output.write(`\x1b[${up}A`);
+  output.write("\r");
+}
+
+function renderPromptBuffer(buffer, cursor, previous = { lineCount: 0, cursorRow: 0, renderedRows: [] }, options = {}) {
+  const layout = buildPromptLayout(buffer, cursor, terminalWidth(), terminalHeight(), options);
+  const sameShape = previous.lineCount === layout.renderedRows.length && previous.renderedRows?.length === layout.renderedRows.length;
+  const changedRows = sameShape
+    ? layout.renderedRows
+        .map((row, index) => (row === previous.renderedRows[index] ? -1 : index))
+        .filter((index) => index >= 0)
+    : layout.renderedRows.map((_row, index) => index);
+
+  if (!sameShape) {
+    output.write(ansi.cursorHide);
+    clearRenderedPrompt(previous);
+    output.write(layout.renderedRows.join("\n"));
+  } else if (changedRows.length > 0) {
+    output.write(ansi.cursorHide);
+    moveFromPromptCursorToTop(previous);
+    for (let index = 0; index < layout.renderedRows.length; index += 1) {
+      if (changedRows.includes(index)) output.write(`\r${layout.renderedRows[index]}`);
+      if (index < layout.renderedRows.length - 1) output.write("\x1b[1B\r");
+    }
+  } else {
+    moveFromPromptCursorToTop(previous);
+  }
+
   const below = layout.renderedRows.length - 1 - layout.cursorRow;
   if (below > 0) output.write(`\x1b[${below}A`);
   output.write(`\r\x1b[${layout.cursorColumn + 1}G`);
-  output.write(ansi.cursorShow);
+  if (!sameShape || changedRows.length > 0) output.write(ansi.cursorShow);
   return {
     lineCount: layout.renderedRows.length,
     cursorRow: layout.cursorRow,
+    renderedRows: layout.renderedRows,
   };
 }
 
@@ -605,7 +668,7 @@ function createAbortError(message = "Aborted with Ctrl+C") {
   return error;
 }
 
-function readTtyPrompt() {
+function readTtyPrompt(options = {}) {
   return new Promise((resolve, reject) => {
     emitKeypressEvents(input);
     const wasRaw = Boolean(input.isRaw);
@@ -633,14 +696,14 @@ function readTtyPrompt() {
         clearImmediate(redrawHandle);
         redrawHandle = null;
       }
-      rendered = renderPromptBuffer(buffer, cursor, rendered);
+      rendered = renderPromptBuffer(buffer, cursor, rendered, options);
     };
 
     const redraw = () => {
       if (redrawHandle) return;
       redrawHandle = setImmediate(() => {
         redrawHandle = null;
-        rendered = renderPromptBuffer(buffer, cursor, rendered);
+        rendered = renderPromptBuffer(buffer, cursor, rendered, options);
       });
     };
 
@@ -800,13 +863,294 @@ function readTtyPrompt() {
   });
 }
 
-async function readPromptAnswer(rl) {
+async function readPromptAnswer(rl, state = {}) {
   if (input.isTTY && output.isTTY && typeof input.setRawMode === "function") {
-    return readTtyPrompt();
+    return readTtyPrompt({ commandCwd: state.commandCwd || process.cwd() });
   }
   return rl.question(userPrompt());
 }
 
+class LiveRunInput {
+  constructor({ state, store, controller }) {
+    this.state = state;
+    this.store = store;
+    this.controller = controller;
+    this.buffer = "";
+    this.cursor = 0;
+    this.rendered = { lineCount: 0, cursorRow: 0, renderedRows: [] };
+    this.redrawHandle = null;
+    this.preferredColumn = null;
+    this.pendingAsap = [];
+    this.pendingQueued = [];
+    this.wasRaw = Boolean(input.isRaw);
+    this.started = false;
+    this.handler = this.handleKey.bind(this);
+  }
+
+  get commandCwd() {
+    return this.state.commandCwd || process.cwd();
+  }
+
+  start() {
+    if (!input.isTTY || !output.isTTY || typeof input.setRawMode !== "function") return false;
+    emitKeypressEvents(input);
+    input.resume();
+    input.setRawMode(true);
+    input.on("keypress", this.handler);
+    activeRunInput = this;
+    this.started = true;
+    this.renderNow();
+    return true;
+  }
+
+  async stop() {
+    if (!this.started) return [];
+    if (this.redrawHandle) {
+      clearImmediate(this.redrawHandle);
+      this.redrawHandle = null;
+    }
+    input.off("keypress", this.handler);
+    if (typeof input.setRawMode === "function") input.setRawMode(this.wasRaw);
+    this.clearForExternalOutput();
+    output.write(ansi.cursorShow);
+    if (activeRunInput === this) activeRunInput = null;
+    this.started = false;
+
+    const unappliedAsap = [...this.pendingAsap];
+    if (unappliedAsap.length > 0) {
+      await this.removeInboxItems(unappliedAsap.map((item) => item.id));
+    }
+    return [
+      ...unappliedAsap.map((item) => ({ ...item, kind: "asap" })),
+      ...this.pendingQueued.map((item) => ({ ...item, kind: "queued" })),
+    ];
+  }
+
+  printLine(line = "") {
+    this.clearForExternalOutput();
+    output.write(`${line}\n`);
+    this.renderNow();
+  }
+
+  clearForExternalOutput() {
+    if (!this.rendered.lineCount) return;
+    output.write(ansi.cursorHide);
+    clearRenderedPrompt(this.rendered);
+    this.rendered = { lineCount: 0, cursorRow: 0, renderedRows: [] };
+    output.write(ansi.cursorShow);
+  }
+
+  renderNow() {
+    if (this.redrawHandle) {
+      clearImmediate(this.redrawHandle);
+      this.redrawHandle = null;
+    }
+    this.rendered = renderPromptBuffer(this.buffer, this.cursor, this.rendered, {
+      commandCwd: this.commandCwd,
+      pendingAsap: this.pendingAsap,
+      pendingQueued: this.pendingQueued,
+    });
+  }
+
+  redraw() {
+    if (this.redrawHandle) return;
+    this.redrawHandle = setImmediate(() => {
+      this.redrawHandle = null;
+      this.renderNow();
+    });
+  }
+
+  setBuffer(nextBuffer, nextCursor = nextBuffer.length) {
+    this.buffer = String(nextBuffer || "");
+    this.cursor = clamp(nextCursor, 0, this.buffer.length);
+    this.preferredColumn = null;
+    this.redraw();
+  }
+
+  moveVertical(direction) {
+    const layout = buildPromptLayout(this.buffer, this.cursor, terminalWidth(), terminalHeight(), {
+      commandCwd: this.commandCwd,
+      pendingAsap: this.pendingAsap,
+      pendingQueued: this.pendingQueued,
+    });
+    const location = cursorLocation(layout, this.cursor);
+    const targetRowIndex = location.rowIndex + direction;
+    if (targetRowIndex < 0 || targetRowIndex >= layout.rows.length) return;
+    const currentColumn = this.preferredColumn ?? location.column;
+    const targetRow = layout.rows[targetRowIndex];
+    this.cursor = targetRow.start + Math.min(currentColumn, targetRow.end - targetRow.start);
+    this.preferredColumn = currentColumn;
+    this.redraw();
+  }
+
+  async removeInboxItems(ids = []) {
+    if (ids.length === 0) return;
+    const idSet = new Set(ids);
+    const inbox = await this.store.loadInbox().catch(() => []);
+    await this.store.saveInbox(inbox.filter((item) => !idSet.has(item.id))).catch(() => {});
+  }
+
+  async submitAsap() {
+    const content = this.buffer.trim();
+    if (!content) return;
+    const item = {
+      id: `cli-asap-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+      content,
+      priority: "asap",
+      source: "cli-live",
+    };
+    this.pendingAsap.push(item);
+    this.setBuffer("");
+    await this.store.appendInbox(content, item).catch((error) => {
+      this.pendingAsap = this.pendingAsap.filter((pending) => pending.id !== item.id);
+      this.printLine(`${label("error", ansi.systemBg)} failed to pipe message: ${error.message}`);
+    });
+    await this.store.appendEvent("conversation.piped_input", {
+      id: item.id,
+      prompt: content,
+      source: item.source,
+      priority: item.priority,
+    }).catch(() => {});
+    this.redraw();
+  }
+
+  queueAfterFinish() {
+    const content = this.buffer.trim();
+    if (!content) return;
+    this.pendingQueued.push({
+      id: `cli-queued-${Date.now()}-${Math.random().toString(16).slice(2)}`,
+      content,
+      priority: "after-finish",
+      source: "cli-live",
+    });
+    this.setBuffer("");
+  }
+
+  editLastQueued() {
+    const item = this.pendingQueued.pop();
+    if (!item) return;
+    this.setBuffer(item.content);
+  }
+
+  editLastAsap() {
+    const item = this.pendingAsap.pop();
+    if (!item) return;
+    void this.removeInboxItems([item.id]);
+    this.setBuffer(item.content);
+  }
+
+  markApplied(data = {}) {
+    const id = data.id || "";
+    const prompt = String(data.prompt || "");
+    if (id) {
+      this.pendingAsap = this.pendingAsap.filter((item) => item.id !== id);
+    } else if (prompt) {
+      const index = this.pendingAsap.findIndex((item) => item.content === prompt);
+      if (index >= 0) this.pendingAsap.splice(index, 1);
+    }
+    this.redraw();
+  }
+
+  handleKey(str = "", key = {}) {
+    if (key.ctrl && key.name === "c") {
+      this.controller.abort(new Error("Interrupted by ctrl-c."));
+      return;
+    }
+    if (key.name === "escape") {
+      this.controller.abort(new Error("Interrupted by escape."));
+      return;
+    }
+    if (key.meta && key.name === "up") {
+      this.editLastAsap();
+      return;
+    }
+    if ((key.shift && key.name === "left") || key.sequence === "\x1b[1;2D") {
+      this.editLastQueued();
+      return;
+    }
+    if ((key.ctrl && key.name === "j") || key.sequence === "\n") {
+      ({ buffer: this.buffer, cursor: this.cursor } = insertAt(this.buffer, this.cursor, "\n"));
+      this.preferredColumn = null;
+      this.redraw();
+      return;
+    }
+    if (key.name === "return" || key.name === "enter" || key.sequence === "\r" || str === "\r") {
+      void this.submitAsap();
+      return;
+    }
+    if (key.name === "tab") {
+      this.queueAfterFinish();
+      return;
+    }
+    if (key.name === "backspace") {
+      ({ buffer: this.buffer, cursor: this.cursor } = removeBefore(this.buffer, this.cursor));
+      this.preferredColumn = null;
+      this.redraw();
+      return;
+    }
+    if (key.name === "delete") {
+      ({ buffer: this.buffer, cursor: this.cursor } = removeAt(this.buffer, this.cursor));
+      this.preferredColumn = null;
+      this.redraw();
+      return;
+    }
+    if (key.name === "left") {
+      this.cursor = Math.max(this.cursor - 1, 0);
+      this.preferredColumn = null;
+      this.redraw();
+      return;
+    }
+    if (key.name === "right") {
+      this.cursor = Math.min(this.cursor + 1, this.buffer.length);
+      this.preferredColumn = null;
+      this.redraw();
+      return;
+    }
+    if (key.name === "up") {
+      this.moveVertical(-1);
+      return;
+    }
+    if (key.name === "down") {
+      this.moveVertical(1);
+      return;
+    }
+    if ((key.ctrl && key.name === "a") || key.name === "home") {
+      this.cursor = lineBounds(this.buffer, this.cursor).start;
+      this.preferredColumn = null;
+      this.redraw();
+      return;
+    }
+    if ((key.ctrl && key.name === "e") || key.name === "end") {
+      this.cursor = lineBounds(this.buffer, this.cursor).end;
+      this.preferredColumn = null;
+      this.redraw();
+      return;
+    }
+    if (key.ctrl && key.name === "u") {
+      const bounds = lineBounds(this.buffer, this.cursor);
+      this.buffer = `${this.buffer.slice(0, bounds.start)}${this.buffer.slice(this.cursor)}`;
+      this.cursor = bounds.start;
+      this.preferredColumn = null;
+      this.redraw();
+      return;
+    }
+    if (key.ctrl && key.name === "k") {
+      const bounds = lineBounds(this.buffer, this.cursor);
+      this.buffer = `${this.buffer.slice(0, this.cursor)}${this.buffer.slice(bounds.end)}`;
+      this.preferredColumn = null;
+      this.redraw();
+      return;
+    }
+    if (key.ctrl || key.meta) return;
+    if (str && !key.sequence?.startsWith("\x1b")) {
+      const text = str.replace(/\r/g, "");
+      ({ buffer: this.buffer, cursor: this.cursor } = insertAt(this.buffer, this.cursor, text));
+      this.preferredColumn = null;
+      this.redraw();
+    }
+  }
+}
+
 function printStatus(state) {
   printSystemLine(`project=${process.cwd()}`);
   printSystemLine(`cwd=${state.commandCwd || process.cwd()}`);
@@ -1221,8 +1565,12 @@ async function runPrompt(prompt, state, packageDir) {
   printSystemLine(`session=${state.sessionId}`);
   printSystemLine(`status=running workingOn=${state.activeGoal}`);
 
-  const detachInterrupts = attachRunInterrupts(controller);
+  const store = new SessionStore(config.sessionsDir, state.sessionId);
+  const liveInput = new LiveRunInput({ state, store, controller });
+  const liveStarted = liveInput.start();
+  const detachInterrupts = liveStarted ? () => {} : attachRunInterrupts(controller);
   let result;
+  let queuedAfterFinish = [];
   try {
     result = await runAgent({
       ...config,
@@ -1235,7 +1583,7 @@ async function runPrompt(prompt, state, packageDir) {
         } else if (options.kind === "heading") {
           printHeading(text);
         } else if (options.error) {
-          console.error(`${label("error", ansi.systemBg)} ${stripMarkdown(text)}`);
+          outputLine(`${label("error", ansi.systemBg)} ${stripMarkdown(text)}`);
         } else {
           printSystemLine(text);
         }
@@ -1252,7 +1600,8 @@ async function runPrompt(prompt, state, packageDir) {
         } else if (type === "loop.guard") {
           printStatusEvent(state, "loop_guard", data.toolName || "");
         } else if (type === "conversation.queued_input_applied") {
-          printStatusEvent(state, "queued_input_applied");
+          liveInput.markApplied(data);
+          printStatusEvent(state, "queued_input_applied", data.priority === "asap" ? "asap" : "");
         } else if (type === "session.finished") {
           printStatusEvent(state, "finished");
         } else if (type === "session.stopped") {
@@ -1264,6 +1613,7 @@ async function runPrompt(prompt, state, packageDir) {
     });
   } finally {
     detachInterrupts();
+    queuedAfterFinish = await liveInput.stop();
   }
   state.sessionId = result.sessionId || state.sessionId;
   state.status = result.stopped ? "stopped" : "idle";
@@ -1271,7 +1621,9 @@ async function runPrompt(prompt, state, packageDir) {
   printSystemLine(`status=${state.status} session=${state.sessionId}`);
   if (result.stopped && result.reason === "user_interrupt") {
     await printResumeHint(state);
+    return [];
   }
+  return queuedAfterFinish;
 }
 
 export async function startInteractiveCli(args = {}, { packageDir, packageVersion } = {}) {
@@ -1296,7 +1648,7 @@ export async function startInteractiveCli(args = {}, { packageDir, packageVersio
     while (true) {
       let answer = "";
       try {
-        answer = await readPromptAnswer(rl);
+        answer = await readPromptAnswer(rl, state);
       } catch (error) {
         if (error?.code === "ERR_USE_AFTER_CLOSE") break;
         if (isAbortError(error)) {
@@ -1314,7 +1666,19 @@ export async function startInteractiveCli(args = {}, { packageDir, packageVersio
       }
 
       try {
-        await runPrompt(line, state, packageDir);
+        const pendingPrompts = [{ content: line }];
+        while (pendingPrompts.length > 0) {
+          const nextPrompt = pendingPrompts.shift();
+          const content = String(nextPrompt.content || "").trim();
+          if (!content) continue;
+          if (content.startsWith("/")) {
+            const keepGoing = await handleCommand(content, state, packageDir);
+            if (!keepGoing) return;
+            continue;
+          }
+          const queued = await runPrompt(content, state, packageDir);
+          pendingPrompts.push(...queued.filter((item) => String(item.content || "").trim()));
+        }
       } catch (error) {
         if (isAbortError(error)) {
           await printResumeHint(state);

package/src/session-store.js

@@ -1,5 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
+import crypto from "node:crypto";
 
 export class SessionStore {
   constructor(baseDir, sessionId) {
@@ -63,16 +64,20 @@ export class SessionStore {
   async appendInbox(content, metadata = {}) {
     await this.ensure();
     const text = String(content || "").trim();
-    if (!text) return;
-    const line = JSON.stringify({
+    if (!text) return null;
+    const item = {
+      id: metadata.id || `inbox-${crypto.randomUUID()}`,
       timestamp: new Date().toISOString(),
       content: text,
+      priority: metadata.priority || "normal",
       ...metadata,
-    });
+    };
+    const line = JSON.stringify(item);
     await fs.appendFile(this.inboxPath, `${line}\n`, "utf8");
+    return item;
   }
 
-  async drainInbox() {
+  async loadInbox() {
     await this.ensure();
     let raw = "";
     try {
@@ -80,7 +85,6 @@ export class SessionStore {
     } catch {
       return [];
     }
-    await fs.writeFile(this.inboxPath, "", "utf8");
     return raw
       .split("\n")
       .map((line) => line.trim())
@@ -88,6 +92,22 @@ export class SessionStore {
       .map((line) => JSON.parse(line));
   }
 
+  async saveInbox(items = []) {
+    await this.ensure();
+    const lines = items.filter(Boolean).map((item) => JSON.stringify(item));
+    await fs.writeFile(this.inboxPath, lines.length > 0 ? `${lines.join("\n")}\n` : "", "utf8");
+  }
+
+  async drainInbox() {
+    await this.ensure();
+    const items = await this.loadInbox();
+    await fs.writeFile(this.inboxPath, "", "utf8");
+    return items.sort((a, b) => {
+      const priority = (item) => (item.priority === "asap" ? 0 : 1);
+      return priority(a) - priority(b) || String(a.timestamp || "").localeCompare(String(b.timestamp || ""));
+    });
+  }
+
   async saveSnapshot(step, snapshot) {
     await this.ensure();
     const filename = `step-${String(step).padStart(3, "0")}.snapshot.json`;