pi-jar 0.1.9 → 0.2.1

package/src/settings.ts

@@ -23,6 +23,8 @@ export interface JarVisualSettings {
   advisor: boolean;
   /** Consult the advisor automatically when the agent repeats a tool call or keeps failing. */
   advisorGates: boolean;
+  /** Opt-in provider-context pruning of reasoning from completed earlier user turns. */
+  contextDiet: boolean;
   /** Glyph set for footer, composer and views: unicode, Nerd Font icons, or plain ascii. */
   icons: IconSet;
   footer: FooterSettings;
@@ -37,7 +39,7 @@ export function isMaxSubagents(value: unknown): value is MaxSubagents {
 
 export const SETTINGS_FILE = "pi-jar-settings.json";
 export function defaultVisualSettings(footer: FooterSettings = DEFAULT_FOOTER_SETTINGS): JarVisualSettings {
-  return { version: 1, accent: "follow", animations: true, ui: true, composer: true, mascot: true, suggestions: true, goalRounds: 8, maxSubagents: 4, advisor: true, advisorGates: true, icons: "unicode", footer: { ...footer } };
+  return { version: 1, accent: "follow", animations: true, ui: true, composer: true, mascot: true, suggestions: true, goalRounds: 8, maxSubagents: 4, advisor: true, advisorGates: true, contextDiet: false, icons: "unicode", footer: { ...footer } };
 }
 
 /** Legacy footer choices are imported only while the new file is absent. Never modify the old file. */
@@ -70,6 +72,7 @@ export function loadVisualSettings(directory: string): JarVisualSettings {
     maxSubagents: isMaxSubagents(value.maxSubagents) ? value.maxSubagents : fallback.maxSubagents,
     advisor: typeof value.advisor === "boolean" ? value.advisor : fallback.advisor,
     advisorGates: typeof value.advisorGates === "boolean" ? value.advisorGates : fallback.advisorGates,
+    contextDiet: typeof value.contextDiet === "boolean" ? value.contextDiet : fallback.contextDiet,
     icons: ICON_SETS.some((set) => set === value.icons) ? value.icons as IconSet : fallback.icons,
     footer: Object.fromEntries(FOOTER_FIELDS.map((field) => [field,
       typeof footer[field] === "boolean" ? footer[field] : fallback.footer[field]])) as FooterSettings

package/src/shell-notifications.ts

@@ -1,4 +1,4 @@
-import type { ExtensionAPI, CustomMessageEntryDraft } from "@earendil-works/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext, CustomMessageEntryDraft } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { cleanText } from "./status.ts";
 import { describe, SHELL_MESSAGE, type ShellEvent, type ShellManager } from "./shells.ts";
@@ -34,14 +34,40 @@ export function registerShellNotifications(pi: ExtensionAPI, manager: () => Shel
   let interrupted = false;
   let deliveryFailures = 0;
   let timer: ReturnType<typeof setTimeout> | undefined;
+  let feedbackTimer: ReturnType<typeof setTimeout> | undefined;
+  let context: ExtensionContext | undefined;
+  const shown = new Set<string>();
+  const eventKey = (event: ShellEvent) => `${event.kind}:${event.job.id}`;
   const warned = new Set<string>();
-  const cancelTimer = () => { clearTimeout(timer); timer = undefined; };
+  const cancelTimer = () => { clearTimeout(timer); timer = undefined; clearTimeout(feedbackTimer); feedbackTimer = undefined; };
   const take = () => {
     cancelTimer();
     const events = manager()?.takeNotifications() ?? [];
+    shown.clear();
     return events.length ? shellNotification(events) : undefined;
   };
   const notify = () => {
+    // UI feedback must not wait for the remote model to finish reasoning. Keep model transport
+    // boundary-safe and acknowledgeable: this preview does not consume or enqueue a follow-up.
+    if (active && !interrupted && context?.hasUI && !feedbackTimer && manager()?.pendingNotifications()) {
+      const owner = manager(), ctx = context;
+      feedbackTimer = setTimeout(() => {
+        feedbackTimer = undefined;
+        if (!active || interrupted || owner !== manager() || ctx !== context) return;
+        const snapshot = owner?.notificationSnapshot() ?? [];
+        const known = new Set(snapshot.map(eventKey));
+        for (const key of shown) if (!known.has(key)) shown.delete(key);
+        const events = snapshot.filter(event => !shown.has(eventKey(event)));
+        if (!events.length) return;
+        const summary = shellNotification(events).details as ShellNotificationDetails;
+        const text = `${summary.summary}: ${events.slice(0, 3).map(event => describe(event.job)).join("; ")}. Model delivery waits for a safe turn boundary.`;
+        try {
+          ctx.ui.notify(cleanText(text, 420), events.some(event => event.job.exitCode !== 0 && event.kind === "exit") ? "warning" : "info");
+          for (const event of events) shown.add(eventKey(event));
+        } catch (error) { console.error("pi-jar: could not show shell completion", error); }
+      }, 300);
+      feedbackTimer.unref?.();
+    }
     if (active || interrupted || timer || !manager()?.pendingNotifications()) return;
     const owner = manager();
     timer = setTimeout(() => {
@@ -59,16 +85,17 @@ export function registerShellNotifications(pi: ExtensionAPI, manager: () => Shel
     }, 300);
     timer.unref?.();
   };
-  const reset = () => { cancelTimer(); active = false; interrupted = false; deliveryFailures = 0; warned.clear(); };
+  const reset = () => { cancelTimer(); active = false; interrupted = false; context = undefined; deliveryFailures = 0; warned.clear(); shown.clear(); };
 
   pi.registerMessageRenderer?.<ShellNotificationDetails>(SHELL_MESSAGE, (message, { expanded }, theme) => {
     const text = typeof message.content === "string" ? message.content : "Background shells";
     const summary = message.details?.summary ?? text.split("\n", 1)[0] ?? "Background shells";
     return new Text(expanded ? text : theme.fg("accent", cleanText(summary, 160)) + theme.fg("dim", " · expand for status"), 0, 0);
   });
-  pi.on?.("session_start", reset);
+  pi.on?.("session_start", (_event, ctx) => { reset(); context = ctx; });
   pi.on?.("session_shutdown", reset);
-  pi.on?.("before_agent_start", () => {
+  pi.on?.("before_agent_start", (_event, ctx) => {
+    context = ctx;
     active = true;
     interrupted = false;
     const entry = take();
@@ -76,7 +103,7 @@ export function registerShellNotifications(pi: ExtensionAPI, manager: () => Shel
     const { type: _type, ...message } = entry;
     return { message };
   });
-  pi.on?.("agent_start", () => { active = true; cancelTimer(); });
+  pi.on?.("agent_start", (_event, ctx) => { context = ctx; active = true; cancelTimer(); });
   pi.on?.("turn_end", event => {
     if (event.outcome !== "completed" || event.context?.canContinue === false) return;
     const entry = take();

package/src/shells.ts

@@ -125,6 +125,8 @@ export class ShellManager {
     for (const event of events) if (this.jobs.has(event.job.id) && !this.pending.has(event.job.id)) this.pending.set(event.job.id, event);
   }
   pendingNotifications(): number { return this.pending.size; }
+  /** Non-consuming status snapshots for immediate UI feedback; never copy or expose log lines. */
+  notificationSnapshot(): ShellEvent[] { return [...this.pending.values()].map(event => ({ ...event, job: { ...event.job, lines: [] } })); }
   verificationPending(): Array<Omit<ShellJob, "lines">> {
     return [...this.jobs.values()].filter(entry => !entry.finished && entry.job.purpose !== "service").map(({ job }) => {
       const { lines: _lines, ...summary } = job;
@@ -438,6 +440,7 @@ export function registerShells(pi: ExtensionAPI, shells: () => ShellManager | un
     promptGuidelines: [
       "Use jar_shell start for servers, watchers and slow commands; set watch to a regex for the line you are waiting for (e.g. \"listening|ready|error\").",
       "Do not poll: work while commands run, then use wait with explicit ids for relevant checks before the final summary. A bounded wait returns pending jobs honestly; never claim success without their exit codes. Do not wait for services/watchers. output, peek, list and wait acknowledge observed events, preventing stale replay.",
+      "Completion events cannot interrupt an in-flight model response. If no useful work remains, call wait for the relevant finite jobs immediately instead of thinking or waiting for an automatic wake-up.",
       "Notifications contain coalesced status, not log dumps. Inspect output only for relevant diagnostics. Mark never-ending jobs purpose: service and kill shells you no longer need."
     ],
     parameters: Parameters,
@@ -453,7 +456,7 @@ export function registerShells(pi: ExtensionAPI, shells: () => ShellManager | un
           case "start": {
             const job = manager.start({ command: params.command ?? "", cwd: ctx.cwd, ...(params.name ? { name: params.name } : {}), ...(params.watch ? { watch: params.watch } : {}),
               ...(params.notify !== undefined ? { notify: params.notify } : {}), ...(params.purpose ? { purpose: params.purpose } : {}) });
-            return reply(`Started ${describe(job)} (pid ${job.pid ?? "?"}). ${job.notify ? "You will be woken when it " + (job.watch ? "matches or " : "") + "exits." : "Notifications are off; check it with output."}`);
+            return reply(`Started ${describe(job)} (pid ${job.pid ?? "?"}). ${job.notify ? "Completion reaches the model at the next safe turn boundary (or wakes it when idle). If no other useful work remains, use wait now." : "Notifications are off; check it with output."}`);
           }
           case "output": {
             if (!params.id) return reply("output needs an id.");

package/src/side-model.ts

@@ -30,7 +30,7 @@ export interface SideAnswer { text: string; model: string }
  * Ask the model assigned to `role` (or the current model) a one-shot question outside the
  * conversation. Tries configured fallbacks in order on failure; cancellation never retries.
  */
-export async function askRole(ctx: ExtensionContext, roles: ModelRoleManager, usage: SideUsage | undefined, role: string,
+export async function askRole(ctx: ExtensionContext, roles: ModelRoleManager, usage: Pick<SideUsage, "add"> | undefined, role: string,
   systemPrompt: string, prompt: string, signal?: AbortSignal): Promise<SideAnswer> {
   const fallbacks = roles.fallbackSpecs?.(role) ?? [];
   const failures: string[] = [];
@@ -52,6 +52,8 @@ export async function askRole(ctx: ExtensionContext, roles: ModelRoleManager, us
       const result = await ctx.modelRegistry.streamSimple(model,
         { systemPrompt, messages: [{ role: "user", content: prompt, timestamp: Date.now() }] },
         { ...(reasoning ? { reasoning } : {}), ...(signal ? { signal } : {}) }).result();
+      // Callers with detached work can supply a session-generation-safe usage sink.
+      // Returned attempts (including cancelled attempts) still account for actual usage.
       const cost = result.usage?.cost?.total;
       usage?.add({ role, model: name, input: result.usage?.input ?? 0, output: result.usage?.output ?? 0, cacheRead: result.usage?.cacheRead ?? 0,
         cacheWrite: result.usage?.cacheWrite ?? 0, cost: Number.isFinite(cost) ? cost! : 0, at: Date.now() });

package/src/welcome.ts

@@ -1,4 +1,4 @@
-import { sliceByColumn, stripTerminalSequences, truncateToWidth, visibleWidth } from "@earendil-works/pi-tui";
+import { sliceByColumn, stripTerminalSequences, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@earendil-works/pi-tui";
 import { FLAME_RAMP, FLAME_WIDTH, flameFrame, rgb, supportsTruecolor } from "./flame.ts";
 import { cleanText } from "./status.ts";
 import { iconSet, withIcon } from "./icons.ts";
@@ -10,6 +10,8 @@ export interface WelcomeInfo {
   model?: string;
   effort?: string;
   activeRole?: string;
+  /** Active configuration profile, shown even before a session is named. */
+  profile?: string;
   project?: string;
   context?: string;
   cost?: string;
@@ -189,6 +191,8 @@ function card(width: number, fg: Paint, info: WelcomeInfo): string[] {
     cell(center(fg("dim", "— welcome to ") + fg("accent", "pi-jar") + fg("dim", " —"), inner)),
     cell(""),
     divider,
+    ...wrapTextWithAnsi(cleanText(info.profile ?? "Default", 32) || "Default", Math.max(1, inner - labelWidth))
+      .map((line, index) => cell(index ? fg("dim", " ".repeat(labelWidth)) + fg("accent", line) : label("PROFILE", line, "accent"))),
     cell(label("PROJECT", withIcon("folder", info.project || "unavailable") + " · " + git, info.dirty ? "warning" : "muted")),
     cell(label("SESSION", [info.context ?? "ctx ?", quota, info.cost ?? ""].filter(Boolean).join(" · "))),
     divider,
@@ -262,6 +266,7 @@ function renderWelcome(width: number, frame: number, fg: Paint, info: WelcomeInf
       ...flame.slice(4).map((line) => fit(sliceByColumn(line, start, Math.min(width, FLAME_WIDTH)))),
       ...PI_COMPACT.map((line) => fit(fg("accent", line))),
       fit(fg("accent", "pi-jar")),
+      fit(fg("accent", "Profile: " + (cleanText(info.profile ?? "Default", 32) || "Default"))),
       ...wrap(cleanText(info.message ?? HOPEFUL_WELCOME_MESSAGES[0], 100), width).map((line) => fit("\x1b[1m" + fg("warning", line) + "\x1b[22m")),
       fit(fg(info.settingsClickable === false ? "dim" : "accent", info.settingsClickable === false ? "ctrl+alt+s settings" : "[ ⚙ Settings ]")),
       ""