pi-jar 0.2.2 → 0.2.3

package/src/suggest.ts

@@ -2,6 +2,7 @@ import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
 import { cleanText } from "./status.ts";
+import { setToolActive } from "./tool-activation.ts";
 
 export const SUGGEST_TOOL = "jar_suggest";
 const MAX_SUGGESTION = 160;
@@ -31,12 +32,8 @@ export function registerSuggestions(pi: ExtensionAPI, state: SuggestionState, op
   pi.registerTool?.({
     name: SUGGEST_TOOL,
     label: "suggest",
-    description: "Optionally offer one useful next prompt as ghost text in the input box; Tab accepts it for editing.",
-    promptSnippet: "Optionally use jar_suggest at the end when one genuinely useful next prompt would help the user continue.",
-    promptGuidelines: [
-      "jar_suggest is best-effort, not mandatory. Use it only when there is one clear next action worth surfacing; skip it for routine completions.",
-      "When used, call it once as the final action with one imperative line under 120 characters. Do not mention jar_suggest in your reply."
-    ],
+    description: "Optionally offer one useful next prompt (one imperative line under 120 characters) as ghost text in the input box; Tab accepts it for editing. Call once as the final action; do not mention it in your reply.",
+    promptSnippet: "Optionally end with one jar_suggest call only when one clear next prompt is worth surfacing; skip it for routine completions.",
     parameters: Type.Object({ suggestion: Type.String({ description: "The user's likely next prompt, one line." }) }),
     execute: async (_id, params) => {
       const ok = state.set(params.suggestion ?? "");
@@ -50,11 +47,7 @@ export function registerSuggestions(pi: ExtensionAPI, state: SuggestionState, op
   });
 
   const sync = () => {
-    if (typeof pi.getActiveTools !== "function" || typeof pi.setActiveTools !== "function") return;
-    const active = pi.getActiveTools();
-    const has = active.includes(SUGGEST_TOOL);
-    if (options.enabled() && !has && pi.getAllTools().some((tool) => tool.name === SUGGEST_TOOL)) pi.setActiveTools([...active, SUGGEST_TOOL]);
-    else if (!options.enabled() && has) pi.setActiveTools(active.filter((name) => name !== SUGGEST_TOOL));
+    setToolActive(pi, SUGGEST_TOOL, options.enabled());
     if (!options.enabled()) state.clear();
   };
 

package/src/task-tool.ts

@@ -87,16 +87,10 @@ export function registerTaskTool(
   pi.registerTool({
     name: "jar_todo",
     label: "tasks",
-    description: "Maintain session tasks: write establishes a fresh complete task plan, update changes one existing task by stable id, append adds genuinely new work, and remove deletes one task tree. start/done/open/edit remain concise status operations. Stable IDs are returned for every task.",
-    promptSnippet: "Track multi-step work with jar_todo: write the task plan first, update/remove existing tasks by stable id, append only when new work arrives mid-run, and keep one leaf in_progress.",
+    description: "Maintain session tasks. write sets the complete current plan (omitted tasks are removed; each item has content, status, optional activeForm and one level of `subtasks`, whose completion completes the parent; progress counts leaves). update changes one task by stable id, append adds genuinely new work mid-run (not a new plan), remove deletes one task tree; start/done/open/edit are concise status operations. Stable IDs are returned for every task.",
+    promptSnippet: "Track work with 3+ steps or several requests in jar_todo (skip trivial requests and questions): write the complete plan for a new request, start fresh once the old list is completed.",
     promptGuidelines: [
-      "Use jar_todo proactively, without waiting for the user, for any task with three or more distinct steps, when the user gives several tasks, or right after receiving new instructions. Skip it for single trivial requests and pure questions.",
-      "Prefer write when establishing the task plan for a new request. If the existing checklist is fully completed, start the next request with a fresh write rather than appending onto old completed work.",
-      "Use update with a stable id to revise one existing task and remove to delete one task tree. Use append mainly when the user steers or adds genuinely new requirements while an active checklist is already in progress; do not use append as the default way to create a new plan.",
-      "write with todos is the complete current task plan and removes omitted tasks. Each item has content, status, and optional activeForm/subtasks.",
-      "Break a large task into `subtasks` (same shape, one level deep). A parent's status follows its subtasks: it is completed when all of them are. Progress counts leaf tasks (subtasks and tasks without subtasks).",
-      "Keep exactly one leaf task in_progress at a time. Mark a task in_progress before you start it and completed immediately after it is verified; do not batch completions.",
-      "Only mark a task completed when it is fully done. If tests fail, work is partial or you are blocked, keep it in_progress and add a task for what must be resolved. Remove tasks that are no longer relevant."
+      "Keep exactly one leaf in_progress; mark it completed right after verifying it. Never batch completions or complete partial, failing or blocked work: keep it open and add a task for the blocker."
     ],
     parameters: Parameters,
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {

package/src/tool-activation.ts

@@ -0,0 +1,14 @@
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+
+/**
+ * Activate or deactivate one registered tool. Inactive tools send neither their schema nor their
+ * prompt rules, so mode-specific tools are active only while their mode is. Pi applies a change
+ * made in before_agent_start to that run; toggling only at mode boundaries keeps the prompt stable.
+ */
+export function setToolActive(pi: ExtensionAPI, name: string, wanted: boolean): void {
+  if (typeof pi.getActiveTools !== "function" || typeof pi.setActiveTools !== "function") return;
+  const active = pi.getActiveTools();
+  const has = active.includes(name);
+  if (wanted && !has && pi.getAllTools().some((tool) => tool.name === name)) pi.setActiveTools([...active, name]);
+  else if (!wanted && has) pi.setActiveTools(active.filter((tool) => tool !== name));
+}

package/src/usage-view.ts

@@ -53,7 +53,7 @@ function resetText(window: QuotaWindow, now: number): string {
   return `Resets ${when} (in ${duration(Math.max(0, at - now))})`;
 }
 
-export interface UsageView { stats: UsageStats; provider?: string; quota?: Quota; quotaEnabled: boolean; now: number }
+export interface UsageView { stats: UsageStats; provider?: string; quota?: Quota; quotaFailure?: { error: string; retryInMs: number }; quotaEnabled: boolean; now: number }
 
 /** Claude-style usage page: session totals, per-model breakdown, then plan limit bars. */
 export function usageLines(view: UsageView, width: number, fg: Paint): string[] {
@@ -79,9 +79,13 @@ export function usageLines(view: UsageView, width: number, fg: Paint): string[]
   lines.push("", heading(`Plan usage limits${view.provider ? " · " + view.provider : ""}`));
   const windows: [string, QuotaWindow | undefined][] = [["Current session (5h)", view.quota?.fiveHour], ["Current week", view.quota?.week]];
   if (!windows.some(([, window]) => window)) {
-    lines.push(fg("dim", view.provider === "anthropic" || view.provider === "openai-codex"
-      ? view.quotaEnabled ? "  Loading limits… reopen in a moment." : "  Limit lookup is off; enable it with /jar quota on."
-      : "  Plan limits are available for anthropic and openai-codex subscriptions."));
+    const supported = view.provider === "anthropic" || view.provider === "openai-codex";
+    const failure = view.quotaFailure;
+    lines.push(fg(supported && view.quotaEnabled && failure ? "warning" : "dim", !supported
+      ? "  Plan limits are available for anthropic and openai-codex subscriptions."
+      : !view.quotaEnabled ? "  Limit lookup is off; enable it with /jar quota on."
+      : failure ? `  Limits unavailable: ${failure.error}. Retrying in ${duration(failure.retryInMs)}.`
+      : "  Loading limits…"));
     return lines;
   }
   for (const [label, window] of windows) {

package/src/usage.ts

@@ -12,6 +12,8 @@ export function sessionCost(ctx: Pick<ExtensionContext, "sessionManager">): numb
   return total;
 }
 
-export function formatCost(value: number): string {
-  return `cost $${value < 0.01 && value > 0 ? value.toFixed(4) : value.toFixed(2)}`;
+/** `cost $1.23`, plus the recent average per provider call when there is one: `cost $1.23 · $0.04/call`. */
+export function formatCost(value: number, perCall?: number): string {
+  const money = (amount: number) => `$${amount < 0.01 && amount > 0 ? amount.toFixed(4) : amount.toFixed(2)}`;
+  return `cost ${money(value)}` + (perCall !== undefined && perCall > 0 ? ` · ${money(perCall)}/call` : "");
 }