@pellux/goodvibes-agent 1.5.5 → 1.5.6

package/src/tools/agent-local-registry-tool.ts

@@ -1,54 +1,35 @@
 import type { Tool } from '@pellux/goodvibes-sdk/platform/types';
 import type { ToolRegistry } from '@pellux/goodvibes-sdk/platform/tools';
 import type { ShellPathService } from '@/runtime/index.ts';
-import { MemoryRegistry, type MemoryClass, type MemoryRecord, type MemoryScope } from '@pellux/goodvibes-sdk/platform/state';
+import { MemoryRegistry } from '@pellux/goodvibes-sdk/platform/state';
 import { AgentPersonaRegistry, type AgentPersonaRecord } from '../agent/persona-registry.ts';
 import { AgentNoteRegistry, type AgentNoteRecord } from '../agent/note-registry.ts';
 import { AgentRoutineRegistry, type AgentRoutineRecord } from '../agent/routine-registry.ts';
 import { AgentSkillRegistry, type AgentSkillBundleRecord, type AgentSkillRecord } from '../agent/skill-registry.ts';
-import { assertNoSecretLikeMemoryText } from '../agent/memory-safety.ts';
-import { formatAgentRecordOrigin, formatAgentRecordReference, formatAgentRecordReviewState } from '../agent/record-labels.ts';
+import { formatAgentRecordOrigin, formatAgentRecordReviewState } from '../agent/record-labels.ts';
 import { buildAgentLocalRequirements } from './agent-local-registry-requirements.ts';
+import {
+  AGENT_TOOL_PROVENANCE,
+  type AgentLocalRegistryToolArgs,
+  readAffirmative,
+  readString,
+  readStringList,
+  registryError,
+  registryOutput,
+  requireConfirmedDelete,
+  requireDescription,
+  requireId,
+  requireName,
+  requireTextField,
+} from './agent-local-registry-args.ts';
+import { handleMemory, MEMORY_CLASSES, MEMORY_SCOPES } from './agent-local-registry-memory.ts';
 
 export type AgentLocalRegistryDomain = 'memory' | 'note' | 'persona' | 'skill' | 'skill_bundle' | 'routine';
 export type AgentLocalRegistryAction = 'list' | 'search' | 'get' | 'create' | 'update' | 'enable' | 'disable' | 'review' | 'stale' | 'use' | 'clear_active' | 'start' | 'delete';
-
-export interface AgentLocalRegistryToolArgs {
-  readonly domain?: unknown;
-  readonly action?: unknown;
-  readonly id?: unknown;
-  readonly query?: unknown;
-  readonly cls?: unknown;
-  readonly scope?: unknown;
-  readonly summary?: unknown;
-  readonly detail?: unknown;
-  readonly confidence?: unknown;
-  readonly title?: unknown;
-  readonly name?: unknown;
-  readonly description?: unknown;
-  readonly body?: unknown;
-  readonly sourceUrl?: unknown;
-  readonly procedure?: unknown;
-  readonly steps?: unknown;
-  readonly skills?: unknown;
-  readonly skillIds?: unknown;
-  readonly requiresEnv?: unknown;
-  readonly requiresCommands?: unknown;
-  readonly triggers?: unknown;
-  readonly tags?: unknown;
-  readonly reason?: unknown;
-  readonly enabled?: unknown;
-  readonly activate?: unknown;
-  readonly provenance?: unknown;
-  readonly confirm?: unknown;
-  readonly explicitUserRequest?: unknown;
-}
+export type { AgentLocalRegistryToolArgs } from './agent-local-registry-args.ts';
 
 const DOMAINS: readonly AgentLocalRegistryDomain[] = ['memory', 'note', 'persona', 'skill', 'skill_bundle', 'routine'];
 const ACTIONS: readonly AgentLocalRegistryAction[] = ['list', 'search', 'get', 'create', 'update', 'enable', 'disable', 'review', 'stale', 'use', 'clear_active', 'start', 'delete'];
-const MEMORY_CLASSES: readonly MemoryClass[] = ['decision', 'constraint', 'incident', 'pattern', 'fact', 'risk', 'runbook', 'architecture', 'ownership'];
-const MEMORY_SCOPES: readonly MemoryScope[] = ['session', 'project', 'team'];
-const AGENT_TOOL_PROVENANCE = 'agent-local-registry-tool';
 
 function isDomain(value: unknown): value is AgentLocalRegistryDomain {
   return typeof value === 'string' && DOMAINS.includes(value as AgentLocalRegistryDomain);
@@ -58,206 +39,6 @@ function isAction(value: unknown): value is AgentLocalRegistryAction {
   return typeof value === 'string' && ACTIONS.includes(value as AgentLocalRegistryAction);
 }
 
-function readString(value: unknown): string {
-  return typeof value === 'string' ? value.trim() : '';
-}
-
-function readAffirmative(value: unknown): boolean {
-  const normalized = readString(value).toLowerCase(); return value === true || (typeof value === 'string' && (normalized === '' || normalized === 'yes' || normalized === 'y' || normalized === 'true' || normalized === 'on'));
-}
-
-function readStringList(value: unknown): readonly string[] {
-  if (typeof value === 'string') {
-    return value.split(',').map((entry) => entry.trim()).filter(Boolean);
-  }
-  if (!Array.isArray(value)) return [];
-  return value.filter((entry): entry is string => typeof entry === 'string').map((entry) => entry.trim()).filter(Boolean);
-}
-
-function readOptionalNumber(value: unknown): number | undefined {
-  if (typeof value === 'number' && Number.isFinite(value)) return value;
-  if (typeof value !== 'string' || !value.trim()) return undefined;
-  const parsed = Number(value);
-  return Number.isFinite(parsed) ? parsed : undefined;
-}
-
-function readOptionalConfidence(value: unknown): number | undefined {
-  const confidence = readOptionalNumber(value);
-  if (confidence === undefined) return undefined;
-  if (confidence < 0 || confidence > 100) throw new Error('confidence must be between 0 and 100.');
-  return confidence;
-}
-
-function isMemoryClass(value: unknown): value is MemoryClass {
-  return typeof value === 'string' && MEMORY_CLASSES.includes(value as MemoryClass);
-}
-
-function isMemoryScope(value: unknown): value is MemoryScope {
-  return typeof value === 'string' && MEMORY_SCOPES.includes(value as MemoryScope);
-}
-
-function registryError(message: string): { readonly success: false; readonly error: string } {
-  return { success: false, error: message };
-}
-
-function registryOutput(output: string): { readonly success: true; readonly output: string } {
-  return { success: true, output };
-}
-
-function requireId(args: AgentLocalRegistryToolArgs): string {
-  const id = readString(args.id);
-  if (!id) throw new Error('id is required.');
-  return id;
-}
-
-function requireConfirmedDelete(args: AgentLocalRegistryToolArgs, label: string): void {
-  const explicitUserRequest = readString(args.explicitUserRequest);
-  if (!explicitUserRequest) throw new Error(`${label} deletion requires explicitUserRequest with the user's exact request or a short faithful summary.`);
-  if (args.confirm !== true) throw new Error(`${label} deletion requires confirm:true after an explicit user request.`);
-}
-
-function requireName(args: AgentLocalRegistryToolArgs): string {
-  const name = readString(args.name);
-  if (!name) throw new Error('name is required.');
-  return name;
-}
-
-function requireDescription(args: AgentLocalRegistryToolArgs): string {
-  const description = readString(args.description);
-  if (!description) throw new Error('description is required.');
-  return description;
-}
-
-function requireTextField(value: unknown, fieldName: string): string {
-  const text = readString(value);
-  if (!text) throw new Error(`${fieldName} is required.`);
-  return text;
-}
-
-function requireSummary(args: AgentLocalRegistryToolArgs): string {
-  const summary = readString(args.summary || args.description);
-  if (!summary) throw new Error('summary is required.');
-  return summary;
-}
-
-function requireMemoryClass(args: AgentLocalRegistryToolArgs): MemoryClass {
-  const cls = args.cls || 'fact';
-  if (!isMemoryClass(cls)) throw new Error(`Invalid memory class. Valid values ${MEMORY_CLASSES.join(', ')}.`);
-  return cls;
-}
-
-function readMemoryScope(args: AgentLocalRegistryToolArgs): MemoryScope {
-  const scope = args.scope || 'project';
-  if (!isMemoryScope(scope)) throw new Error(`Invalid memory scope. Valid values ${MEMORY_SCOPES.join(', ')}.`);
-  return scope;
-}
-
-function formatMemory(record: MemoryRecord): string {
-  const tags = record.tags.length > 0 ? ` tags ${record.tags.join(', ')}` : '';
-  return `${record.id}  ${record.scope}/${record.cls}  ${formatAgentRecordReviewState(record.reviewState)}  ${record.confidence}%${tags}  ${record.summary}`;
-}
-
-async function handleMemory(registry: MemoryRegistry, action: AgentLocalRegistryAction, args: AgentLocalRegistryToolArgs): Promise<string> {
-    if (action === 'list') {
-      const records = registry.getAll();
-      return records.length === 0
-        ? 'Agent-local memory\nNo Agent-local memory records.'
-        : ['Agent-local memory', ...records.map(formatMemory)].join('\n');
-    }
-    if (action === 'search') {
-      const query = readString(args.query);
-      const records = registry.search({ query, limit: 10 });
-      return records.length === 0
-        ? `Agent-local memory search\nNo Agent-local memory records matched "${query}".`
-        : ['Agent-local memory search', `query ${query || '(all)'}`, ...records.map(formatMemory)].join('\n');
-    }
-    if (action === 'get') {
-      const record = registry.get(requireId(args));
-      if (!record) return `Unknown Agent-local memory ${readString(args.id)}`;
-      return [
-        formatMemory(record),
-        `created ${new Date(record.createdAt).toISOString()}`,
-        `updated ${new Date(record.updatedAt).toISOString()}`,
-        `origin ${record.provenance.map((entry) => formatAgentRecordReference({ kind: String(entry.kind), ref: String(entry.ref) })).join(', ') || '(none)'}`,
-        `provenance: ${record.provenance.map((entry) => `${String(entry.kind)}:${String(entry.ref)}`).join(',') || '(none)'}`,
-        '',
-        record.detail || '(no detail)',
-      ].join('\n');
-    }
-    if (action === 'create') {
-      const summary = requireSummary(args);
-      const detail = readString(args.detail || args.body);
-      const tags = readStringList(args.tags);
-      const confidence = readOptionalConfidence(args.confidence);
-      assertNoSecretLikeMemoryText([summary, detail, ...tags]);
-      const record = await registry.add({
-        scope: readMemoryScope(args),
-        cls: requireMemoryClass(args),
-        summary,
-        detail,
-        tags: [...tags],
-        ...(confidence === undefined ? {} : { review: { state: 'fresh' as const, confidence } }),
-        provenance: [{ kind: 'event', ref: readString(args.provenance) || AGENT_TOOL_PROVENANCE }],
-      });
-      return [
-        'Created Agent-local memory',
-        `  id ${record.id}`,
-        `  summary ${record.summary}`,
-      ].join('\n');
-    }
-    if (action === 'update') {
-      const summary = readString(args.summary || args.description);
-      const detail = readString(args.detail || args.body);
-      const tags = args.tags === undefined ? undefined : [...readStringList(args.tags)];
-      assertNoSecretLikeMemoryText([summary, detail, ...(tags ?? [])]);
-      const record = registry.update(requireId(args), {
-        summary: summary || undefined,
-        detail: detail || undefined,
-        tags,
-        scope: args.scope === undefined ? undefined : readMemoryScope(args),
-      });
-      if (!record) return `Unknown Agent-local memory ${readString(args.id)}`;
-      return [
-        'Updated Agent-local memory',
-        `  id ${record.id}`,
-        `  summary ${record.summary}`,
-      ].join('\n');
-    }
-    if (action === 'review') {
-      const record = registry.review(requireId(args), {
-        state: 'reviewed',
-        confidence: readOptionalConfidence(args.confidence),
-        reviewedBy: 'agent',
-      });
-      if (!record) return `Unknown Agent-local memory ${readString(args.id)}`;
-      return [
-        'Reviewed Agent-local memory',
-        `  id ${record.id}`,
-      ].join('\n');
-    }
-    if (action === 'stale') {
-      const record = registry.review(requireId(args), {
-        state: 'stale',
-        staleReason: readString(args.reason) || 'Marked stale by Agent.',
-      });
-      if (!record) return `Unknown Agent-local memory ${readString(args.id)}`;
-      return [
-        'Marked Agent-local memory stale',
-        `  id ${record.id}`,
-      ].join('\n');
-    }
-    if (action === 'delete') {
-      const id = requireId(args);
-      requireConfirmedDelete(args, 'Agent-local memory');
-      if (!registry.delete(id)) return `Unknown Agent-local memory ${id}`;
-      return [
-        'Deleted Agent-local memory',
-        `  id ${id}`,
-      ].join('\n');
-    }
-    throw new Error(`Action ${action} is not valid for memory.`);
-}
-
 function formatNote(note: AgentNoteRecord): string {
   const tags = note.tags.length > 0 ? ` tags ${note.tags.join(', ')}` : '';
   const sourceUrl = note.sourceUrl ? ` source ${note.sourceUrl}` : '';
@@ -743,6 +524,7 @@ export function createAgentLocalRegistryTool(shellPaths: ShellPathService, memor
           action: { type: 'string', enum: [...ACTIONS] },
           id: { type: 'string' },
           query: { type: 'string' },
+          semantic: { type: 'boolean', description: 'Memory search: semantic by default; false forces literal matching.' },
           cls: { type: 'string', enum: [...MEMORY_CLASSES], description: 'Memory class when domain is memory.' },
           scope: { type: 'string', enum: [...MEMORY_SCOPES], description: 'Memory scope when domain is memory.' },
           summary: { type: 'string', description: 'Memory summary when domain is memory.' },

package/src/tools/agent-operator-briefing-tool.ts

@@ -30,7 +30,7 @@ const OPERATOR_BRIEFING_ROUTES: readonly OperatorRouteDescriptor[] = [
   { id: 'projectPlanning.workPlan.snapshot', path: '/api/projects/planning/work-plan' },
   { id: 'approvals.list', path: '/api/approvals' },
   { id: 'automation.integration.snapshot', path: '/api/automation' },
-  { id: 'schedules.list', path: '/api/automation/schedules' },
+  { id: 'automation.schedules.list', path: '/api/automation/schedules' },
   { id: 'scheduler.capacity', path: '/api/runtime/scheduler' },
 ] as const;
 
@@ -149,7 +149,7 @@ function formatRoute(result: OperatorRouteResult): string {
   if (result.route.id === 'projectPlanning.workPlan.snapshot') return formatWorkPlan(result.body);
   if (result.route.id === 'approvals.list') return formatApprovals(result.body);
   if (result.route.id === 'automation.integration.snapshot') return formatAutomation(result.body);
-  if (result.route.id === 'schedules.list') return formatSchedules(result.body);
+  if (result.route.id === 'automation.schedules.list') return formatSchedules(result.body);
   return formatCapacity(result.body);
 }
 

package/src/tools/agent-operator-method-tool.ts

@@ -17,6 +17,7 @@ interface OperatorContractMethod {
     readonly method?: string;
     readonly path?: string;
   };
+  readonly invokable?: boolean;
 }
 
 interface OperatorMethodToolArgs {
@@ -562,6 +563,18 @@ export function createAgentOperatorMethodTool(
           error: `Unknown GoodVibes operator method '${methodId}'. Inspect host action:"methods" first.`,
         };
       }
+      // W4-A3 (capability-advertisement honesty): the operator contract marks a
+      // cataloged-but-not-route-backed method invokable:false (email.inbox.list,
+      // email.send, etc. — see @pellux/goodvibes-sdk's method-catalog-route-reconcile).
+      // Refuse here, before prepareOperatorRoute/fetch, rather than letting the
+      // model discover a bare 404 from a route that was never wired up. The ad
+      // must degrade at the source, not rely on the model coping with a 404.
+      if (method.invokable === false) {
+        return {
+          success: false,
+          error: `operator method '${method.id}' is unavailable (route not served by this daemon). Do not retry it; the daemon has not wired this capability up.`,
+        };
+      }
 
       let route: PreparedOperatorRoute;
       try {

package/src/tools/agent-policy-explanation.ts

@@ -6,6 +6,7 @@ import type { CommandContext } from '../input/command-registry.ts';
 import { fallbackPermissionCategoryForArgs } from '../runtime/tool-permission-safety.ts';
 import { HARNESS_MODE_DESCRIPTORS } from './agent-harness-mode-catalog.ts';
 import { explainAgentToolPolicyInvocation } from './agent-tool-policy-guard.ts';
+import { computeApprovalPosture, type ApprovalPosture } from '../permissions/approval-posture.ts';
 
 type PolicyExplanationStatus = 'allowed' | 'confirmation_required' | 'denied';
 type PermissionPredictionOutcome = 'allowed' | 'prompt' | 'denied';
@@ -186,18 +187,42 @@ function readAutoApprove(context: CommandContext): boolean {
   return context.platform.config?.behavior?.autoApprove === true;
 }
 
+/**
+ * Reads the SAME effective approval posture that cli/status.ts, the doctor
+ * surface, and the footer read (via computeApprovalPosture) — the shared
+ * single source of truth, so this tool's "explain" output never disagrees
+ * with what those other surfaces say about auto-approve / permission mode.
+ */
+function readEffectivePosture(context: CommandContext): ApprovalPosture {
+  const mode = readPermissionMode(context);
+  const customTools: Record<string, unknown> = {};
+  if (mode === 'custom') {
+    for (const key of Object.values(TOOL_CONFIG_KEYS)) {
+      if (key in customTools) continue;
+      customTools[key] = readPermissionToolAction(context, key) ?? undefined;
+    }
+  }
+  return computeApprovalPosture({
+    autoApprove: readAutoApprove(context),
+    mode,
+    customTools,
+  });
+}
+
 function predictPermission(context: CommandContext, toolName: string, category: PermissionCategory): PermissionPrediction {
-  if (readAutoApprove(context)) {
+  const posture = readEffectivePosture(context);
+
+  if (posture.autoApprove) {
     return {
       outcome: 'allowed',
       sourceLayer: 'config_policy',
       reasonCode: 'config_allow',
-      mode: readPermissionMode(context),
-      reason: 'Automatic tool approval is enabled for this session.',
+      mode: posture.mode,
+      reason: posture.detail,
     };
   }
 
-  const mode = readPermissionMode(context);
+  const mode = posture.mode;
   if (mode === 'allow-all') {
     return {
       outcome: 'allowed',
@@ -350,6 +375,10 @@ export function explainAgentPolicyDecision(
     ...(permission.outcome === 'prompt' ? [`Answer the ${category} permission prompt for ${toolName}.`] : []),
     ...(confirmation.required && !confirmation.confirmed ? ['Call the route with confirm:true and explicitUserRequest.'] : []),
   ];
+  // The overall approval posture — computed by the SAME shared helper that
+  // cli/status.ts, the doctor surface, and the footer use, so this tool's
+  // own displayed posture text can never disagree with theirs.
+  const posture = readEffectivePosture(context);
 
   return {
     status: 'found',
@@ -359,6 +388,12 @@ export function explainAgentPolicyDecision(
       registered: definition !== undefined,
       category,
       userExplanation: userExplanation(status, category),
+      posture: {
+        label: posture.label,
+        autoApprove: posture.autoApprove,
+        mode: posture.mode,
+        bypassesPrompts: posture.bypassesPrompts,
+      },
       policyLayers: [
         {
           layer: 'Agent route guard',

package/src/tools/agent-schedule-tool.ts

@@ -52,10 +52,10 @@ interface AgentScheduleToolArgs {
 }
 
 const LIFECYCLE_ACTIONS: Readonly<Record<'run' | 'pause' | 'resume' | 'delete', string>> = {
-  run: 'schedules.run',
-  pause: 'schedules.disable',
-  resume: 'schedules.enable',
-  delete: 'schedules.delete',
+  run: 'automation.schedules.run',
+  pause: 'automation.schedules.disable',
+  resume: 'automation.schedules.enable',
+  delete: 'automation.schedules.delete',
 };
 
 function readString(value: unknown): string {
@@ -248,7 +248,7 @@ export function createAgentScheduleTool(
       const action = readAction(args);
       if (action === 'list') {
         return operatorMethodTool.execute({
-          methodId: 'schedules.list',
+          methodId: 'automation.schedules.list',
           input: listInput(args),
         });
       }

package/src/utils/terminal-width.ts

@@ -1,9 +1,54 @@
+/**
+ * Strip ANSI SGR/CSI escape sequences and OSC-8 hyperlink sequences
+ * from a string so that only visible characters remain for width measurement.
+ *
+ * Covers:
+ *   - CSI sequences: ESC [ ... <final byte 0x40-0x7E>  (includes SGR \x1b[...m)
+ *   - OSC sequences: ESC ] ... ST  where ST is ESC\\ or BEL (0x07)
+ *   - Simple ESC followed by a single non-bracket/non-] character (e.g. ESC c)
+ */
+function stripAnsi(text: string): string {
+  let result = '';
+  let i = 0;
+  while (i < text.length) {
+    if (text[i] === '\x1b') {
+      const next = text[i + 1];
+      if (next === '[') {
+        // CSI: skip until final byte (0x40-0x7E)
+        i += 2;
+        while (i < text.length) {
+          const c = text.charCodeAt(i);
+          i++;
+          if (c >= 0x40 && c <= 0x7e) break;
+        }
+      } else if (next === ']') {
+        // OSC: skip until ST (ESC\\ or BEL)
+        i += 2;
+        while (i < text.length) {
+          if (text[i] === '\x07') { i++; break; }
+          if (text[i] === '\x1b' && text[i + 1] === '\\') { i += 2; break; }
+          i++;
+        }
+      } else {
+        // Simple two-byte escape (ESC + one char)
+        i += next !== undefined ? 2 : 1;
+      }
+    } else {
+      result += text[i];
+      i++;
+    }
+  }
+  return result;
+}
+
 /**
  * Calculates the visual width of a string in the terminal.
  * Handles CJK characters, emoji (including ZWJ sequences), and
- * variation selectors correctly as double-width.
+ * variation selectors correctly as double-width. ANSI escape sequences
+ * (SGR/CSI/OSC-8) are stripped before measurement.
  */
 export function getDisplayWidth(text: string): number {
+  text = stripAnsi(text);
   let width = 0;
   let i = 0;
   while (i < text.length) {
@@ -34,6 +79,13 @@ export function getDisplayWidth(text: string): number {
       code === 0x2717 ||
       code === 0x2714 ||
       code === 0x2718 ||
+      // ✕ (0x2715) and ✖ (0x2716) — the multiplication-X cross family used for
+      // the error-line prefix. Terminals draw them one cell wide, but they sit
+      // inside the 0x2600–0x27bf emoji block below and would otherwise be counted
+      // as width 2, desyncing the styled cell grid from the physical glyph and
+      // corrupting the following text (the "✕t" glitch on the steer error line).
+      code === 0x2715 ||
+      code === 0x2716 ||
       code === 0x2022 ||
       code === 0x258d ||
       (code >= 0x2500 && code <= 0x257f)
@@ -107,6 +159,51 @@ export function truncateDisplay(text: string, width: number, ellipsis = '…'):
   return result + ellipsis;
 }
 
+/** A single footer/status-line segment plus its survival priority. */
+export interface PrioritizedSegment {
+  readonly text: string;
+  /** Lower number = higher priority = dropped LAST under width pressure. */
+  readonly priority: number;
+}
+
+/**
+ * Join segments left-to-right with `separator`, but when the joined line
+ * would exceed `width`, drop whole low-priority segments (highest `priority`
+ * number first) one at a time until it fits — rather than character-truncating
+ * the joined string, which can mangle a high-value segment mid-word (e.g. a
+ * `spine:online` daemon-liveness marker clipped to `spi…`).
+ *
+ * Only falls back to character truncation (via truncateDisplay) if the
+ * remaining highest-priority segments still don't fit at width — a rare,
+ * very-narrow-terminal case.
+ */
+export function joinPrioritizedSegments(
+  segments: readonly PrioritizedSegment[],
+  separator: string,
+  width: number,
+): string {
+  const join = (list: readonly PrioritizedSegment[]) => list.map(s => s.text).join(separator);
+  let kept = segments;
+  // Keep dropping whole segments while more than one remains; once a single
+  // segment is left, stop — an empty result would be a worse outcome than
+  // falling through to character truncation on that last segment below.
+  while (kept.length > 1 && getDisplayWidth(join(kept)) > width) {
+    // Drop the single lowest-priority (highest `priority` number) segment;
+    // ties broken toward the leftmost (earlier-declared) segment surviving —
+    // `>=` (not `>`) so that on equal priority the LATER index keeps winning
+    // as the drop candidate, leaving the earliest-declared segment of that
+    // priority tier intact (e.g. cwd survives over model when both are
+    // priority 0, since cwd is declared first).
+    let dropIdx = 0;
+    for (let i = 1; i < kept.length; i++) {
+      if (kept[i].priority >= kept[dropIdx].priority) dropIdx = i;
+    }
+    kept = kept.slice(0, dropIdx).concat(kept.slice(dropIdx + 1));
+  }
+  const joined = join(kept);
+  return getDisplayWidth(joined) > width ? truncateDisplay(joined, width) : joined;
+}
+
 export function padDisplayEnd(text: string, width: number): string {
   const currentWidth = getDisplayWidth(text);
   if (currentWidth >= width) return text;

package/src/version.ts

@@ -6,7 +6,7 @@ import { join } from 'node:path';
 // The prebuild script updates the fallback value before compilation.
 // Uses import.meta.dir (Bun) to locate package.json relative to this file,
 // which is correct regardless of the process working directory.
-let _version = '1.5.5';
+let _version = '1.5.6';
 try {
   const pkg = JSON.parse(readFileSync(join(import.meta.dir, '..', 'package.json'), 'utf-8')) as {
     readonly version?: unknown;