@lazyingart/agintiflow 0.12.7 → 0.12.9

package/README.md

@@ -75,7 +75,7 @@ For code edits, AgInTiFlow routes patch/refactor/database-style tasks to DeepSee
 
 For larger repositories, use `--profile large-codebase` or choose **Large codebase engineering** in the web UI. The web default stays **Auto**, and Auto now escalates codebase/system/debugging prompts to the same engineering loop when needed. Complex work routes to DeepSeek v4 pro, starts with `inspect_project`, then uses search/read/patch/check loops inspired by Codex, Copilot SDK, Claude Code, Gemini CLI, Qwen, and Claw Code. See [docs/large-codebase-engineering.md](docs/large-codebase-engineering.md).
 
-AgInTiFlow can also spend cheap DeepSeek calls on parallel scout notes before the main executor starts a complicated task. Scouts run independently for architecture, implementation, review, and research risks, then the main agent uses those notes while still doing the real file/shell/browser work itself. Disable with `--no-parallel-scouts` or set `--scout-count 1..4`.
+AgInTiFlow can also spend cheap DeepSeek calls on parallel scout notes before the main executor starts a complicated task. Scouts run independently for architecture, implementation, review, research, context mapping, tests, git workflow, and integration risks, then a coordinator synthesis is injected for the main agent. The executor still does the real file/shell/browser work itself. Disable with `--no-parallel-scouts` or set `--scout-count 1..8`.
 
 For current docs, install errors, package/toolchain setup, and source discovery, the agent has a guarded `web_search` tool. It returns compact search results without browser search-engine loops and respects configured domain allowlists. Disable with `--no-web-search`.
 
@@ -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. 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.
+The web chat mirrors the CLI session store while keeping browser-native controls. Launch `aginti web` from the same project folder and it reads the same `.sessions/` history as `aginti` and `aginti resume`. In the web UI, Enter sends and Shift+Enter adds a newline. `Pipe to run` writes an ASAP message (`→`) to `.sessions/<session-id>/inbox.jsonl` so an active CLI or web agent can consume it at the next safe boundary. `Queue after finish` stores a browser-local next prompt (`↳`) and starts it after the current web run finishes; queued items have Edit and Remove buttons. Esc or Stop stops active web runs. 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:
 
@@ -376,6 +376,7 @@ curl -X POST http://127.0.0.1:3210/api/sandbox/preflight \
   -d '{"sandboxMode":"docker-workspace","buildImage":true}'
 curl http://127.0.0.1:3210/api/workspace/changes
 curl "http://127.0.0.1:3210/api/sessions/<session-id>/artifacts"
+curl "http://127.0.0.1:3210/api/sessions/<session-id>/inbox"
 ```
 
 These endpoints report Docker/image/workspace readiness, recent sandbox logs, file-change provenance, and renderable artifact metadata without returning API keys or npm tokens. Artifact content is loaded on demand through guarded session/workspace reads.

package/docs/agent-runtime-pipe.md

@@ -7,10 +7,12 @@ AgInTiFlow keeps CLI and web runs equivalent by using the project folder as the
 - Web settings database: `<project>/.sessions/web-state.sqlite`.
 - Runtime inbox: `<project>/.sessions/<session-id>/inbox.jsonl`.
 
-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.
+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 web API exposes `GET /api/sessions/:id/inbox`, `POST /api/sessions/:id/inbox`, `PATCH /api/sessions/:id/inbox/:itemId`, and `DELETE /api/sessions/:id/inbox/:itemId` so browser users can inspect, edit, or remove pending pipe messages before the runner consumes them. 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.
 
+The web UI uses a related but browser-appropriate pattern. Enter sends and Shift+Enter adds a newline. `Pipe to run` writes an ASAP inbox item shared with CLI. `Queue after finish` keeps a browser-local next prompt and starts it after the current web-owned run finishes. Both lanes render in a pending panel with Edit and Remove buttons instead of terminal-only keybindings.
+
 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/docs/large-codebase-engineering.md

@@ -38,6 +38,22 @@ For complicated tasks, the agent should follow this loop:
 6. `run_command` for the narrowest relevant check first.
 7. Broaden checks only after the focused check passes.
 
+## Context Budgeting
+
+Mature coding agents avoid keeping an entire growing project in the prompt. AgInTiFlow uses a layered context pack:
+
+- Stable memory: `AGINTI.md`, `AGENTS.md`, README files, manifests, and package scripts.
+- Project map: `inspect_project` summaries, language counts, source/test directories, and recommended reads.
+- Active evidence: exact search hits, selected files, failing command output, and compact git status/diff.
+- Patch context: only the nearby code needed for `apply_patch`, plus before/after hashes and compact diffs.
+- Scout synthesis: cheap parallel DeepSeek scouts produce bounded advice, then a coordinator summary is injected instead of every long transcript becoming permanent context.
+
+This keeps the main executor sober: it knows where it is in the repo, but it still re-reads exact files before editing and validates with commands rather than trusting stale memory.
+
+## Git Discipline
+
+When asked to commit, pull, merge, or push, the agent should run `git status --short` and `git diff --stat` first. It should commit only intended changes, use `git fetch` and `git pull --ff-only` when remote state matters, and stop for the user on conflicts, divergence, unrelated dirty files, or any merge/rebase/reset choice. Web and CLI logs fold long command output but keep full command summaries visible.
+
 ## CLI And Web Parity
 
 Both CLI and web use the same task profile registry and the same model/tool schemas. Use either:
@@ -74,11 +90,15 @@ DeepSeek calls are cheap enough that complex tasks can use several short advisor
 - Implementer: predicts patch boundaries and focused checks.
 - Reviewer: looks for missing tests, risks, and instruction-compliance failures.
 - Researcher: suggests `web_search` queries when current information may matter.
+- Cartographer: builds a compact context map instead of dumping the whole tree.
+- Tester: finds the narrowest useful checks and setup blockers.
+- Git operator: keeps status/diff/commit/pull/push workflows disciplined.
+- Integrator: looks for cross-stream conflicts and ordering constraints.
 
-Scout output is injected as advisory context only. The main agent still owns execution and must use real tools to inspect, edit, run commands, and finish. CLI flags:
+Scout output is synthesized by a coordinator note and injected as advisory context only. The main agent still owns execution and must use real tools to inspect, edit, run commands, and finish. CLI flags:
 
 ```bash
-aginti --parallel-scouts --scout-count 4 "fix this complicated repo bug"
+aginti --parallel-scouts --scout-count 8 "fix this complicated repo bug"
 aginti --no-parallel-scouts "run a cheap short task"
 ```
 

package/package.json

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

package/public/app.js

@@ -122,8 +122,18 @@ const translations = {
     sendingStatus: "Sending...",
     runningStatus: "Running...",
     queuedStatus: "Queued for the running agent.",
+    queuedAsapStatus: "Piped into the shared session inbox.",
+    queuedAfterFinishStatus: "Queued for the next web run.",
     failedContinue: "Failed to continue the conversation.",
-    chatShortcutHelp: "Enter sends · Ctrl+J inserts a newline · Tab queues while the agent is running",
+    chatShortcutHelp: "Enter sends · Shift+Enter adds a newline · use buttons for pipe/queue control",
+    pipeMessageButton: "Pipe to run",
+    queueAfterFinishButton: "Queue after finish",
+    pendingMessagesTitle: "Pending messages",
+    asapQueueLabel: "ASAP pipe",
+    afterFinishQueueLabel: "After finish",
+    editQueuedMessage: "Edit",
+    removeQueuedMessage: "Remove",
+    queuedConsumedHint: "ASAP pipe messages are shared with CLI and consumed at the next safe agent boundary.",
     conversationMenuLabel: "Manage conversations",
     manageConversationsTitle: "Manage conversations",
     manageConversationsHelp: "Rename, auto-rename, or delete saved chat history.",
@@ -671,7 +681,10 @@ const sessionSelectEl = document.querySelector("#session-select");
 const chatThreadEl = document.querySelector("#chat-thread");
 const chatFormEl = document.querySelector("#chat-form");
 const chatInputEl = document.querySelector("#chat-input");
+const chatPendingEl = document.querySelector("#chat-pending");
 const chatStatusEl = document.querySelector("#chat-status");
+const pipeMessageButton = document.querySelector("#pipe-message");
+const queueAfterFinishButton = document.querySelector("#queue-after-finish");
 const manageSessionsButton = document.querySelector("#manage-sessions");
 const openArtifactsButton = document.querySelector("#open-artifacts");
 const artifactBadgeEl = document.querySelector("#artifact-badge");
@@ -714,6 +727,9 @@ let pollTimer = null;
 let saveTimer = null;
 let lastChatEntries = [];
 let lastSessions = [];
+let pendingInboxItems = [];
+let pendingAfterFinishItems = [];
+let flushingAfterFinish = false;
 let lastKeyStatus = null;
 let lastWrappers = [];
 let lastSandbox = null;
@@ -741,6 +757,21 @@ function setLogs(text, mode = "active") {
   logsEl.textContent = text;
 }
 
+function outputLineCount(value = "") {
+  const text = String(value || "");
+  return text ? text.split(/\r?\n/).length : 0;
+}
+
+function outputPreviewText(value = "", maxLines = 18) {
+  const lines = String(value || "").split(/\r?\n/);
+  const shown = lines.slice(0, maxLines);
+  return {
+    text: shown.join("\n"),
+    hidden: Math.max(lines.length - shown.length, 0),
+    total: value ? lines.length : 0,
+  };
+}
+
 function updateStopRunButton() {
   if (!stopRunButton) return;
   stopRunButton.hidden = currentRunStatus !== "running";
@@ -1011,7 +1042,7 @@ function formPayload() {
     allowAuxiliaryTools: allowAuxiliaryToolsField?.checked ?? true,
     allowWebSearch: allowWebSearchField?.checked ?? true,
     allowParallelScouts: allowParallelScoutsField?.checked ?? true,
-    parallelScoutCount: Number(parallelScoutCountField?.value) || 3,
+    parallelScoutCount: Math.min(Math.max(Number(parallelScoutCountField?.value) || 3, 1), 8),
     allowWrapperTools: allowWrapperToolsField.checked,
     preferredWrapper: preferredWrapperField.value,
     taskProfile: taskProfileField?.value || "auto",
@@ -1022,22 +1053,60 @@ function formPayload() {
   };
 }
 
+function renderCommandOutputLog(entry) {
+  const data = entry.data || {};
+  const command = data.command || "";
+  const stdout = data.stdout || "";
+  const stderr = data.stderr || "";
+  const stdoutPreview = outputPreviewText(stdout);
+  const stderrPreview = outputPreviewText(stderr);
+  const totalLines = outputLineCount(stdout) + outputLineCount(stderr);
+  const large = totalLines > 18 || stdout.length + stderr.length > 2600;
+  const policy = data.commandPolicy?.category ? ` · ${data.commandPolicy.category}` : "";
+  const status = data.blocked ? "blocked" : data.error ? "error" : "ok";
+  const details = [
+    stdout ? `<div class="log-stream-title">stdout</div><pre>${escapeHtml(stdoutPreview.text)}</pre>` : "",
+    stdoutPreview.hidden > 0 ? `<div class="log-fold-note">... ${stdoutPreview.hidden} more stdout line(s) folded</div>` : "",
+    stderr ? `<div class="log-stream-title">stderr</div><pre>${escapeHtml(stderrPreview.text)}</pre>` : "",
+    stderrPreview.hidden > 0 ? `<div class="log-fold-note">... ${stderrPreview.hidden} more stderr line(s) folded</div>` : "",
+    data.error ? `<div class="log-fold-note">${escapeHtml(data.error)}</div>` : "",
+  ]
+    .filter(Boolean)
+    .join("");
+
+  return `
+    <details class="log-command" ${large ? "" : "open"}>
+      <summary>
+        <span>${escapeHtml(`[${entry.at}] command ${status}${policy}`)}</span>
+        <code>${escapeHtml(command)}</code>
+        <small>stdout=${outputLineCount(stdout)} stderr=${outputLineCount(stderr)}${large ? " · folded" : ""}</small>
+      </summary>
+      ${details || `<div class="log-fold-note">No command output.</div>`}
+    </details>
+  `;
+}
+
 function renderLogs(run) {
-  const lines = [];
-  lines.push(`status=${run.status} session=${run.sessionId} provider=${run.provider} model=${run.model}`);
-  if (run.result) lines.push(`result=${run.result}`);
-  if (run.error) lines.push(`error=${run.error}`);
-  lines.push("");
+  logsEl.dataset.mode = "active";
+  const parts = [
+    `<div class="log-line">${escapeHtml(`status=${run.status} session=${run.sessionId} provider=${run.provider} model=${run.model}`)}</div>`,
+    run.result ? `<div class="log-line">${escapeHtml(`result=${run.result}`)}</div>` : "",
+    run.error ? `<div class="log-line error">${escapeHtml(`error=${run.error}`)}</div>` : "",
+  ];
 
   for (const entry of run.logs || []) {
-    lines.push(`[${entry.at}] ${entry.kind}: ${entry.message}`);
+    if (entry.message === "command.output") {
+      parts.push(renderCommandOutputLog(entry));
+      continue;
+    }
+    parts.push(`<div class="log-line">${escapeHtml(`[${entry.at}] ${entry.kind}: ${entry.message}`)}</div>`);
     if (entry.data && Object.keys(entry.data).length > 0) {
-      lines.push(JSON.stringify(entry.data, null, 2));
+      parts.push(`<pre class="log-json">${escapeHtml(JSON.stringify(entry.data, null, 2))}</pre>`);
     }
-    lines.push("");
   }
 
-  setLogs(lines.join("\n"));
+  logsEl.innerHTML = parts.filter(Boolean).join("");
+  logsEl.scrollTop = logsEl.scrollHeight;
 }
 
 function escapeHtml(value) {
@@ -1270,6 +1339,233 @@ function renderChat(chatEntries) {
   chatThreadEl.scrollTop = chatThreadEl.scrollHeight;
 }
 
+function afterFinishQueueKey(sessionId = currentSessionId) {
+  return `agintiflow.web.afterFinishQueue.${sessionId || "none"}`;
+}
+
+function loadAfterFinishQueue(sessionId = currentSessionId) {
+  if (!sessionId) return [];
+  try {
+    const parsed = JSON.parse(localStorage.getItem(afterFinishQueueKey(sessionId)) || "[]");
+    return Array.isArray(parsed) ? parsed.filter((item) => item?.id && item?.content) : [];
+  } catch {
+    return [];
+  }
+}
+
+function saveAfterFinishQueue(sessionId = currentSessionId) {
+  if (!sessionId) return;
+  localStorage.setItem(afterFinishQueueKey(sessionId), JSON.stringify(pendingAfterFinishItems));
+}
+
+function newLocalQueueId() {
+  if (globalThis.crypto?.randomUUID) return `after-${globalThis.crypto.randomUUID()}`;
+  return `after-${Date.now()}-${Math.random().toString(16).slice(2)}`;
+}
+
+function compactMessage(content, limit = 220) {
+  const text = String(content || "").replace(/\s+/g, " ").trim();
+  return text.length > limit ? `${text.slice(0, limit - 1)}...` : text;
+}
+
+function renderPendingMessages() {
+  if (!chatPendingEl) return;
+  const inboxItems = pendingInboxItems || [];
+  const afterItems = pendingAfterFinishItems || [];
+  if (inboxItems.length === 0 && afterItems.length === 0) {
+    chatPendingEl.hidden = true;
+    chatPendingEl.innerHTML = "";
+    return;
+  }
+
+  const section = (label, items, kind) => {
+    if (!items.length) return "";
+    return `
+      <div class="pending-section">
+        <div class="pending-label">${escapeHtml(label)}</div>
+        ${items
+          .map(
+            (item) => `
+              <div class="pending-item">
+                <div class="pending-copy">
+                  <span class="pending-kind ${kind}">${kind === "asap" ? "→" : "↳"}</span>
+                  <span>${escapeHtml(compactMessage(item.content))}</span>
+                </div>
+                <div class="pending-actions">
+                  <button type="button" class="mini-button" data-edit-${kind}="${escapeHtml(item.id)}">${t(
+                    "editQueuedMessage"
+                  )}</button>
+                  <button type="button" class="mini-button danger" data-remove-${kind}="${escapeHtml(item.id)}">${t(
+                    "removeQueuedMessage"
+                  )}</button>
+                </div>
+              </div>
+            `
+          )
+          .join("")}
+      </div>
+    `;
+  };
+
+  chatPendingEl.hidden = false;
+  chatPendingEl.innerHTML = `
+    <div class="pending-header">
+      <strong>${t("pendingMessagesTitle")}</strong>
+      <span>${t("queuedConsumedHint")}</span>
+    </div>
+    ${section(t("asapQueueLabel"), inboxItems, "asap")}
+    ${section(t("afterFinishQueueLabel"), afterItems, "after")}
+  `;
+}
+
+async function refreshInbox() {
+  if (!currentSessionId) {
+    pendingInboxItems = [];
+    pendingAfterFinishItems = [];
+    renderPendingMessages();
+    return;
+  }
+
+  pendingAfterFinishItems = loadAfterFinishQueue(currentSessionId);
+  const response = await fetch(`/api/sessions/${encodeURIComponent(currentSessionId)}/inbox`);
+  if (!response.ok) {
+    pendingInboxItems = [];
+    renderPendingMessages();
+    return;
+  }
+  const data = await response.json();
+  pendingInboxItems = data.items || [];
+  renderPendingMessages();
+}
+
+async function updateInboxItem(itemId, content) {
+  const response = await fetch(`/api/sessions/${encodeURIComponent(currentSessionId)}/inbox/${encodeURIComponent(itemId)}`, {
+    method: "PATCH",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ content }),
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(data.error || t("failedContinue"));
+  await refreshInbox();
+}
+
+async function removeInboxItem(itemId) {
+  const response = await fetch(`/api/sessions/${encodeURIComponent(currentSessionId)}/inbox/${encodeURIComponent(itemId)}`, {
+    method: "DELETE",
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) throw new Error(data.error || t("failedContinue"));
+  await refreshInbox();
+}
+
+function editAfterFinishItem(itemId) {
+  const item = pendingAfterFinishItems.find((candidate) => candidate.id === itemId);
+  if (!item) return;
+  pendingAfterFinishItems = pendingAfterFinishItems.filter((candidate) => candidate.id !== itemId);
+  saveAfterFinishQueue();
+  chatInputEl.value = item.content;
+  chatInputEl.focus();
+  renderPendingMessages();
+}
+
+function removeAfterFinishItem(itemId) {
+  pendingAfterFinishItems = pendingAfterFinishItems.filter((candidate) => candidate.id !== itemId);
+  saveAfterFinishQueue();
+  renderPendingMessages();
+}
+
+function queueAfterFinishFromInput() {
+  if (!currentSessionId) {
+    chatStatusEl.textContent = t("selectSessionFirst");
+    return;
+  }
+  const content = chatInputEl.value.trim();
+  if (!content) {
+    chatStatusEl.textContent = t("messageRequired");
+    return;
+  }
+  pendingAfterFinishItems = [
+    ...pendingAfterFinishItems,
+    {
+      id: newLocalQueueId(),
+      content,
+      timestamp: new Date().toISOString(),
+      source: "web",
+    },
+  ];
+  saveAfterFinishQueue();
+  chatInputEl.value = "";
+  chatStatusEl.textContent = t("queuedAfterFinishStatus");
+  renderPendingMessages();
+}
+
+async function pipeMessageFromInput() {
+  if (!currentSessionId) {
+    chatStatusEl.textContent = t("selectSessionFirst");
+    return;
+  }
+  const content = chatInputEl.value.trim();
+  if (!content) {
+    chatStatusEl.textContent = t("messageRequired");
+    return;
+  }
+
+  chatStatusEl.textContent = t("sendingStatus");
+  const response = await fetch(`/api/sessions/${encodeURIComponent(currentSessionId)}/inbox`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ content, priority: "asap" }),
+  });
+  const data = await response.json().catch(() => ({}));
+  if (!response.ok) {
+    chatStatusEl.textContent = data.error || t("failedContinue");
+    return;
+  }
+  chatInputEl.value = "";
+  chatStatusEl.textContent = t("queuedAsapStatus");
+  pendingInboxItems = data.item ? [...pendingInboxItems, data.item] : pendingInboxItems;
+  renderPendingMessages();
+  await refreshInbox();
+}
+
+async function flushAfterFinishQueue() {
+  if (!currentSessionId || flushingAfterFinish || currentRunStatus === "running" || pendingAfterFinishItems.length === 0) return;
+  flushingAfterFinish = true;
+  const next = pendingAfterFinishItems[0];
+  pendingAfterFinishItems = pendingAfterFinishItems.slice(1);
+  saveAfterFinishQueue();
+  renderPendingMessages();
+
+  try {
+    const response = await fetch(`/api/sessions/${encodeURIComponent(currentSessionId)}/messages`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        ...formPayload(),
+        content: next.content,
+      }),
+    });
+    const data = await response.json().catch(() => ({}));
+    if (!response.ok) throw new Error(data.error || t("failedContinue"));
+    currentSessionId = data.sessionId;
+    currentRunStatus = data.queued ? currentRunStatus : "running";
+    updateStopRunButton();
+    chatStatusEl.textContent = data.queued ? t("queuedStatus") : t("runningStatus");
+    await refreshSessions();
+    await refreshChat();
+    if (pollTimer) clearInterval(pollTimer);
+    pollTimer = setInterval(refreshRun, 1500);
+    await refreshRun();
+  } catch (error) {
+    pendingAfterFinishItems = [next, ...pendingAfterFinishItems];
+    saveAfterFinishQueue();
+    renderPendingMessages();
+    chatStatusEl.textContent = error instanceof Error ? error.message : String(error);
+  } finally {
+    flushingAfterFinish = false;
+  }
+}
+
 function artifactReadKey(sessionId = currentSessionId) {
   return `agintiflow.artifacts.readIds.${sessionId || "none"}`;
 }
@@ -1682,6 +1978,7 @@ async function refreshRun() {
   runMetaEl.textContent = `${run.status} · ${run.sessionId}`;
   renderLogs(run);
   await refreshArtifacts({ loadSelected: artifactTunnelDialog?.open });
+  await refreshInbox();
 
   if (run.status === "finished" || run.status === "failed" || run.status === "stopped") {
     clearInterval(pollTimer);
@@ -1690,6 +1987,7 @@ async function refreshRun() {
     await refreshSessions();
     await refreshWorkspaceChanges();
     await refreshArtifacts({ loadSelected: artifactTunnelDialog?.open });
+    if (run.status === "finished") await flushAfterFinishQueue();
   }
 }
 
@@ -1711,6 +2009,9 @@ async function stopCurrentRun() {
 
 async function refreshChat() {
   if (!currentSessionId) {
+    pendingInboxItems = [];
+    pendingAfterFinishItems = [];
+    renderPendingMessages();
     renderChat([]);
     return;
   }
@@ -1722,6 +2023,9 @@ async function refreshChat() {
   }
 
   const data = await response.json();
+  pendingInboxItems = data.inbox || [];
+  pendingAfterFinishItems = loadAfterFinishQueue(currentSessionId);
+  renderPendingMessages();
   renderChat(data.chat || []);
 }
 
@@ -2019,24 +2323,54 @@ form.addEventListener("input", schedulePreferenceSave);
 form.addEventListener("change", schedulePreferenceSave);
 
 chatInputEl.addEventListener("keydown", (event) => {
-  if (event.key === "j" && event.ctrlKey && !event.metaKey && !event.altKey) {
+  if (event.key === "Enter" && !event.shiftKey && !event.ctrlKey && !event.metaKey && !event.altKey) {
     event.preventDefault();
-    const start = chatInputEl.selectionStart ?? chatInputEl.value.length;
-    const end = chatInputEl.selectionEnd ?? chatInputEl.value.length;
-    chatInputEl.value = `${chatInputEl.value.slice(0, start)}\n${chatInputEl.value.slice(end)}`;
-    chatInputEl.selectionStart = chatInputEl.selectionEnd = start + 1;
+    chatFormEl.requestSubmit();
+  }
+});
+
+pipeMessageButton?.addEventListener("click", () => {
+  pipeMessageFromInput().catch((error) => {
+    chatStatusEl.textContent = String(error);
+  });
+});
+
+queueAfterFinishButton?.addEventListener("click", queueAfterFinishFromInput);
+
+chatPendingEl?.addEventListener("click", (event) => {
+  const target = event.target.closest("button");
+  if (!target) return;
+
+  const editAsap = target.dataset.editAsap;
+  const removeAsap = target.dataset.removeAsap;
+  const editAfter = target.dataset.editAfter;
+  const removeAfter = target.dataset.removeAfter;
+
+  if (editAsap) {
+    const item = pendingInboxItems.find((candidate) => candidate.id === editAsap);
+    const next = prompt(t("editQueuedMessage"), item?.content || "");
+    if (next !== null) {
+      updateInboxItem(editAsap, next).catch((error) => {
+        chatStatusEl.textContent = String(error);
+      });
+    }
     return;
   }
 
-  if (event.key === "Tab") {
-    event.preventDefault();
-    chatFormEl.requestSubmit();
+  if (removeAsap) {
+    removeInboxItem(removeAsap).catch((error) => {
+      chatStatusEl.textContent = String(error);
+    });
     return;
   }
 
-  if (event.key === "Enter" && !event.shiftKey && !event.ctrlKey && !event.metaKey && !event.altKey) {
-    event.preventDefault();
-    chatFormEl.requestSubmit();
+  if (editAfter) {
+    editAfterFinishItem(editAfter);
+    return;
+  }
+
+  if (removeAfter) {
+    removeAfterFinishItem(removeAfter);
   }
 });
 
@@ -2108,10 +2442,13 @@ sessionSelectEl.addEventListener("change", async () => {
   currentSessionId = sessionSelectEl.value;
   if (!currentSessionId) {
     currentRunStatus = "";
+    pendingInboxItems = [];
+    pendingAfterFinishItems = [];
     updateStopRunButton();
     runMetaEl.textContent = "";
     setLogs(t("noRunSelected"), "empty");
     renderChat([]);
+    renderPendingMessages();
     artifactItems = [];
     selectedArtifactId = "";
     renderArtifactShell();
@@ -2158,18 +2495,8 @@ chatFormEl.addEventListener("submit", async (event) => {
   updateStopRunButton();
   chatInputEl.value = "";
   chatStatusEl.textContent = data.queued ? t("queuedStatus") : t("runningStatus");
-  if (data.queued) {
-    renderChat([
-      ...lastChatEntries,
-      {
-        role: "user",
-        content,
-        at: new Date().toISOString(),
-      },
-    ]);
-  }
   await refreshSessions();
-  if (!data.queued) await refreshChat();
+  await refreshChat();
   await refreshWorkspaceChanges();
   await refreshArtifacts({ loadSelected: artifactTunnelDialog?.open });
 

package/public/index.html

@@ -205,7 +205,7 @@
 
           <label>
             <span data-i18n="parallelScoutCountLabel">Scout count</span>
-            <input id="parallelScoutCount" name="parallelScoutCount" type="number" min="1" max="4" value="3" />
+            <input id="parallelScoutCount" name="parallelScoutCount" type="number" min="1" max="8" value="3" />
           </label>
 
           <div class="grid wrapper-controls">
@@ -313,10 +313,15 @@
               placeholder="Continue the selected conversation here."
             ></textarea>
             <p class="chat-shortcuts subtle" data-i18n="chatShortcutHelp">
-              Enter sends · Ctrl+J inserts a newline · Tab queues while the agent is running
+              Enter sends · Shift+Enter adds a newline · use buttons for pipe/queue control
             </p>
+            <div id="chat-pending" class="chat-pending" hidden></div>
             <div class="actions">
               <button type="submit" data-i18n="sendMessageButton">Send message</button>
+              <button id="pipe-message" type="button" class="secondary" data-i18n="pipeMessageButton">Pipe to run</button>
+              <button id="queue-after-finish" type="button" class="secondary" data-i18n="queueAfterFinishButton">
+                Queue after finish
+              </button>
               <span id="chat-status" class="subtle"></span>
             </div>
           </form>
@@ -333,7 +338,7 @@
               <div id="run-meta" class="subtle"></div>
             </div>
           </div>
-          <pre id="logs" class="logs" data-i18n="noRunStarted">No run started.</pre>
+          <div id="logs" class="logs" data-i18n="noRunStarted">No run started.</div>
         </section>
       </section>
     </main>