@lazyingart/agintiflow 0.12.4 → 0.12.6

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 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.
+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 with a colored response gutter and render common Markdown, including headings, inline code, bold text, lists, quotes, code fences, and tables. Resuming a session prints a compact recent-chat preview before the prompt. 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.4",
+  "version": "0.12.6",
   "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,21 +122,24 @@ 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");
+  if (!/aginti>\s*\r?\n\s*\|\s+Mock run complete\./.test(result.stdout)) {
+    throw new Error("assistant response did not render with a fresh-line response gutter");
   }
 
   const latest = await runCli(["resume"], "/exit\n");
   if (!latest.stdout.includes("session=") || !latest.stdout.includes("Interactive agent chat")) {
     throw new Error("bare aginti resume did not open the latest session interactively");
   }
+  if (!latest.stdout.includes("resume history") || !latest.stdout.includes("Mock run complete")) {
+    throw new Error("bare aginti resume did not preview saved chat history");
+  }
 
   console.log(
     JSON.stringify(
       {
         ok: true,
         projectRoot: tempRoot,
-        checks: ["markdown-render", "prompt-layout", "agent-response-newline", "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-gutter", "aginti-md", "instructions-command", "instructions-chat-edit", "interactive-chat", "mock-file-write", "run-status", "resume-latest", "resume-history-preview"],
       },
       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

@@ -3,11 +3,12 @@ import { emitKeypressEvents } from "node:readline";
 import { stdin as input, stdout as output } from "node:process";
 import { runAgent } from "./agent-runner.js";
 import { loadConfig } from "./config.js";
-import { initProject, listProjectSessions, providerKeyStatus, readProjectInstructions, setProviderKey } from "./project.js";
+import { initProject, listProjectSessions, projectPaths, providerKeyStatus, readProjectInstructions, setProviderKey } from "./project.js";
 import { normalizePackageInstallPolicy, normalizeSandboxMode } from "./command-policy.js";
 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 = {
@@ -26,6 +27,7 @@ const ansi = {
   cursorShow: "\x1b[?25h",
   userBg: "\x1b[48;5;24m\x1b[38;5;231m",
   agentBg: "\x1b[48;5;29m\x1b[38;5;231m",
+  responseBg: "\x1b[48;5;25m\x1b[38;5;231m",
   systemBg: "\x1b[48;5;236m\x1b[38;5;245m",
 };
 const brandPalette = ["\x1b[38;5;45m", "\x1b[38;5;81m", "\x1b[38;5;86m", "\x1b[38;5;118m", "\x1b[38;5;226m"];
@@ -56,6 +58,7 @@ const SLASH_COMMANDS = [
   "/exit",
 ];
 const promptHistory = [];
+let activeRunInput = null;
 
 function color(value, ...codes) {
   if (!useColor || codes.length === 0) return String(value);
@@ -70,6 +73,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 +144,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;
@@ -260,34 +276,38 @@ function rolePrefix(name, bgCode) {
   return `${label(name, bgCode)} ${color("|", bgCode)} `;
 }
 
+function responsePrefix() {
+  return `${color(" | ", ansi.responseBg)} `;
+}
+
 function printWrapped(prefix, text, { stripCode = "" } = {}) {
   const rendered = stripMarkdown(text);
   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) {
-  console.log(rolePrefix("aginti>", ansi.agentBg).trimEnd());
+  outputLine(label("aginti>", ansi.agentBg).trimEnd());
   const rendered = stripMarkdown(text);
   const lines = rendered.split("\n");
-  for (const line of lines) console.log(line);
+  for (const line of lines) outputLine(`${responsePrefix()}${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) {
@@ -364,7 +384,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")
   );
 }
@@ -401,7 +423,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);
@@ -497,6 +519,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;
@@ -514,6 +547,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,
@@ -558,8 +594,8 @@ function moveFromPromptCursorToTop(previous) {
   output.write("\r");
 }
 
-function renderPromptBuffer(buffer, cursor, previous = { lineCount: 0, cursorRow: 0, renderedRows: [] }) {
-  const layout = buildPromptLayout(buffer, cursor);
+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
@@ -637,7 +673,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);
@@ -665,14 +701,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);
       });
     };
 
@@ -832,13 +868,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()}`);
@@ -869,6 +1186,34 @@ async function latestSession() {
   return sessions[0] || null;
 }
 
+function compactHistoryText(content = "", limit = 170) {
+  const rendered = stripAnsi(stripMarkdown(String(content || "")));
+  return compactLine(rendered.replace(/\s+/g, " "), limit);
+}
+
+function printHistoryEntry(entry) {
+  const role = entry.role === "assistant" ? "aginti" : entry.role === "user" ? "user" : String(entry.role || "note");
+  const bg = role === "aginti" ? ansi.agentBg : role === "user" ? ansi.userBg : ansi.systemBg;
+  const time = entry.at ? new Date(entry.at).toLocaleTimeString([], { hour: "2-digit", minute: "2-digit" }) : "";
+  const suffix = time ? ` ${color(time, ansi.dim)}` : "";
+  outputLine(`${label(role, bg)} ${color("|", bg)} ${compactHistoryText(entry.content)}${suffix}`);
+}
+
+async function printResumeHistory(state, { limit = 8 } = {}) {
+  if (!state.sessionId) return;
+  const store = new SessionStore(projectPaths(process.cwd()).sessionsDir, state.sessionId);
+  const saved = await store.loadState().catch(() => null);
+  const chat = Array.isArray(saved?.chat) ? saved.chat.filter((entry) => entry?.content) : [];
+  if (chat.length === 0) {
+    printSystemLine(`resume history session=${state.sessionId} messages=0`);
+    return;
+  }
+
+  const shown = chat.slice(-limit);
+  printSystemLine(`resume history session=${state.sessionId} showing=${shown.length}/${chat.length}`);
+  for (const entry of shown) printHistoryEntry(entry);
+}
+
 function printStatusEvent(state, label, details = "") {
   state.lastEvent = details ? `${label}: ${details}` : label;
   printSystemLine(`status=${state.status || "running"} ${state.lastEvent}`);
@@ -1092,10 +1437,12 @@ async function handleCommand(line, state, packageDir) {
       } else {
         state.sessionId = latest.sessionId;
         printAgentMessage(`Resuming latest ${formatSessionLine(latest)}`);
+        await printResumeHistory(state);
       }
     } else {
       state.sessionId = value;
       printAgentMessage(`Resuming ${state.sessionId}`);
+      await printResumeHistory(state);
     }
     return true;
   }
@@ -1253,8 +1600,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,
@@ -1267,7 +1618,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);
         }
@@ -1284,7 +1635,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") {
@@ -1296,6 +1648,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";
@@ -1303,7 +1656,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 } = {}) {
@@ -1323,12 +1678,13 @@ export async function startInteractiveCli(args = {}, { packageDir, packageVersio
   await maybeOnboardDeepSeekKey(state);
   printAgentMessage("Interactive agent chat. Type /help for commands, /exit to quit.");
   printStatus(state);
+  await printResumeHistory(state);
 
   try {
     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)) {
@@ -1346,7 +1702,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`;