@a-t-h-i/bot-lobby 0.6.2 → 0.6.3

package/src/lobby/view.ts

@@ -9,7 +9,8 @@
  * pane toggles, paging) work in both. Everything bot-lobby-specific arrives
  * through `LobbyHost`, so the view renders and reacts the same in tests.
  */
-import { decodeKittyPrintable, Editor, Input, Key, matchesKey, visibleWidth, type Component, type EditorTheme, type Focusable, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
+import { decodeKittyPrintable, Editor, Input, Key, matchesKey, type Component, type EditorTheme, type Focusable, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from "@earendil-works/pi-tui";
+import { textWidth } from "../width.ts";
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
 import type { AgentRun } from "../schemas/findings.ts";
 import type { PlannedTask } from "../state/backlog.ts";
@@ -23,7 +24,7 @@ import { MEMBER_LABELS, ORACLE_LABEL, type PlannerSeed, type PlanningSession } f
 import { issueText, type IssuesState } from "./issues.ts";
 import { actionFor, keyLabel, keyMap, LOBBY_ACTIONS, type KeyMap, type LobbyAction } from "./keys.ts";
 import { beside, bold, box, fit, highlight, paint, rule, selectRow, spinner, spread, windowStart, wrap, wrapHanging, type LobbyTheme, type PaneLayout } from "./layout.ts";
-import { chatLines, HOME_PANES, renderHome, type HomePane } from "./tabs/home.ts";
+import { chatTail, HOME_PANES, renderHome, type HomePane } from "./tabs/home.ts";
 import { filterRows, pips, planDetailLines, renderTasks, taskDetailLines, taskProgress, taskRows, tasksWidths, type TaskRow } from "./tabs/tasks.ts";
 import { renderPlan, type PlanLayout, type PlanView, type SeatView } from "./tabs/plan.ts";
 import { filterJobs, newestFirst, renderQuickFix } from "./tabs/quickfix.ts";
@@ -113,6 +114,9 @@ function sameView(a: SessionView, b: SessionView): boolean {
   return true;
 }
 
+/** Tops a conversation whose earlier messages are not in memory. */
+export const OLDER_NOTE = "↑ earlier messages load as you scroll up";
+
 const SECTION_OF: Record<SessionWhere, string> = { "this window": "THIS WINDOW", background: "BACKGROUND", "other terminal": "OTHER TERMINALS", "not running": "NOT RUNNING" };
 const WHERE_MARKS: Record<SessionWhere, string> = { "this window": "●", background: "◆", "other terminal": "◇", "not running": "○" };
 
@@ -189,8 +193,12 @@ export interface LobbyHost {
   archiveTask(taskId: string): string;
   restoreTask(taskId: string): string;
   deleteTask(taskId: string, where: "list" | "archive"): string;
-  /** Another session's conversation, read from its saved session file. */
+  /** Another session's conversation, read from its saved session file (its newest messages). */
   sessionChat(sessionId: string): ChatEntry[];
+  /** Whether another session has messages earlier than `sessionChat` returns. */
+  hasOlderChat(sessionId: string): boolean;
+  /** A session's whole conversation, oldest first: this window's (no id) or another's; loaded only while scrolled back to it. */
+  chatHistory(sessionId?: string): readonly ChatEntry[];
   /** A task's status without animations, for a session other than this window's. */
   taskScene(task: Task, width: number, height: number): string[];
   profileLabel(kind: LobbyAgentKind): string;
@@ -216,7 +224,7 @@ class LobbyEditor extends Editor {
     if (!this.label) return super.renderTopBorder(width, hiddenLineCount);
     const label = ` ${this.label} `;
     const more = hiddenLineCount > 0 ? ` ↑${hiddenLineCount} ` : "";
-    const rest = width - 2 - visibleWidth(label) - visibleWidth(more);
+    const rest = width - 2 - textWidth(label) - textWidth(more);
     if (rest < 1) return super.renderTopBorder(width, hiddenLineCount);
     return `${this.borderColor("──")}${this.paintLabel(label)}${this.borderColor("─".repeat(rest))}${more ? this.borderColor(more) : ""}`;
   }
@@ -430,6 +438,7 @@ export class LobbyView implements Component, Focusable {
   refreshData(force: boolean): void {
     const now = this.now();
     if (!force && now - this.data.at < DATA_REFRESH_MS) return;
+    this.dataVersion += 1;
     this.data = {
       tasks: this.host.tasks(),
       plans: this.host.plans(),
@@ -838,6 +847,7 @@ export class LobbyView implements Component, Focusable {
         break;
     }
     this.clampScroll();
+    if (pane === "conversation") this.followHistory();
   }
 
   /** Home and End: the oldest or first line of the focused pane, or back to its newest or last. */
@@ -861,6 +871,8 @@ export class LobbyView implements Component, Focusable {
       return;
     }
     this.scrollPane(pane, far);
+    // Home loads earlier messages at the top; go on to the very first of them.
+    if (start && pane === "conversation" && this.history) this.homeOffsets.conversation = Number.MAX_SAFE_INTEGER;
   }
 
   /** The wheel over the draft scrolls it; the cursor follows only when it would leave the screen. */
@@ -954,7 +966,9 @@ export class LobbyView implements Component, Focusable {
     const rows = this.taskRowList();
     this.tasksSelected = Math.max(0, Math.min(rows.length - 1, index));
     this.tasksDetailOffset = 0;
-    this.refreshData(true);
+    // Only the newly selected task's comments: moving through the list must not reread every task from disk.
+    const row = rows[this.tasksSelected];
+    if (row?.kind === "task" && !this.data.comments.has(row.id)) this.data.comments.set(row.id, this.host.comments(row.id));
   }
 
   private async loadIssueDetail(): Promise<void> {
@@ -1205,6 +1219,50 @@ export class LobbyView implements Component, Focusable {
     void this.host.answerDialog(session).then(() => this.host.requestRender());
   }
 
+  /* -------------------------------------------------------------- history */
+
+  /**
+   * The whole conversation of the session in view, loaded when the
+   * conversation pane is scrolled back past the messages kept in memory, and
+   * let go once it is back at the newest.
+   */
+  private history?: { view: SessionView; entries: readonly ChatEntry[] };
+
+  /** The conversation to draw for the session in view, and whether earlier messages wait to be loaded. */
+  private conversationFor(entry: SessionEntry): { chat: readonly ChatEntry[]; older: boolean } {
+    if (this.history && sameView(this.history.view, entry.view)) return { chat: this.history.entries, older: false };
+    if (entry.view.kind === "here") return { chat: this.host.feed.chat, older: this.host.feed.chatOlder };
+    if (entry.view.kind === "background") {
+      const session = this.viewedSessionFor(entry.view.key);
+      return { chat: session?.feed.chat ?? [], older: Boolean(session?.feed.chatOlder && session.sessionId) };
+    }
+    return entry.sessionId ? { chat: this.host.sessionChat(entry.sessionId), older: this.host.hasOlderChat(entry.sessionId) } : { chat: [], older: false };
+  }
+
+  /**
+   * After the conversation pane scrolls: at its top, with earlier messages
+   * waiting, load the whole conversation; back at its newest, let it go.
+   * True when history was loaded now.
+   */
+  private followHistory(): boolean {
+    if (this.tab !== "lobby") return false;
+    if (this.homeOffsets.conversation === 0) {
+      this.history = undefined;
+      return false;
+    }
+    if (this.history && sameView(this.history.view, this.viewing)) return false;
+    const pane = this.panes.get("conversation");
+    if (!pane || this.homeOffsets.conversation < pane.total - pane.rows) return false;
+    const entry = this.viewedEntry();
+    if (!this.conversationFor(entry).older) return false;
+    const sessionId = entry.view.kind === "here" ? undefined : entry.view.kind === "background" ? this.viewedSessionFor(entry.view.key)?.sessionId : entry.sessionId;
+    if (entry.view.kind !== "here" && !sessionId) return false;
+    const entries = this.host.chatHistory(sessionId);
+    if (entries.length === 0) return false;
+    this.history = { view: entry.view, entries };
+    return true;
+  }
+
   /* ------------------------------------------------------------ sessions */
 
   /** Every session the lobby can show: this window, the background sessions it started, then tasks other terminals drive. */
@@ -1270,6 +1328,7 @@ export class LobbyView implements Component, Focusable {
     this.viewing = target;
     this.picking = false;
     this.newSession = false;
+    this.history = undefined;
     for (const pane of HOME_PANES) this.homeOffsets[pane] = 0;
     if (this.tab !== "lobby") this.setTab("lobby");
     this.setMode("type");
@@ -1657,8 +1716,41 @@ export class LobbyView implements Component, Focusable {
 
   /* -------------------------------------------------------------- render */
 
+  /** Bumped each time the data is reread. */
+  private dataVersion = 0;
+  /** Task rows as last built: several parts of a frame ask, and they only change with the data, the search or the clock. */
+  private rowsMemo?: { key: string; rows: TaskRow[] };
+
+  /** The Metrics tab's figures as last computed: they change only with the data, the grouping, the order or the search. */
+  private metricsMemo?: { key: string; figures: ReturnType<LobbyView["computeMetrics"]> };
+
+  private metricsFigures(query: string | undefined) {
+    const key = `${this.dataVersion}|${this.metricsBy}|${this.metricsSort}|${query ?? ""}`;
+    if (this.metricsMemo?.key !== key) this.metricsMemo = { key, figures: this.computeMetrics(query) };
+    return this.metricsMemo.figures;
+  }
+
+  private computeMetrics(query: string | undefined) {
+    const records = filterRecords(collectMetrics(this.data.metrics, this.data.tasks), query);
+    return {
+      records,
+      groups: sortGroups(aggregateMetrics(records, this.metricsBy), this.metricsSort),
+      taskTimes: taskTimesByModel(this.data.tasks, records),
+      stats: taskStats(this.data.tasks),
+      jev: summarizeClassifier(this.data.classifierMetrics, records),
+    };
+  }
+
   /** Task rows, narrowed by the Tasks tab's search. */
   private taskRowList(): TaskRow[] {
+    const key = `${this.dataVersion}|${this.tick}|${this.showArchived}|${this.queries.tasks ?? ""}`;
+    if (this.rowsMemo?.key === key) return this.rowsMemo.rows;
+    const rows = this.buildTaskRows();
+    this.rowsMemo = { key, rows };
+    return rows;
+  }
+
+  private buildTaskRows(): TaskRow[] {
     const names = new Map<string, string>();
     for (const session of this.host.sessions()) if (session.sessionId && session.alive) names.set(session.sessionId, session.name);
     const auto = new Set(this.data.tasks.filter((task) => !TERMINAL_STATES.includes(task.state) && this.host.isAuto(task.id)).map((task) => task.id));
@@ -1691,12 +1783,12 @@ export class LobbyView implements Component, Focusable {
       const badge = badges[tab] ? ` ${paint(theme, tab === "plan" && session?.awaitingAnswers ? "warning" : "accent", badges[tab]!)}` : "";
       let cell = ` ${number} ${name}${badge} `;
       if (tab === this.tab) cell = theme.bg ? theme.bg("selectedBg", cell) : `[${cell}]`;
-      const from = visibleWidth(left);
+      const from = textWidth(left);
       left += cell;
-      spans.push({ tab, from, to: visibleWidth(left) });
+      spans.push({ tab, from, to: textWidth(left) });
     }
     this.tabSpans = spans;
-    const room = width - visibleWidth(left) - 1;
+    const room = width - textWidth(left) - 1;
     const entry = this.viewedEntry();
     const help = paint(theme, "dim", `${keyLabel(this.keys.help)} keys `);
     const auto = entry.auto ? ` ${bold(theme, paint(theme, "success", "⟳ AUTO"))}` : "";
@@ -1717,8 +1809,8 @@ export class LobbyView implements Component, Focusable {
         ? [`${dot} ${zen.task.id} ${state}${auto}${asking}  ${help}`, `${dot} ${zen.task.id} ${state}${auto}${asking} `, `${dot} ${state}${auto} `, `${dot}${auto} `]
         : [`${paint(theme, "dim", "no task in this session")}${asking}  ${help}`, `${paint(theme, "dim", "no task in this session")}${asking} `, help, ""];
     }
-    const status = choices.find((choice) => visibleWidth(choice) <= room) ?? "";
-    const gap = width - visibleWidth(left) - visibleWidth(status);
+    const status = choices.find((choice) => textWidth(choice) <= room) ?? "";
+    const gap = width - textWidth(left) - textWidth(status);
     return gap >= 1 ? `${left}${" ".repeat(gap)}${status}` : fit(left, width);
   }
 
@@ -1780,7 +1872,7 @@ export class LobbyView implements Component, Focusable {
     const tail = this.searching
       ? paint(theme, "dim", " enter keep · esc clear · ↑↓ browse results ")
       : paint(theme, "dim", ` ${keyLabel(this.keys.search)} or / edits · esc clears `);
-    const room = Math.max(4, width - visibleWidth(lead) - visibleWidth(tail));
+    const room = Math.max(4, width - textWidth(lead) - textWidth(tail));
     const field = this.searching ? this.search.render(room)[0] ?? "" : bold(theme, fit(query ?? "", room));
     return [fit(`${lead}${fit(field, room)}${tail}`, width)];
   }
@@ -2018,12 +2110,9 @@ export class LobbyView implements Component, Focusable {
         }, width, height, theme);
       }
       case "metrics": {
-        const records = filterRecords(collectMetrics(this.data.metrics, this.data.tasks), query);
-        const groups = sortGroups(aggregateMetrics(records, this.metricsBy), this.metricsSort);
+        const { records, groups, taskTimes, stats, jev } = this.metricsFigures(query);
         this.metricsSelected = Math.min(this.metricsSelected, Math.max(0, groups.length - 1));
-        const taskTimes = taskTimesByModel(this.data.tasks, records);
-        const jev = summarizeClassifier(this.data.classifierMetrics, records);
-        return renderMetrics({ groups, taskTimes, records, stats: taskStats(this.data.tasks), by: this.metricsBy, sort: this.metricsSort, selected: this.metricsSelected, ...(query ? { query } : {}), panes: this.panes, ...(jev ? { classifier: jev } : {}) }, width, height, theme);
+        return renderMetrics({ groups, taskTimes, records, stats, by: this.metricsBy, sort: this.metricsSort, selected: this.metricsSelected, ...(query ? { query } : {}), panes: this.panes, ...(jev ? { classifier: jev } : {}) }, width, height, theme);
       }
     }
   }
@@ -2150,7 +2239,7 @@ export class LobbyView implements Component, Focusable {
     const room = height - lines.length - 2;
     if (room > 2) {
       lines.push("", rule(width, "Conversation", theme));
-      const talk = chat.length > 0 ? chatLines(chat, width, theme) : [paint(theme, "dim", "Nothing said yet.")];
+      const talk = chat.length > 0 ? chatTail(chat, width, theme, room - 1).lines : [paint(theme, "dim", "Nothing said yet.")];
       lines.push(...talk.slice(-(room - 1)));
     }
     return lines;
@@ -2175,9 +2264,11 @@ export class LobbyView implements Component, Focusable {
     const query = this.query();
     const entry = this.viewedEntry();
     if (entry.view.kind !== "here") return this.otherSessionBody(entry, width, height, theme, now);
+    const talk = this.conversationFor(entry);
     return renderHome({
       ...(zen.task ? { task: zen.task, scene: (w: number, h: number, animated: boolean) => this.host.scene(w, h, animated) } : {}),
-      chat: feed.chat,
+      chat: talk.chat,
+      ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
       ...(feed.reply ? { liveReply: feed.reply } : {}),
       activity: feed.activity,
       thoughts: feed.thoughts,
@@ -2207,6 +2298,7 @@ export class LobbyView implements Component, Focusable {
    */
   private otherSessionBody(entry: SessionEntry, width: number, height: number, theme: LobbyTheme, now: number): string[] {
     const session = this.viewedSession();
+    const talk = this.conversationFor(entry);
     const task = entry.task;
     const query = this.query();
     const common = {
@@ -2232,7 +2324,8 @@ export class LobbyView implements Component, Focusable {
       const emptyNote = session.status === "starting" ? `starting ${session.name}…` : !session.alive ? `${session.name} has ended.` : `${session.name} has not said anything yet.`;
       return renderHome({
         ...common,
-        chat: session.feed.chat,
+        chat: talk.chat,
+        ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
         ...(session.feed.reply ? { liveReply: session.feed.reply } : {}),
         activity: session.feed.activity,
         thoughts: session.feed.thoughts,
@@ -2243,7 +2336,8 @@ export class LobbyView implements Component, Focusable {
     const running = entry.where === "other terminal";
     return renderHome({
       ...common,
-      chat: entry.sessionId ? this.host.sessionChat(entry.sessionId) : [],
+      chat: talk.chat,
+      ...(talk.older ? { olderNote: OLDER_NOTE } : {}),
       activity: [],
       thoughts: [],
       busy: false,

package/src/pi/events.ts

@@ -15,6 +15,7 @@ import { taskRequest, type Task, type TaskState } from "../schemas/task.ts";
 import { pendingComments, readPlanComments, type PlanComment } from "../state/comments.ts";
 import { isAutoMode } from "../state/auto.ts";
 import { triageContext } from "../classifier/triage.ts";
+import { previousTaskNote } from "./fresh-context.ts";
 
 /** States in which the triage still helps the Master shape the task; once it is planned, the hints are noise. */
 const SHAPING_STATES: ReadonlySet<TaskState> = new Set(["created", "clarifying", "scouting", "synthesizing", "awaiting_approval"]);
@@ -92,9 +93,13 @@ export function registerLifecycle(pi: ExtensionAPI, configDir: string): void {
   pi.on("before_agent_start", (event, ctx) => {
     const root = detectProjectRoot(ctx.cwd, configDir);
     const sessionId = ctx.sessionManager.getSessionId();
-    const task = isSubagentProcess() || isMinimized() ? undefined : activeTask(root, configDir, sessionId);
+    const hidden = isSubagentProcess() || isMinimized();
+    const task = hidden ? undefined : activeTask(root, configDir, sessionId);
     if (!task) {
-      delete event.systemPromptOptions.sections["bot-lobby"];
+      // After a task ended and cleared the context, a line on where its record is, in case the user refers back to it.
+      const previous = hidden ? undefined : previousTaskNote(ctx, configDir);
+      if (previous) event.systemPromptOptions.sections["bot-lobby"] = previous;
+      else delete event.systemPromptOptions.sections["bot-lobby"];
       return;
     }
     const slices = readAgentKnowledge(readDataRoots(root, configDir), "master");

package/src/pi/fresh-context.ts

@@ -0,0 +1,134 @@
+/**
+ * A clean slate for the oracle at every task. The session keeps its whole
+ * conversation (the lobby, /tree and /resume still show all of it), but the
+ * model is sent only what came after the latest task boundary: a task
+ * starting in this session, or this session's task ending. So one long
+ * session no longer carries every past task into every call; the task in
+ * hand reaches the oracle through bot-lobby's system prompt section and its
+ * task folder, which do not depend on the conversation.
+ *
+ * A boundary is a custom entry in the session file, which is never sent to
+ * the model: it survives /resume and belongs to the branch it was made on.
+ * Subagents (scouts, workers, reviewers, the planning panel, quick fixes)
+ * already run as pi processes of their own, each with its own context, and
+ * are not touched here.
+ */
+import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
+import { relative } from "node:path";
+import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
+import { peekTasks, taskDirFor } from "../state/persistence.ts";
+import { detectProjectRoot, loadConfig } from "../state/project.ts";
+import { CLEARED_NOTE, CONTEXT_MARK, lobbyFeed } from "../lobby/feed.ts";
+import { isSubagentProcess } from "./quiet.ts";
+
+export { CLEARED_NOTE, CONTEXT_MARK };
+
+export interface ContextMark {
+  kind: "start" | "end";
+  taskId: string;
+  /** Messages from this time on (ms) are what the model is sent. */
+  at: number;
+}
+
+/** The boundaries on a session branch, oldest first. */
+export function contextMarks(entries: readonly unknown[]): ContextMark[] {
+  const marks: ContextMark[] = [];
+  for (const entry of entries) {
+    const mark = asMark(entry);
+    if (mark) marks.push(mark);
+  }
+  return marks;
+}
+
+/** A session entry as a boundary, when it is one. */
+export function asMark(entry: unknown): ContextMark | undefined {
+  const record = entry as { type?: string; customType?: string; data?: Partial<ContextMark> } | undefined;
+  if (record?.type !== "custom" || record.customType !== CONTEXT_MARK) return undefined;
+  const data = record.data;
+  if (!data || typeof data.at !== "number" || typeof data.taskId !== "string" || (data.kind !== "start" && data.kind !== "end")) return undefined;
+  return { kind: data.kind, taskId: data.taskId, at: data.at };
+}
+
+/** Replies and tool results answer what came before them, so what the model is sent never opens with one. */
+const ANSWERS = new Set(["assistant", "toolResult"]);
+
+/**
+ * The messages from the boundary on: from the first one at or after it that
+ * can open a conversation (a request, a summary, an extension's message).
+ * All of them when nothing has come since the boundary (a task that ended
+ * mid-run still gets its closing turn).
+ */
+export function fromBoundary<T extends { role: string; timestamp?: number }>(messages: T[], boundary: number | undefined): T[] {
+  if (boundary === undefined) return messages;
+  const start = messages.findIndex((message) => typeof message.timestamp === "number" && message.timestamp >= boundary && !ANSWERS.has(message.role));
+  return start <= 0 ? messages : messages.slice(start);
+}
+
+/** Whether the oracle starts clean at each task (`workflow.freshContext`, on by default). */
+export function freshContextOn(): boolean {
+  return loadConfig().workflow.freshContext;
+}
+
+/** Record a boundary in this session. */
+export function markContext(pi: ExtensionAPI, mark: ContextMark): void {
+  pi.appendEntry<ContextMark>(CONTEXT_MARK, mark);
+  if (mark.kind === "end") lobbyFeed.say("note", CLEARED_NOTE, mark.at);
+}
+
+/** The session's newest task: the one its conversation was last about. */
+function lastTask(ctx: ExtensionContext, configDir: string): Task | undefined {
+  const sessionId = ctx.sessionManager.getSessionId();
+  return peekTasks(detectProjectRoot(ctx.cwd, configDir), configDir).find((task) => task.ownerSessionId === sessionId);
+}
+
+/** Close the session's task once it has ended (completed or abandoned): the next request starts clean. */
+export function closeEndedTask(pi: ExtensionAPI, ctx: ExtensionContext, configDir: string, now = Date.now()): boolean {
+  if (isSubagentProcess() || !freshContextOn()) return false;
+  const task = lastTask(ctx, configDir);
+  if (!task || !TERMINAL_STATES.includes(task.state)) return false;
+  if (contextMarks(ctx.sessionManager.getBranch()).some((mark) => mark.kind === "end" && mark.taskId === task.id)) return false;
+  markContext(pi, { kind: "end", taskId: task.id, at: now });
+  return true;
+}
+
+/**
+ * The note bot-lobby's system prompt section carries after a task ended and
+ * cleared the context: which task it was and where its record is, for when
+ * the user refers back to it.
+ */
+export function previousTaskNote(ctx: ExtensionContext, configDir: string): string | undefined {
+  if (!freshContextOn()) return undefined;
+  const last = contextMarks(ctx.sessionManager.getBranch()).at(-1);
+  if (last?.kind !== "end") return undefined;
+  const root = detectProjectRoot(ctx.cwd, configDir);
+  const task = peekTasks(root, configDir).find((entry) => entry.id === last.taskId);
+  if (!task) return undefined;
+  const record = relative(ctx.cwd, taskDirFor(root, configDir, task.id)) || ".";
+  return [
+    `Your previous task, ${task.id} "${task.title}", ended (${task.state}). Its conversation was cleared from your context so the next piece of work starts fresh.`,
+    `Its record (request, proposal, plan, decisions, runs) is in ${record}/. Read it only if the user refers back to that task.`,
+  ].join("\n");
+}
+
+/** Trim what the oracle is sent to its latest boundary, and close tasks as they end. */
+export function registerFreshContext(pi: ExtensionAPI, configDir: string): void {
+  if (isSubagentProcess()) return;
+  pi.on("context", (event, ctx) => {
+    if (!freshContextOn()) return undefined;
+    const boundary = contextMarks(ctx.sessionManager.getBranch()).at(-1)?.at;
+    const messages = fromBoundary(event.messages, boundary);
+    return messages.length === event.messages.length ? undefined : { messages };
+  });
+  // A task's last turn is over: whatever is asked next starts clean.
+  pi.on("agent_end", (_event, ctx) => void closeEndedTask(pi, ctx, configDir));
+  // It may have ended while the oracle was idle (abandoned or archived from the lobby, finished in another window).
+  pi.on("before_agent_start", (_event, ctx) => void closeEndedTask(pi, ctx, configDir));
+  // Compacting a conversation the next request drops anyway would only cost a model call.
+  pi.on("session_before_compact", (event) => {
+    if (event.reason === "manual" || !freshContextOn()) return undefined;
+    const last = contextMarks(event.branchEntries).at(-1);
+    if (!last) return undefined;
+    const since = event.branchEntries.some((entry) => entry.type === "message" && Date.parse(entry.timestamp) >= last.at);
+    return since ? undefined : { cancel: true };
+  });
+}

package/src/pi/owner.ts

@@ -10,7 +10,7 @@
 import type { KeyId } from "@earendil-works/pi-tui";
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
-import { activeTask, loadTask } from "../state/persistence.ts";
+import { peekOwnedTask } from "../state/persistence.ts";
 import { detectProjectRoot, loadConfig } from "../state/project.ts";
 import { commentMessage, markCommentsDelivered, readPlanComments, undeliveredComments } from "../state/comments.ts";
 import { inboxMessage, markInboxDelivered, markSessionInboxDelivered, readInbox, readSessionInbox } from "../state/inbox.ts";
@@ -42,6 +42,8 @@ interface Owner {
   configDir: string;
   timer?: ReturnType<typeof setInterval>;
   auto?: AutoTrack;
+  /** The session's task as this tick read it: one read serves the whole tick. */
+  tick?: { task: Task | undefined };
 }
 
 let owner: Owner | undefined;
@@ -53,7 +55,8 @@ export function onOwnerEvent(fn: ((event: OwnerEvent) => void) | undefined): voi
 }
 
 function ownTask(state: Owner): Task | undefined {
-  return activeTask(state.root, state.configDir, state.ctx.sessionManager.getSessionId());
+  if (state.tick) return state.tick.task;
+  return peekOwnedTask(state.root, state.configDir, state.ctx.sessionManager.getSessionId());
 }
 
 function live(task: Task | undefined): task is Task {
@@ -68,8 +71,7 @@ export function deliverComments(): number {
   if (!live(task) || task.paused) return 0;
   const fresh = undeliveredComments(readPlanComments(state.root, state.configDir, task.id));
   if (fresh.length === 0) return 0;
-  const current = loadTask(state.root, state.configDir, task.id) ?? task;
-  state.pi.sendUserMessage(commentMessage(task.id, fresh, Boolean(current.plan)), state.ctx.isIdle() ? undefined : { deliverAs: "steer" });
+  state.pi.sendUserMessage(commentMessage(task.id, fresh, Boolean(task.plan)), state.ctx.isIdle() ? undefined : { deliverAs: "steer" });
   markCommentsDelivered(state.root, state.configDir, task.id, fresh.map((comment) => comment.id));
   listener?.({ kind: "comments", taskId: task.id, count: fresh.length });
   return fresh.length;
@@ -211,11 +213,18 @@ export function toggleOwnAuto(): string {
 
 /** One tick of the owner's clock. */
 export function ownerTick(): void {
-  heartbeat();
-  deliverComments();
-  deliverInbox();
-  deliverSessionInbox();
-  driveAuto();
+  const state = owner;
+  if (!state) return;
+  state.tick = { task: ownTask(state) };
+  try {
+    heartbeat();
+    deliverComments();
+    deliverInbox();
+    deliverSessionInbox();
+    driveAuto();
+  } finally {
+    state.tick = undefined;
+  }
 }
 
 function stop(): void {
@@ -254,7 +263,7 @@ export function registerOwner(pi: ExtensionAPI, configDir: string): void {
   // Auto mode has nobody to answer a question: tell the oracle to decide instead.
   pi.on("tool_call", (event, ctx) => {
     if (event.toolName !== "ask_user_question" || !owner) return undefined;
-    const task = activeTask(owner.root, owner.configDir, ctx.sessionManager.getSessionId());
+    const task = peekOwnedTask(owner.root, owner.configDir, ctx.sessionManager.getSessionId());
     if (!live(task) || !isAutoMode(owner.root, owner.configDir, task.id)) return undefined;
     return { block: true, reason: `Auto mode is on for ${task.id}: nobody will answer. Decide this yourself from the request, the plan and your reconnaissance, record the decision, and continue.` };
   });

package/src/pi/start-task.ts

@@ -15,6 +15,7 @@ import { applyMasterModel } from "./settings-ui.ts";
 import { setAutoMode } from "../state/auto.ts";
 import { loadPlannedTask, markPlannedTaskStarted, plannedTaskRequest } from "../state/backlog.ts";
 import { triageFor } from "../classifier/instance.ts";
+import { freshContextOn, markContext } from "./fresh-context.ts";
 
 function uniqueTaskId(root: string, configDir: string, request: string): string {
   const base = nextTaskId(request);
@@ -76,6 +77,8 @@ export async function startTask(pi: ExtensionAPI, ctx: ExtensionContext, configD
   applyStatus(ctx, root, configDir);
   await applyMasterModel(pi, ctx, loadConfig());
   ctx.ui.notify(`bot-lobby ${task.id} started`, "info");
+  // The oracle takes the task on with a clean context: nothing said before the kickoff is sent to its model.
+  if (freshContextOn()) markContext(pi, { kind: "start", taskId: task.id, at: Date.now() });
   // A kickoff while pi is still busy (another turn) queues behind it instead of throwing.
   pi.sendUserMessage(kickoff(task), ctx.isIdle() ? undefined : { deliverAs: "followUp" });
   return task;

package/src/pi/ui.ts

@@ -1,5 +1,6 @@
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
-import { Key, truncateToWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import { Key, type Component, type TUI } from "@earendil-works/pi-tui";
+import { clip } from "../width.ts";
 import type { AgentRun } from "../schemas/findings.ts";
 import { TERMINAL_STATES, type Task } from "../schemas/task.ts";
 import { activeTask } from "../state/persistence.ts";
@@ -255,7 +256,7 @@ export class ZenScene {
     const key = `${width}|${rows}|${this.tick}|${frameKey}|${motion.phase}|${motion.talk}|${zenVersion}|${Math.floor(now / 1000)}|${quiet}|${still}`;
     if (this.cache && this.cache.key === key && this.cache.theme === theme) return this.cache.lines;
     const opts = { width, rows, tick: this.tick, theme, expressions, variants, oracleActivity, oracleMotion: motion, still };
-    const lines = panelLines(zenState.task, zenState.runs, now, quiet, opts).map((line) => truncateToWidth(line, width));
+    const lines = panelLines(zenState.task, zenState.runs, now, quiet, opts).map((line) => clip(line, width));
     this.cache = { key, theme, lines };
     return lines;
   }

package/src/pi/zen-large.ts

@@ -1,4 +1,4 @@
-import { truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { clip, textWidth } from "../width.ts";
 import {
   BAR,
   BUBBLE,
@@ -243,11 +243,11 @@ function labelPaint(status: SlotState, theme?: PanelTheme): ((text: string) => s
 }
 
 function padTo(text: string, width: number): string {
-  return truncateToWidth(text, width, "", true);
+  return clip(text, width, "", true);
 }
 
 function centre(text: string, width: number): string {
-  return padTo(" ".repeat(Math.max(0, Math.floor((width - visibleWidth(text)) / 2))) + text, width);
+  return padTo(" ".repeat(Math.max(0, Math.floor((width - textWidth(text)) / 2))) + text, width);
 }
 
 function mod(index: number, length: number): number {
@@ -273,7 +273,7 @@ function sceneCentre(width: number): number {
 
 /** Place a row of at most `SCENE_WIDTH` columns on the scene's centre column. */
 function place(row: string, width: number): string {
-  return " ".repeat(Math.max(0, sceneLeft(width) + Math.floor((SCENE_WIDTH - visibleWidth(row)) / 2))) + row;
+  return " ".repeat(Math.max(0, sceneLeft(width) + Math.floor((SCENE_WIDTH - textWidth(row)) / 2))) + row;
 }
 
 function alertLine(
@@ -283,7 +283,7 @@ function alertLine(
   kind: "warning" | "error" = "warning",
 ): string {
   const left = sceneLeft(width);
-  const line = paint(truncateToWidth(`! ${alert}`, width - left, "…"), kind, theme, true);
+  const line = paint(clip(`! ${alert}`, width - left, "…"), kind, theme, true);
   return " ".repeat(left) + line;
 }
 
@@ -294,8 +294,8 @@ function boxLines(input: LargeSceneInput, width: number, theme?: PanelTheme): st
 
 function topBorder(input: LargeSceneInput, theme?: PanelTheme): string {
   const lead = "┌─ BOT-LOBBY ── ";
-  const label = truncateToWidth(`${input.taskTitle} · ${input.state} `, SCENE_WIDTH - 18, "…");
-  const tail = "─".repeat(Math.max(0, SCENE_WIDTH - 1 - visibleWidth(lead) - visibleWidth(label)));
+  const label = clip(`${input.taskTitle} · ${input.state} `, SCENE_WIDTH - 18, "…");
+  const tail = "─".repeat(Math.max(0, SCENE_WIDTH - 1 - textWidth(lead) - textWidth(label)));
   return paint(lead, "muted", theme) + paint(label, "accent", theme, true) + paint(`${tail}┐`, "muted", theme);
 }
 
@@ -349,7 +349,7 @@ function bodyLines(
 /** One dim line under the agent strip; warnings take the warning colour. */
 function feedRow(feed: FeedLine, width: number, theme?: PanelTheme): string {
   const left = sceneLeft(width) + 1;
-  const text = truncateToWidth(feed.text, Math.max(0, Math.min(SCENE_WIDTH - 2, width - left)), "…");
+  const text = clip(feed.text, Math.max(0, Math.min(SCENE_WIDTH - 2, width - left)), "…");
   return " ".repeat(left) + (feed.kind === "warning" ? paint(text, "warning", theme) : paint(text, "dim", theme));
 }
 
@@ -494,7 +494,7 @@ export function oracleAside(input: LargeSceneInput): string {
 function bubbleRows(input: LargeSceneInput, theme?: PanelTheme): string[] {
   const accent = ORACLE_COLORS[input.oracle.pose];
   const border = (text: string) => paint(text, "muted", theme);
-  const text = (value: string) => padTo(truncateToWidth(value, BUBBLE_TEXT, "…"), BUBBLE_TEXT);
+  const text = (value: string) => padTo(clip(value, BUBBLE_TEXT, "…"), BUBBLE_TEXT);
   const rule = "─".repeat(BUBBLE.width - 2);
   return [
     border(`╭${rule}╮`),
@@ -661,7 +661,7 @@ function assemble(end: number, cells: readonly Cell[]): string {
   let cursor = 0;
   for (const cell of cells) {
     row += " ".repeat(Math.max(0, cell.offset - cursor)) + (cell.paint ? cell.paint(cell.text) : cell.text);
-    cursor = cell.offset + visibleWidth(cell.text);
+    cursor = cell.offset + textWidth(cell.text);
   }
   return row + " ".repeat(Math.max(0, end - cursor));
 }