perchai-cli 2.4.45 → 2.4.46

package/dist/perch.mjs

@@ -75566,7 +75566,6 @@ var init_payroll = __esm({
 // lib/perchBusinessTools/index.ts
 var init_perchBusinessTools = __esm({
   "lib/perchBusinessTools/index.ts"() {
-    "use strict";
     init_generateAPAuditPacket();
     init_inventoryFolder();
     init_loadBusinessTables();
@@ -75918,7 +75917,6 @@ function isTurnAbortedError(error) {
 var TURN_STOPPED_BY_USER_MESSAGE;
 var init_turnAbort = __esm({
   "features/perchTerminal/runtime/turnAbort.ts"() {
-    "use strict";
     TURN_STOPPED_BY_USER_MESSAGE = "Turn stopped by user.";
   }
 });
@@ -76224,7 +76222,6 @@ function getToolDisplayName(toolName) {
 var NON_MODULE_TOOL_OWNERS, TOOL_RISK, TOOL_DISPLAY_NAMES;
 var init_catalog = __esm({
   "features/perchTerminal/runtime/toolSystem/catalog.ts"() {
-    "use strict";
     init_toolNames();
     NON_MODULE_TOOL_OWNERS = {
       [TOOL_NAMES.listSources]: "lane",
@@ -86739,6 +86736,7 @@ function truncateHistoryLine(value, max2) {
 }
 var init_operatorTruth = __esm({
   "features/perchTerminal/runtime/operatorTruth.ts"() {
+    "use strict";
   }
 });
 
@@ -93085,7 +93083,7 @@ var init_agentSkillRegistry = __esm({
         "name": "wait-operator",
         "description": "Watch bounded external or local conditions, poll deployment and job status, wait through short-running tasks, and resume with verified state instead of guessing.",
         "path": "features/perchTerminal/agentPlatform/skills/wait-operator/SKILL.md",
-        "body": "\n# wait-operator\n\nUse this skill when the user asks Perch to wait, watch, poll, monitor, check back, or keep an eye on a deployment, CI run, background job, file creation, local server, browser page, or other condition.\n\n## Operating Rules\n\n- Treat waiting as an active bounded loop: define the condition, timeout, interval, and failure states before polling.\n- Never sleep indefinitely. Use short intervals and a clear maximum wait unless the user explicitly asks for a longer watch.\n- Prefer read-only checks: status commands, existing logs, HTTP status endpoints, browser observe/wait, or file existence checks.\n- For deployments and CI, distinguish pending, ready/success, failed, canceled, timed out, and unknown. Do not call a run ready from elapsed time alone.\n- Report the last observed state if the wait times out or credentials/session state blocks verification.\n- Avoid noisy transcript spam. Group repeated polling into a short progress summary unless the user asks to see every check.\n- If the user asks for a real follow-up after this turn rather than an in-turn wait, create or suggest the appropriate automation instead of pretending the current turn can run forever.\n\n## Verification\n\nFinish only after the watched condition is directly verified or a blocker is named. Include the evidence source: command status, page state, URL, log line, file path, or timestamped last check.",
+        "body": "\n# wait-operator\n\nUse this skill when the user asks Perch to wait, watch, poll, monitor, check back, or keep an eye on a deployment, CI run, background job, file creation, local server, browser page, or other condition.\n\n## Operating Rules\n\n- **Background tasks (run_in_background):** after backgrounding a long-running command, call wait_for_background_task(taskId) to end your turn and be automatically woken with the result. NEVER busy-poll check_background_task in a loop \u2014 that wastes iterations and never triggers the wake path. One check is fine for a specific reason (e.g. reporting current progress on user request); repeated polling is always wrong.\n- Treat waiting as an active bounded loop: define the condition, timeout, interval, and failure states before polling.\n- Never sleep indefinitely. Use short intervals and a clear maximum wait unless the user explicitly asks for a longer watch.\n- Prefer read-only checks: status commands, existing logs, HTTP status endpoints, browser observe/wait, or file existence checks.\n- For deployments and CI, distinguish pending, ready/success, failed, canceled, timed out, and unknown. Do not call a run ready from elapsed time alone.\n- Report the last observed state if the wait times out or credentials/session state blocks verification.\n- Avoid noisy transcript spam. Group repeated polling into a short progress summary unless the user asks to see every check.\n- If the user asks for a real follow-up after this turn rather than an in-turn wait, create or suggest the appropriate automation instead of pretending the current turn can run forever.\n\n## Verification\n\nFinish only after the watched condition is directly verified or a blocker is named. Include the evidence source: command status, page state, URL, log line, file path, or timestamped last check.",
         "surface": {
           "gui": "supported",
           "cli": "supported"
@@ -135384,7 +135382,7 @@ function getDesktopToolDefinitions() {
       type: "function",
       function: {
         name: TOOL_NAMES.runInBackground,
-        description: "Launch a long-running shell command in the background. Returns immediately with a taskId; the command keeps running detached. Use check_background_task to poll, or wait_for_background_task to be woken when it finishes. Permission mode gates execution.",
+        description: "Launch a long-running shell command in the background. Returns immediately with a taskId; the command keeps running detached. After launching, call wait_for_background_task(taskId) to end your turn and be automatically re-invoked when it finishes. Permission mode gates execution.",
         parameters: {
           type: "object",
           properties: {
@@ -135406,7 +135404,7 @@ function getDesktopToolDefinitions() {
       type: "function",
       function: {
         name: TOOL_NAMES.checkBackgroundTask,
-        description: "Check the status and recent output of a background task by taskId. Returns status (running/done/failed/killed/unknown), exit code, runtime, and an output preview.",
+        description: "One-off status check for a background task. Returns status, exit code, runtime, and output preview. Do NOT call this repeatedly to wait for completion \u2014 use wait_for_background_task instead.",
         parameters: {
           type: "object",
           properties: {
@@ -135448,7 +135446,7 @@ function getDesktopToolDefinitions() {
       type: "function",
       function: {
         name: TOOL_NAMES.waitForBackgroundTask,
-        description: "Ask to be woken when a background task finishes. This does NOT block: it registers a wake, and you should end your turn. The runtime will re-invoke you with a system-initiated turn carrying the task result once it completes. Auto-wake only fires in autonomous permission modes.",
+        description: "After launching long-running work, call this to end your turn and be automatically re-invoked when it finishes. This is how you wait \u2014 do NOT poll check_background_task in a loop. The runtime delivers a system-initiated turn with the result once the task completes. Auto-wake fires in autonomous permission modes (auto_review / take_the_wheel).",
         parameters: {
           type: "object",
           properties: {
@@ -197126,6 +197124,7 @@ function recordDispatchBatchResult(tasks, result2, ctx, opts = {}) {
 var lifecycleByRun, MAX_LIFECYCLE_RUNS;
 var init_workerLifecycle = __esm({
   "features/perchTerminal/runtime/workers/workerLifecycle.ts"() {
+    "use strict";
     init_workerManifest();
     lifecycleByRun = /* @__PURE__ */ new Map();
     MAX_LIFECYCLE_RUNS = 200;
@@ -212049,9 +212048,13 @@ var init_backgroundWake = __esm({
 // features/perchTerminal/runtime/toolSystem/tools/background/index.ts
 var background_exports = {};
 __export(background_exports, {
+  __resetPollTrackerForTests: () => __resetPollTrackerForTests,
   backgroundTools: () => backgroundTools
 });
-var UNAVAILABLE, runInBackgroundTool, checkBackgroundTaskTool, listBackgroundTasksTool, killBackgroundTaskTool, waitForBackgroundTaskTool, backgroundTools;
+function __resetPollTrackerForTests() {
+  pollTracker.clear();
+}
+var UNAVAILABLE, pollTracker, POLL_REDIRECT_THRESHOLD, runInBackgroundTool, checkBackgroundTaskTool, listBackgroundTasksTool, killBackgroundTaskTool, waitForBackgroundTaskTool, backgroundTools;
 var init_background = __esm({
   "features/perchTerminal/runtime/toolSystem/tools/background/index.ts"() {
     "use strict";
@@ -212060,6 +212063,8 @@ var init_background = __esm({
     init_backgroundWake();
     init_toolNames();
     UNAVAILABLE = "Background execution is unavailable on this surface. It requires the Perch CLI or Perch Desktop.";
+    pollTracker = /* @__PURE__ */ new Map();
+    POLL_REDIRECT_THRESHOLD = 2;
     runInBackgroundTool = {
       name: TOOL_NAMES.runInBackground,
       classification: { native: false },
@@ -212079,11 +212084,26 @@ var init_background = __esm({
     checkBackgroundTaskTool = {
       name: TOOL_NAMES.checkBackgroundTask,
       classification: { native: false },
-      handler: async (args) => {
+      handler: async (args, ctx) => {
         const taskId = String(args.taskId ?? "").trim();
         if (!taskId) return { ok: false, error: "taskId must be a non-empty string." };
         const snapshot = await checkBackgroundTask({ taskId });
         if (snapshot === null) return { ok: false, error: `No background task found for ${taskId}.` };
+        if (snapshot.status === "running") {
+          const key = taskId;
+          const count = (pollTracker.get(key) ?? 0) + 1;
+          pollTracker.set(key, count);
+          if (count >= POLL_REDIRECT_THRESHOLD) {
+            const mode = normalizePermissionMode(ctx.permissionMode);
+            const wakeAvailable = WAKE_ALLOWED_PERMISSION_MODES.has(mode);
+            return {
+              ok: true,
+              task: snapshot,
+              _pollRedirect: true,
+              note: wakeAvailable ? `Stop polling \u2014 call wait_for_background_task("${taskId}") to end this turn and be automatically woken on completion.` : `This task is still running. Auto-wake is unavailable in "${mode}" mode. Tell the user to switch to auto_review or take_the_wheel for auto-wake, or end this turn and check back later.`
+            };
+          }
+        }
         return { ok: true, task: snapshot };
       }
     };
@@ -231787,7 +231807,7 @@ function runBackgroundCommand2(input) {
   const shell = input.shell || process.env.SHELL || "/bin/zsh";
   let child;
   try {
-    child = spawn2(shell, ["-lc", command], {
+    child = spawn2(shell, ["-ilc", command], {
       cwd: input.cwd,
       env: process.env,
       stdio: ["ignore", "pipe", "pipe"],
@@ -233811,6 +233831,37 @@ var init_cliStandaloneOAuth = __esm({
   }
 });
 
+// lib/perchTerminal/statusLabels.ts
+function sectionLabel(sectionKey) {
+  if (STATUS_LABELS[sectionKey]) return STATUS_LABELS[sectionKey];
+  return sectionKey.replace(/_/g, " ").replace(/\b\w/g, (c) => c.toUpperCase());
+}
+var STATUS_LABELS;
+var init_statusLabels = __esm({
+  "lib/perchTerminal/statusLabels.ts"() {
+    STATUS_LABELS = {
+      not_found: "Not found",
+      not_initialized: "Not initialized",
+      sent_raw: "Included",
+      sent_compacted: "Summarized",
+      output_reserve: "Reserved for response",
+      excluded: "Excluded",
+      skipped: "Skipped",
+      reserved: "Reserved",
+      generated: "Generated",
+      error: "Error",
+      completed: "Completed",
+      failed: "Failed",
+      running: "Running",
+      pending: "Pending",
+      blocked: "Blocked",
+      in_progress: "In progress",
+      sent: "Sent",
+      compacted: "Summarized"
+    };
+  }
+});
+
 // features/perchTerminal/runtime/contextMeterDisplay.ts
 function positiveInt3(value) {
   if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) return null;
@@ -233870,13 +233921,182 @@ function resolveContextMeterDisplay(snapshot, activeModel) {
     hasWorkers
   };
 }
-var ADMITTED_ROW_STATUSES2;
+function displayCategoryOrder(key) {
+  if (key.startsWith("mcp_tools")) {
+    const idx2 = DISPLAY_CATEGORY_ORDER.indexOf("mcp_tools");
+    return idx2;
+  }
+  const idx = DISPLAY_CATEGORY_ORDER.indexOf(key);
+  return idx === -1 ? DISPLAY_CATEGORY_ORDER.length : idx;
+}
+function displayCategoryForLane(lane) {
+  if (lane.startsWith("mcp_tools")) {
+    return { key: lane, label: sectionLabel(lane) };
+  }
+  switch (lane) {
+    case "system":
+    case "system_prompt":
+    case "selected_model":
+      return { key: "system_prompt", label: "System prompt" };
+    case "tools":
+    case "tool_definitions":
+    case "system_tools":
+      return { key: "system_tools", label: "System tools" };
+    case "mcp_tools":
+      return { key: "mcp_tools", label: "MCP tools" };
+    case "skills":
+    case "agent_skills":
+      return { key: "skills", label: "Skills" };
+    case "output_response":
+      return { key: "output_response", label: "Output response" };
+    case "output_reserve":
+    case "reserved_output":
+      return { key: "reserved_output", label: "Reserved output" };
+    case "deferred":
+      return { key: "deferred", label: "Deferred" };
+    case "messages":
+    case "conversation":
+    case "summarized_conversation":
+      return { key: "conversation", label: "Conversation" };
+    case "tool_transcript":
+      return { key: "tool_transcript", label: "Tool transcript" };
+    case "project_memory":
+    case "permanent_memory":
+    case "rules_project_memory":
+    case "durable_memory":
+      return { key: "memory_rules", label: "Memory & rules" };
+    case "tool_evidence":
+    case "thread_evidence":
+    case "retrieved_evidence":
+    case "files":
+    case "selected_source":
+      return { key: "evidence", label: "Evidence" };
+    case "workers":
+      return { key: "workers", label: "Workers" };
+    case "desktop":
+    case "workspace_context":
+      return { key: "workspace_context", label: "Workspace context" };
+    case "wire_overhead":
+      return { key: "overhead", label: "Overhead" };
+    default:
+      return { key: lane, label: sectionLabel(lane) };
+  }
+}
+function isCacheKey(key) {
+  return key.includes("cache");
+}
+function segmentsFromCategories(categories) {
+  return categories.filter((category) => category.tokens > 0 && !isCacheKey(category.key)).map((category) => ({
+    key: category.key,
+    label: category.label,
+    tokens: category.tokens
+  }));
+}
+function segmentsFromLaneTotals(laneTotals) {
+  return laneTotals.filter((lane) => lane.lane !== "output_reserve" && lane.tokens > 0 && !isCacheKey(lane.lane)).map((lane) => ({ key: lane.lane, label: sectionLabel(lane.lane), tokens: lane.tokens }));
+}
+function segmentsFromRows(rows) {
+  const byLane = /* @__PURE__ */ new Map();
+  for (const row of rows) {
+    if (row.lane === "output_reserve") continue;
+    if (isCacheKey(row.lane)) continue;
+    if (!ADMITTED_ROW_STATUSES2.has(row.status)) continue;
+    byLane.set(row.lane, (byLane.get(row.lane) ?? 0) + row.estimatedTokens);
+  }
+  return Array.from(byLane.entries()).filter(([, tokens]) => tokens > 0).map(([key, tokens]) => ({ key, label: sectionLabel(key), tokens }));
+}
+function segmentsFromBreakdown(breakdown) {
+  return Object.entries(breakdown).filter(([key, val]) => val.estimatedTokens > 0 && !isCacheKey(key)).map(([key, val]) => ({ key, label: sectionLabel(key), tokens: val.estimatedTokens }));
+}
+function groupDisplaySegments(segments) {
+  const grouped = /* @__PURE__ */ new Map();
+  for (const segment of segments) {
+    const display = displayCategoryForLane(segment.key);
+    const existing = grouped.get(display.key);
+    if (existing) {
+      existing.tokens += segment.tokens;
+    } else {
+      grouped.set(display.key, { key: display.key, label: display.label, tokens: segment.tokens });
+    }
+  }
+  return Array.from(grouped.values());
+}
+function buildContentSegments(snapshot) {
+  if (!snapshot) return [];
+  if (snapshot.contextCategories?.length) {
+    return segmentsFromCategories(snapshot.contextCategories);
+  }
+  const source = snapshot.laneTotals?.length ? segmentsFromLaneTotals(snapshot.laneTotals) : snapshot.rows ? segmentsFromRows(snapshot.rows) : segmentsFromBreakdown(snapshot.sectionBreakdown ?? {});
+  return groupDisplaySegments(source);
+}
+function resolveTruncationState(snapshot) {
+  if (snapshot?.truncated) return "truncated";
+  if (snapshot?.compacted) return "compacted";
+  return "none";
+}
+function buildContextComposition(snapshot, activeModel) {
+  const meter = resolveContextMeterDisplay(snapshot, activeModel);
+  const totalTokens = Math.max(1, meter.limitTokens);
+  const reservedOutputTokens = Math.max(0, meter.reservedOutputTokens);
+  const segments = buildContentSegments(snapshot);
+  if (reservedOutputTokens > 0) {
+    segments.push({ key: "reserved_output", label: "Reserved output", tokens: reservedOutputTokens });
+  }
+  const ordered = segments.filter((segment) => segment.tokens > 0).sort((a, b2) => displayCategoryOrder(a.key) - displayCategoryOrder(b2.key));
+  const usedTokens = Math.min(
+    totalTokens,
+    ordered.reduce((sum, segment) => sum + segment.tokens, 0)
+  );
+  const freeSpaceTokens = Math.max(0, totalTokens - usedTokens);
+  const slices = ordered.map((segment) => ({
+    key: segment.key,
+    label: segment.label,
+    tokens: segment.tokens,
+    pct: segment.tokens / totalTokens * 100
+  }));
+  return {
+    slices,
+    freeSpaceTokens,
+    freeSpacePct: freeSpaceTokens / totalTokens * 100,
+    usedTokens,
+    totalTokens,
+    usedPercent: usedTokens / totalTokens * 100,
+    truncationState: resolveTruncationState(snapshot)
+  };
+}
+function contextTruncationNotice(state) {
+  switch (state) {
+    case "compacted":
+      return "\u26A0 Context full \u2014 older messages were compacted to fit";
+    case "truncated":
+      return "\u26A0 Context full \u2014 older messages were dropped to fit";
+    default:
+      return "";
+  }
+}
+var ADMITTED_ROW_STATUSES2, DISPLAY_CATEGORY_ORDER;
 var init_contextMeterDisplay = __esm({
   "features/perchTerminal/runtime/contextMeterDisplay.ts"() {
     "use strict";
+    init_statusLabels();
     init_contextMeter();
     init_contextThresholds();
     ADMITTED_ROW_STATUSES2 = /* @__PURE__ */ new Set(["sent_raw", "sent_compacted"]);
+    DISPLAY_CATEGORY_ORDER = [
+      "system_prompt",
+      "system_tools",
+      "mcp_tools",
+      "skills",
+      "conversation",
+      "tool_transcript",
+      "memory_rules",
+      "evidence",
+      "workspace_context",
+      "workers",
+      "overhead",
+      "deferred",
+      "reserved_output"
+    ];
   }
 });
 
@@ -290603,20 +290823,33 @@ function renderCliContextMeter(snapshot, activeModel) {
   if (snapshot.compacted || compacted > 0) parts.push(`compacted ${compacted}`);
   return parts.join(" \xB7 ");
 }
+function renderCliBlockBar(percent2, width) {
+  const clamped = Math.max(0, Math.min(100, percent2));
+  const filled = Math.round(clamped / 100 * width);
+  return `\u2595${"\u2588".repeat(filled)}${"\u2591".repeat(Math.max(0, width - filled))}\u258F`;
+}
 function renderCliContextDetails(snapshot, activeModel) {
   if (!snapshot) return "context     no meter yet\n";
-  const meter = resolveContextMeterDisplay(snapshot, activeModel);
-  const percent2 = snapshot.contextPercentage ?? Math.round(meter.committedTokens / Math.max(1, meter.limitTokens) * 100);
-  const lines = [
-    ["context", renderCliContextMeter(snapshot, activeModel)],
-    ["thread", `${formatCliTokenCount(meter.threadTokens)} tokens`],
-    ["limit", `${formatCliTokenCount(meter.limitTokens)} tokens`],
-    ["fill", `${Math.max(0, Math.min(100, percent2))}%`],
-    ["compacted", snapshot.compacted || (snapshot.compactedRowCount ?? 0) > 0 ? `${snapshot.compactedRowCount ?? 0} row(s)` : "no"],
-    ["not-found", `${snapshot.notFoundRowCount ?? 0} row(s)`]
-  ];
   const color = shouldUseCliColor();
-  return lines.map(([key, value]) => `${paint(key.padEnd(11), "muted", color)} ${value}`).join("\n") + "\n";
+  const composition = buildContextComposition(snapshot, activeModel);
+  const percent2 = Math.max(0, Math.min(100, Math.round(composition.usedPercent)));
+  const bar = renderCliBlockBar(composition.usedPercent, 24);
+  const header = `${paint("context".padEnd(11), "muted", color)} ${paint(bar, percent2 >= 90 ? "red" : "accent", color)} ${formatCliTokenCount(composition.usedTokens)} / ${formatCliTokenCount(composition.totalTokens)} (${percent2}%)`;
+  const rows = [
+    ...composition.slices.map((slice2) => ({ label: slice2.label, tokens: slice2.tokens, pct: slice2.pct })),
+    { label: "Free space", tokens: composition.freeSpaceTokens, pct: composition.freeSpacePct }
+  ];
+  const labelWidth = Math.max(...rows.map((row) => row.label.length));
+  const tokenWidth = Math.max(...rows.map((row) => formatCliTokenCount(row.tokens).length));
+  const lines = rows.map((row) => {
+    const label = paint(`  ${row.label.padEnd(labelWidth)}`, "muted", color);
+    const tokens = formatCliTokenCount(row.tokens).padStart(tokenWidth);
+    return `${label}  ${tokens} \xB7 ${row.pct.toFixed(1).padStart(4)}%`;
+  });
+  const out = [header, ...lines];
+  const notice = contextTruncationNotice(composition.truncationState);
+  if (notice) out.push(paint(notice, "red", color));
+  return out.join("\n") + "\n";
 }
 function formatCliTokenCount(value) {
   if (value < 1e3) return `${Math.max(0, Math.round(value))}`;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "perchai-cli",
-  "version": "2.4.45",
+  "version": "2.4.46",
   "description": "Perch AI command-line interface",
   "bin": {
     "perch": "bin/perch"