@lazyingart/agintiflow 0.20.170 → 0.20.172

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lazyingart/agintiflow",
-  "version": "0.20.170",
+  "version": "0.20.172",
   "type": "module",
   "description": "AgInTiFlow is a project-aware agent workspace for hybrid wet-dry R&D, hardware-aware intelligence, software automation, and industrial workflows.",
   "license": "Apache-2.0",

package/public/app.js

@@ -1795,6 +1795,15 @@ function renderLogs(run) {
       parts.push(renderCommandOutputLog(entry));
       continue;
     }
+    if (entry.message === "plan.created" && entry.data?.plan) {
+      parts.push(`
+        <article class="log-plan">
+          <div class="log-plan-title">${escapeHtml(`[${entry.at}] plan`)}</div>
+          <div class="markdown-body">${renderMarkdown(entry.data.plan)}</div>
+        </article>
+      `);
+      continue;
+    }
     parts.push(`<div class="log-line">${escapeHtml(`[${entry.at}] ${entry.kind}: ${entry.message}`)}</div>`);
     if (entry.message === "tool.blocked" && entry.data?.permissionAdvice) {
       parts.push(renderPermissionApproval(entry));
@@ -2044,6 +2053,18 @@ function renderChat(chatEntries) {
 
   chatThreadEl.innerHTML = lastChatEntries
     .map((entry) => {
+      if (entry.role === "event") {
+        const label = entry.eventLabel || entry.eventType || "event";
+        const content = entry.markdown
+          ? `<div class="markdown-body">${renderMarkdown(entry.content)}</div>`
+          : escapeHtml(entry.content || "").replace(/\n/g, "<br>");
+        return `
+          <article class="chat-item event" data-event-type="${escapeHtml(entry.eventType || "")}">
+            <div class="chat-meta">${escapeHtml(label)}${entry.at ? ` · ${new Date(entry.at).toLocaleString()}` : ""}</div>
+            <div class="chat-content">${content}</div>
+          </article>
+        `;
+      }
       const role = entry.role === "assistant" ? "assistant" : "user";
       const label = role === "assistant" ? t("assistantLabel") : t("youLabel");
       const content =
@@ -2830,7 +2851,7 @@ async function refreshChat() {
   pendingInboxItems = data.inbox || [];
   pendingAfterFinishItems = loadAfterFinishQueue(currentSessionId);
   renderPendingMessages();
-  renderChat(data.chat || []);
+  renderChat(data.timeline || data.chat || []);
 }
 
 async function savePreferences() {

package/public/styles.css

@@ -1155,6 +1155,23 @@ button.danger {
   color: #fecaca;
 }
 
+.log-plan {
+  margin: 0 0 12px;
+  padding: 12px;
+  border: 1px solid rgba(94, 234, 212, 0.22);
+  border-radius: 14px;
+  background: rgba(15, 23, 42, 0.54);
+}
+
+.log-plan-title {
+  margin-bottom: 8px;
+  color: #99f6e4;
+  font-size: 0.82rem;
+  font-weight: 800;
+  letter-spacing: 0.04em;
+  text-transform: uppercase;
+}
+
 .log-json,
 .log-command pre {
   margin: 8px 0 12px;
@@ -1271,6 +1288,25 @@ button.danger {
   border-bottom-left-radius: 6px;
 }
 
+.chat-item.event {
+  justify-self: stretch;
+  width: auto;
+  max-width: 100%;
+  border-color: rgba(20, 184, 166, 0.28);
+  border-style: dashed;
+  background:
+    linear-gradient(90deg, rgba(20, 184, 166, 0.12), rgba(245, 158, 11, 0.08)),
+    rgba(255, 255, 255, 0.48);
+  box-shadow: none;
+}
+
+.chat-item.event[data-event-type="plan.created"] {
+  border-style: solid;
+  background:
+    radial-gradient(circle at 0% 0%, rgba(20, 184, 166, 0.16), transparent 28%),
+    linear-gradient(180deg, rgba(240, 253, 250, 0.88), rgba(255, 251, 235, 0.7));
+}
+
 .chat-meta {
   font-size: 0.8rem;
   color: var(--muted);

package/scripts/smoke-cli-chat.js

@@ -890,10 +890,13 @@ try {
   if (!latest.stdout.includes("  user>") || !latest.stdout.includes("aginti>") || latest.stdout.includes("user>   ")) {
     throw new Error("resume history should use prompt-style user>/aginti> labels");
   }
-  if (!latest.stdout.includes("resume note=showing chat transcript only")) {
-    throw new Error("bare aginti resume did not clarify that tool/run events are separate from chat history");
+  if (!latest.stdout.includes(" plan ")) {
+    throw new Error("bare aginti resume did not replay saved plan/run context");
   }
-  if (latest.stdout.includes("showing=") || latest.stdout.includes("…")) {
+  if (latest.stdout.includes("resume note=showing chat transcript only")) {
+    throw new Error("bare aginti resume regressed to chat-only history");
+  }
+  if (latest.stdout.includes("showing=")) {
     throw new Error("resume history should render full saved messages instead of compact previews");
   }
 

package/scripts/smoke-web-api.js

@@ -303,6 +303,15 @@ try {
   const chat = await fetchJson(`/api/sessions/${encodeURIComponent(runStart.sessionId)}/chat`);
   if (!Array.isArray(chat.chat) || chat.chat.length < 2) throw new Error("chat history was not persisted");
   if (!Array.isArray(chat.inbox)) throw new Error("chat endpoint did not include shared inbox state");
+  if (!Array.isArray(chat.events) || !chat.events.some((entry) => entry.type === "plan.created")) {
+    throw new Error("chat endpoint did not include saved plan events");
+  }
+  if (
+    !Array.isArray(chat.timeline) ||
+    !chat.timeline.some((entry) => entry.role === "event" && entry.eventType === "plan.created" && String(entry.content || "").trim())
+  ) {
+    throw new Error("chat endpoint did not return a resume-ready timeline with the saved plan");
+  }
 
   const queued = await fetchJson(`/api/sessions/${encodeURIComponent(runStart.sessionId)}/inbox`, {
     method: "POST",

package/src/interactive-cli.js

@@ -2207,6 +2207,127 @@ function printHistoryEntry(entry) {
   printHistoryBlock(role, entry.content, { time, bg });
 }
 
+function timestampMs(value = "") {
+  const parsed = Date.parse(String(value || ""));
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+
+function isReplayableResumeEvent(event = {}) {
+  const type = String(event.type || "");
+  const data = event.data || {};
+  if (type === "plan.created") return Boolean(data.plan);
+  if (
+    [
+      "budget.initialized",
+      "conversation.continued",
+      "conversation.queued_input_applied",
+      "file.changed",
+      "session.failed",
+      "session.finished",
+      "session.stopped",
+      "tool.blocked",
+      "tool.failed",
+      "tool.skipped",
+      "tool.started",
+    ].includes(type)
+  ) {
+    return true;
+  }
+  if (type === "tool.completed") {
+    const toolName = String(data.toolName || "");
+    return ["run_command", "write_file", "apply_patch", "create_artifact"].includes(toolName) || data.ok === false || data.blocked || data.error;
+  }
+  return false;
+}
+
+function resumeTimelineItems(chat = [], events = [], { limit = 0 } = {}) {
+  const shownChat = limit > 0 ? chat.slice(-limit) : chat;
+  const firstChatTime = limit > 0 && shownChat.length > 0 ? timestampMs(shownChat[0].at) : 0;
+  const chatItems = shownChat.map((entry, index) => ({
+    kind: "chat",
+    entry,
+    order: index * 2,
+    at: timestampMs(entry.at),
+  }));
+  const eventItems = events
+    .map((event, index) => ({ event, index }))
+    .filter(({ event }) => isReplayableResumeEvent(event))
+    .filter(({ event }) => !firstChatTime || timestampMs(event.timestamp) >= firstChatTime)
+    .map(({ event, index }) => ({
+      kind: "event",
+      event,
+      order: index * 2 + 1,
+      at: timestampMs(event.timestamp),
+    }));
+  return [...chatItems, ...eventItems].sort((left, right) => (left.at || 0) - (right.at || 0) || left.order - right.order);
+}
+
+function printResumeEvent(event = {}) {
+  const type = String(event.type || "");
+  const data = event.data || {};
+  if (type === "plan.created") {
+    printWrapped(`${label("plan", ansi.systemBg)} `, data.plan || "");
+    return true;
+  }
+  if (type === "tool.started") {
+    outputLine(`${label("tool", ansi.statusBg)} ${toolStatusDetails(data)}`);
+    return true;
+  }
+  if (type === "tool.completed" || type === "tool.failed" || type === "tool.skipped") {
+    const failed = type === "tool.failed" || data.ok === false || data.blocked || data.error;
+    if (data.toolName === "run_command") {
+      printCommandOutputLog({
+        command: data.args?.command || data.command || "",
+        stdout: data.stdout || "",
+        stderr: data.stderr || "",
+        diagnosticHint: data.diagnosticHint || "",
+        commandPolicy: data.commandPolicy,
+        blocked: Boolean(data.blocked),
+        error: data.error || data.reason || "",
+        permissionAdvice: data.permissionAdvice || null,
+      });
+    }
+    outputLine(`${label(failed ? "fail" : "done", failed ? ansi.red : ansi.systemBg)} ${toolStatusDetails(data)}`);
+    return true;
+  }
+  if (type === "tool.blocked") {
+    outputLine(`${label("perm", ansi.red)} ${compactLine(data.reason || data.permissionAdvice?.summary || data.toolName || "Permission blocked.", 104)}`);
+    if (data.permissionAdvice?.suggestedCommand) outputLine(`${color(" | ", ansi.red)} rerun: ${compactLine(data.permissionAdvice.suggestedCommand, 120)}`);
+    if (data.permissionAdvice?.trustedHostCommand) outputLine(`${color(" | ", ansi.red)} host: ${compactLine(data.permissionAdvice.trustedHostCommand, 120)}`);
+    return true;
+  }
+  if (type === "file.changed") {
+    if (data.diff) printWorkspaceChange(data);
+    else outputLine(`${label("write", ansi.systemBg)} ${compactLine(formatWorkspaceChange(data).summary, 92)}`);
+    return true;
+  }
+  if (type === "budget.initialized") {
+    outputLine(`${label("state", ansi.systemBg)} budget=${data.currentMaxSteps || data.initialMaxSteps || data.maxSteps || "unknown"} steps`);
+    return true;
+  }
+  if (type === "conversation.continued") {
+    outputLine(`${label("state", ansi.systemBg)} continued=${compactLine(data.prompt || "", 76)}`);
+    return true;
+  }
+  if (type === "conversation.queued_input_applied") {
+    outputLine(`${label("state", ansi.systemBg)} queued_input_applied=${data.priority === "asap" ? "asap" : "normal"}`);
+    return true;
+  }
+  if (type === "session.finished") {
+    outputLine(`${label("state", ansi.systemBg)} status=finished${data.result ? ` result=${compactLine(data.result, 86)}` : ""}`);
+    return true;
+  }
+  if (type === "session.failed") {
+    outputLine(`${label("state", ansi.red)} status=failed${data.error ? ` error=${compactLine(data.error, 86)}` : ""}`);
+    return true;
+  }
+  if (type === "session.stopped") {
+    outputLine(`${label("state", ansi.systemBg)} status=stopped${data.reason ? ` reason=${compactLine(data.reason, 86)}` : ""}`);
+    return true;
+  }
+  return false;
+}
+
 async function printResumeHistory(state, { limit = 0 } = {}) {
   if (!state.sessionId) return;
   const paths = projectPaths(process.cwd());
@@ -2215,23 +2336,24 @@ async function printResumeHistory(state, { limit = 0 } = {}) {
   const events = await store.loadEvents().catch(() => []);
   const chat = Array.isArray(saved?.chat) ? saved.chat.filter((entry) => entry?.content) : [];
   promptHistory.seedFromChat(chat, state.sessionId);
-  const metadata = `chat=${chat.length}${events.length > 0 ? ` events=${events.length}` : ""}`;
-  if (chat.length === 0) {
+  const timeline = resumeTimelineItems(chat, events, { limit });
+  const replayedEvents = timeline.filter((item) => item.kind === "event").length;
+  const metadata = `chat=${chat.length}${events.length > 0 ? ` events=${events.length}` : ""}${replayedEvents > 0 ? ` replay=${replayedEvents}` : ""}`;
+  if (timeline.length === 0) {
     printSystemLine(`resume history session=${state.sessionId} ${metadata}`);
-    if (events.length > 0) {
-      printSystemLine("resume note=showing chat transcript only; model/tool/run events are saved in events.jsonl and artifacts/");
-    }
     return;
   }
 
-  const shown = limit > 0 ? chat.slice(-limit) : chat;
   printSystemLine(
-    `resume history session=${state.sessionId} ${metadata}${limit > 0 ? ` showing=${shown.length}/${chat.length}` : ""}`
+    `resume history session=${state.sessionId} ${metadata}${limit > 0 ? ` showing=${timeline.length}/${chat.length + events.length}` : ""}`
   );
-  if (events.length > chat.length) {
-    printSystemLine("resume note=showing chat transcript only; model/tool/run events are saved in events.jsonl and artifacts/");
+  if (events.length > replayedEvents) {
+    printSystemLine("resume note=showing chat plus key run events; full raw events remain in events.jsonl and artifacts/.");
+  }
+  for (const item of timeline) {
+    if (item.kind === "chat") printHistoryEntry(item.entry);
+    else printResumeEvent(item.event);
   }
-  for (const entry of shown) printHistoryEntry(entry);
 }
 
 function toolStatusDetails(data = {}) {

package/src/web-db.js

@@ -245,6 +245,18 @@ export class WebDatabase {
         }
         this.savePreferences(preferences);
       }
+      if (
+        preferences.veniceMode !== true &&
+        preferences.routingMode !== "manual" &&
+        preferences.provider !== "venice" &&
+        (preferences.routeProvider === "venice" || preferences.mainProvider === "venice")
+      ) {
+        preferences.routeProvider = "deepseek";
+        preferences.routeModel = "deepseek-v4-flash";
+        preferences.mainProvider = "deepseek";
+        preferences.mainModel = "deepseek-v4-pro";
+        this.savePreferences(preferences);
+      }
       return preferences;
     } catch {
       return defaultPreferences(this.baseDir);

package/web.js

@@ -102,6 +102,131 @@ function mapEventLogs(events) {
   }));
 }
 
+function compactText(value = "", limit = 120) {
+  const text = String(value || "").replace(/\s+/g, " ").trim();
+  return text.length <= limit ? text : `${text.slice(0, Math.max(limit - 1, 1)).trim()}...`;
+}
+
+function toolTimelineSummary(data = {}) {
+  const tool = data.toolName || "unknown";
+  const args = data.args || {};
+  if (tool === "run_command" && args.command) return `${tool}: ${compactText(args.command, 92)}`;
+  if ((tool === "write_file" || tool === "apply_patch" || tool === "read_file" || tool === "open_workspace_file") && args.path) {
+    return `${tool}: ${compactText(args.path, 92)}`;
+  }
+  if ((tool === "open_url" || tool === "web_research" || tool === "web_search") && (args.url || args.query || args.q)) {
+    return `${tool}: ${compactText(args.url || args.query || args.q, 92)}`;
+  }
+  return tool;
+}
+
+function timelineEntryForEvent(event = {}) {
+  const type = String(event.type || "");
+  const data = event.data || {};
+  const at = event.timestamp || "";
+  if (type === "plan.created" && data.plan) {
+    return {
+      role: "event",
+      eventType: type,
+      eventLabel: "plan",
+      content: data.plan,
+      markdown: true,
+      at,
+    };
+  }
+  if (type === "tool.started") {
+    return {
+      role: "event",
+      eventType: type,
+      eventLabel: "tool",
+      content: toolTimelineSummary(data),
+      at,
+    };
+  }
+  if (type === "tool.completed" || type === "tool.failed" || type === "tool.skipped") {
+    const failed = type === "tool.failed" || data.ok === false || data.blocked || data.error;
+    const stdout = data.toolName === "run_command" && data.stdout ? `\nstdout: ${compactText(data.stdout, 180)}` : "";
+    const stderr = data.toolName === "run_command" && data.stderr ? `\nstderr: ${compactText(data.stderr, 180)}` : "";
+    return {
+      role: "event",
+      eventType: type,
+      eventLabel: failed ? "tool failed" : "tool done",
+      content: `${toolTimelineSummary(data)}${stdout}${stderr}`,
+      at,
+    };
+  }
+  if (type === "tool.blocked") {
+    return {
+      role: "event",
+      eventType: type,
+      eventLabel: "permission",
+      content: data.permissionAdvice?.summary || data.reason || data.toolName || "Permission blocked.",
+      at,
+    };
+  }
+  if (type === "file.changed") {
+    return {
+      role: "event",
+      eventType: type,
+      eventLabel: data.toolName === "apply_patch" ? "patch" : "write",
+      content: [data.toolName || data.action || "file.changed", data.path || "", data.created ? "created" : "updated"]
+        .filter(Boolean)
+        .join(" "),
+      at,
+    };
+  }
+  if (type === "budget.initialized") {
+    return {
+      role: "event",
+      eventType: type,
+      eventLabel: "budget",
+      content: `${data.currentMaxSteps || data.initialMaxSteps || data.maxSteps || "unknown"} steps`,
+      at,
+    };
+  }
+  if (type === "conversation.continued") {
+    return {
+      role: "event",
+      eventType: type,
+      eventLabel: "continued",
+      content: data.prompt || "",
+      at,
+    };
+  }
+  if (type === "conversation.queued_input_applied") {
+    return {
+      role: "event",
+      eventType: type,
+      eventLabel: "queued input",
+      content: data.priority === "asap" ? "ASAP queued input applied" : "Queued input applied",
+      at,
+    };
+  }
+  if (type === "session.finished" || type === "session.failed" || type === "session.stopped") {
+    return {
+      role: "event",
+      eventType: type,
+      eventLabel: type.replace("session.", ""),
+      content: data.result || data.error || data.reason || type,
+      at,
+    };
+  }
+  return null;
+}
+
+function sessionTimelineFromChatAndEvents(chat = [], events = []) {
+  const chatItems = (Array.isArray(chat) ? chat : [])
+    .filter((entry) => entry?.content)
+    .map((entry, index) => ({ ...entry, order: index * 2, sortAt: Date.parse(entry.at || "") || 0 }));
+  const eventItems = (Array.isArray(events) ? events : [])
+    .map(timelineEntryForEvent)
+    .filter(Boolean)
+    .map((entry, index) => ({ ...entry, order: index * 2 + 1, sortAt: Date.parse(entry.at || "") || 0 }));
+  return [...chatItems, ...eventItems]
+    .sort((left, right) => (left.sortAt || 0) - (right.sortAt || 0) || left.order - right.order)
+    .map(({ sortAt: _sortAt, order: _order, ...entry }) => entry);
+}
+
 async function loadStoredRun(sessionId) {
   const meta = db.getSession(sessionId);
   if (!meta) return null;
@@ -606,11 +731,16 @@ function deriveChatFromState(state, meta) {
 
 async function loadChat(sessionId) {
   const store = sessionStore(sessionId);
-  const [state, meta] = await Promise.all([store.loadState(), Promise.resolve(db.getSession(sessionId))]);
+  const [state, meta, events] = await Promise.all([
+    store.loadState(),
+    Promise.resolve(db.getSession(sessionId)),
+    store.loadEvents().catch(() => []),
+  ]);
 
   if (!state && !meta) return null;
 
   const inbox = await store.loadInbox().catch(() => []);
+  const chat = deriveChatFromState(state, meta);
   return {
     sessionId,
     goal: state?.goal || meta?.goal || "",
@@ -619,7 +749,9 @@ async function loadChat(sessionId) {
     model: state?.model || meta?.model || "",
     status: meta?.status || "",
     inbox,
-    chat: deriveChatFromState(state, meta),
+    chat,
+    events: events.slice(-120),
+    timeline: sessionTimelineFromChatAndEvents(chat, events).slice(-220),
   };
 }