perchai-cli 2.4.24 → 2.4.26

package/dist/perch.mjs

@@ -76921,6 +76921,7 @@ function buildTranscriptSegments(state) {
   const terminalSegmentIdx = /* @__PURE__ */ new Map();
   const workerRunIdx = /* @__PURE__ */ new Map();
   const flockRunIdx = /* @__PURE__ */ new Map();
+  const diagnosticIdxByKey = /* @__PURE__ */ new Map();
   const capabilityIdx = /* @__PURE__ */ new Map();
   const liveCardIdx = /* @__PURE__ */ new Map();
   const workflowCardIdx = /* @__PURE__ */ new Map();
@@ -77542,6 +77543,38 @@ function buildTranscriptSegments(state) {
       case "diagnostic": {
         flushReasoning();
         if (!ev.message.trim()) break;
+        if (ev.code === "tool_call_budget_exhausted") {
+          let attributed = false;
+          if (ev.workerId) {
+            for (const [flockId, idx] of flockRunIdx) {
+              const seg = segments[idx];
+              if (seg?.kind !== "flock_run") continue;
+              if (!seg.workers.some((worker) => worker.workerId === ev.workerId)) continue;
+              segments[idx] = {
+                ...seg,
+                workers: seg.workers.map(
+                  (worker) => worker.workerId === ev.workerId ? { ...worker, note: "tool limit \u2014 finishing from gathered evidence" } : worker
+                )
+              };
+              attributed = Boolean(flockId);
+              break;
+            }
+          }
+          if (!attributed) {
+            const key = `tool-budget-${ev.workerId ?? "turn"}`;
+            const existingIdx = diagnosticIdxByKey.get(key);
+            if (existingIdx !== void 0 && segments[existingIdx]?.kind === "diagnostic") {
+              segments[existingIdx] = {
+                ...segments[existingIdx],
+                message: ev.message
+              };
+            } else {
+              diagnosticIdxByKey.set(key, segments.length);
+              segments.push({ kind: "diagnostic", message: ev.message, seq: seq++, timestamp: ev.ts });
+            }
+          }
+          break;
+        }
         segments.push({
           kind: "diagnostic",
           message: ev.message,
@@ -77849,6 +77882,7 @@ function buildTranscriptSegments(state) {
           plannerSource: ev.plannerSource,
           workers: ev.workers.map((worker) => ({
             flockWorkerId: worker.flockWorkerId,
+            workerId: worker.workerId,
             displayName: worker.displayName,
             nickname: worker.nickname,
             status: "queued"
@@ -77868,6 +77902,7 @@ function buildTranscriptSegments(state) {
           ...seg.workers,
           {
             flockWorkerId: ev.flockWorkerId,
+            workerId: ev.workerId,
             displayName: ev.displayName,
             nickname: ev.nickname,
             status: ev.status
@@ -83022,7 +83057,6 @@ function listFinancialRoleIds() {
 var FINANCIAL_ROLE_REGISTRY, evidenceScoutManifest;
 var init_financialRoles = __esm({
   "features/perchTerminal/agentPlatform/financialRoles.ts"() {
-    "use strict";
     FINANCIAL_ROLE_REGISTRY = /* @__PURE__ */ new Map();
     evidenceScoutManifest = {
       workerId: "evidence_scout",
@@ -86588,7 +86622,6 @@ function truncateHistoryLine(value, max2) {
 }
 var init_operatorTruth = __esm({
   "features/perchTerminal/runtime/operatorTruth.ts"() {
-    "use strict";
   }
 });
 
@@ -91554,6 +91587,7 @@ function listFinancialPlaybooks() {
 var AP_AUDIT_PACKET_DEF, PLAYBOOKS;
 var init_registry2 = __esm({
   "features/perchTerminal/runtime/financialPlaybooks/registry.ts"() {
+    "use strict";
     init_managedWorkflowRegistry2();
     init_toolNames();
     AP_AUDIT_PACKET_DEF = {
@@ -217708,10 +217742,18 @@ async function runModelToolLoop(input) {
         batch.slice(remainingRealToolCalls).map((toolCall) => toolCall.id)
       );
       if (skippedForToolBudget.size > 0) {
+        const skippedToolNames = [
+          ...new Set(
+            batch.filter((toolCall) => skippedForToolBudget.has(toolCall.id)).map((toolCall) => toolCall.name)
+          )
+        ];
         onEvent({
           type: "diagnostic",
           code: "tool_call_budget_exhausted",
-          message: `Tool-call budget exhausted after ${realToolCallsStarted}/${maxToolCalls ?? 0} real tool call(s); suppressing ${skippedForToolBudget.size} requested call(s).`,
+          message: `Tool budget reached after ${realToolCallsStarted} call(s) \u2014 finishing from gathered evidence.`,
+          toolNames: skippedToolNames,
+          skippedCount: skippedForToolBudget.size,
+          maxToolCalls: maxToolCalls ?? 0,
           ts: now5()
         });
       }
@@ -217725,6 +217767,7 @@ async function runModelToolLoop(input) {
         firstPartyToolIntentUsed = true;
       }
       const batchTerminalIds = batch.map((toolCall) => {
+        if (skippedForToolBudget.has(toolCall.id)) return null;
         onEvent({
           type: "tool_call_requested",
           toolName: toolCall.name,
@@ -217896,17 +217939,20 @@ async function runModelToolLoop(input) {
           consecutiveRequiredArgFailures,
           execution
         );
-        onEvent({
-          type: execution.ok ? "tool_call_completed" : "tool_call_failed",
-          toolName: toolCall.name,
-          toolCallId: toolCall.id,
-          riskLevel: execution.riskLevel,
-          ok: execution.ok,
-          errorCode: execution.errorCode,
-          error: execution.error,
-          metadata: browserPerceptionMetadata(execution),
-          ts: now5()
-        });
+        const isToolBudgetSuppressed = execution.errorCode === "tool_call_budget_exhausted";
+        if (!isToolBudgetSuppressed) {
+          onEvent({
+            type: execution.ok ? "tool_call_completed" : "tool_call_failed",
+            toolName: toolCall.name,
+            toolCallId: toolCall.id,
+            riskLevel: execution.riskLevel,
+            ok: execution.ok,
+            errorCode: execution.errorCode,
+            error: execution.error,
+            metadata: browserPerceptionMetadata(execution),
+            ts: now5()
+          });
+        }
         if (execution.ok && (toolCall.name === "writeLocalFile" || toolCall.name === "editLocalFile")) {
           const out = typeof execution.output === "object" && execution.output !== null ? execution.output : null;
           const filePath = typeof out?.relativePath === "string" ? out.relativePath : null;
@@ -217965,7 +218011,7 @@ async function runModelToolLoop(input) {
           });
         }
         const toolResultText = execution.outputSummary?.trim() ? execution.outputSummary : execution.result.slice(0, 1500);
-        if (toolResultText.trim() && !isTerminalTool) {
+        if (toolResultText.trim() && !isTerminalTool && !isToolBudgetSuppressed) {
           onEvent({
             type: "tool_output_delta",
             toolName: toolCall.name,
@@ -217982,7 +218028,7 @@ async function runModelToolLoop(input) {
           });
         }
         const persistOption = autoRouterActive && lastAutoHopModelId ? getFounderModelOption(lastAutoHopModelId) ?? option : option;
-        if (persistToolCall && !isSyntheticReadSuppressionExecution(execution)) {
+        if (persistToolCall && !isSyntheticReadSuppressionExecution(execution) && !isToolBudgetSuppressed) {
           await persistToolCall({
             toolName: execution.toolName,
             toolCallId: execution.toolCallId,
@@ -219469,7 +219515,7 @@ ${contextBlock}
       return;
     }
     if (event.type === "diagnostic") {
-      ctx.onEvent(event);
+      ctx.onEvent({ ...event, workerId: args.workerId });
       return;
     }
     if (event.type === "model_call_failed") {
@@ -220309,7 +220355,7 @@ function flockCaps() {
 function resolveFlockWriteWorkerCap(input) {
   return input.permissionMode === "take_the_wheel" && input.planJustifiesMoreWriters ? FLOCK_MAX_WRITE_WORKERS_TAKE_THE_WHEEL : FLOCK_MAX_WRITE_WORKERS;
 }
-var FLOCK_MIN_WORKERS, FLOCK_MAX_WORKERS, FLOCK_PREFERRED_WORKERS, FLOCK_DEFAULT_WALL_MS, FLOCK_MAX_WALL_MS, FLOCK_MAX_TOTAL_TOOL_CALLS, FLOCK_MAX_WORKER_ITERATIONS, FLOCK_MAX_WRITE_WORKERS, FLOCK_MAX_WRITE_WORKERS_TAKE_THE_WHEEL, FLOCK_MIN_TASK_CHARS, FLOCK_MIN_TASK_WORDS, FLOCK_MAX_TASK_CHARS;
+var FLOCK_MIN_WORKERS, FLOCK_MAX_WORKERS, FLOCK_PREFERRED_WORKERS, FLOCK_DEFAULT_WALL_MS, FLOCK_MAX_WALL_MS, FLOCK_MAX_TOTAL_TOOL_CALLS, FLOCK_MIN_WORKER_TOOL_CALLS, FLOCK_MAX_WORKER_TOOL_CALLS, FLOCK_MAX_WORKER_ITERATIONS, FLOCK_MAX_WRITE_WORKERS, FLOCK_MAX_WRITE_WORKERS_TAKE_THE_WHEEL, FLOCK_MIN_TASK_CHARS, FLOCK_MIN_TASK_WORDS, FLOCK_MAX_TASK_CHARS;
 var init_flockLimits = __esm({
   "features/perchTerminal/runtime/flock/flockLimits.ts"() {
     "use strict";
@@ -220319,7 +220365,9 @@ var init_flockLimits = __esm({
     FLOCK_PREFERRED_WORKERS = { min: 3, max: 6 };
     FLOCK_DEFAULT_WALL_MS = 8 * 6e4;
     FLOCK_MAX_WALL_MS = 10 * 6e4;
-    FLOCK_MAX_TOTAL_TOOL_CALLS = 80;
+    FLOCK_MAX_TOTAL_TOOL_CALLS = 160;
+    FLOCK_MIN_WORKER_TOOL_CALLS = 12;
+    FLOCK_MAX_WORKER_TOOL_CALLS = 40;
     FLOCK_MAX_WORKER_ITERATIONS = Math.min(10, MAX_WORKER_ITERATIONS);
     FLOCK_MAX_WRITE_WORKERS = 2;
     FLOCK_MAX_WRITE_WORKERS_TAKE_THE_WHEEL = 4;
@@ -220329,6 +220377,118 @@ var init_flockLimits = __esm({
   }
 });
 
+// features/perchTerminal/runtime/flock/flockModelHints.ts
+function parseFlockModelHints(task) {
+  const hints = [];
+  const seen = /* @__PURE__ */ new Set();
+  const push2 = (modelText, roleText, explicit) => {
+    const model = modelText.trim().replace(/\s+/g, " ");
+    const role = roleText.trim().toLowerCase();
+    if (!model || !(role in ROLE_WORD_MAP)) return;
+    const key = `${model.toLowerCase()}\u2192${role}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    hints.push({ modelText: model, roleText: role, explicit });
+  };
+  const usePattern = new RegExp(
+    `\\buse\\s+([A-Za-z0-9][A-Za-z0-9 ._/-]{0,30}?)\\s+(?:as|for)\\s+(?:an?\\s+|the\\s+)?(${ROLE_WORDS})\\b`,
+    "gi"
+  );
+  for (const match of task.matchAll(usePattern)) {
+    push2(match[1], match[2], true);
+  }
+  const pairPattern = new RegExp(
+    `\\b([A-Z][A-Za-z0-9._-]{1,24})\\s+(${ROLE_WORDS})\\b`,
+    "g"
+  );
+  for (const match of task.matchAll(pairPattern)) {
+    if (/^(use|using|the|a|an|as|and|with|for)$/i.test(match[1])) continue;
+    push2(match[1], match[2], false);
+  }
+  return hints;
+}
+function resolveFlockModelOption(modelText) {
+  const needle = modelText.trim().toLowerCase();
+  if (needle.length < 2) return null;
+  const usable = FOUNDER_MODEL_OPTIONS.filter(
+    (option) => isOptionAllowedForLane(option, "fast_worker") || isOptionAllowedForLane(option, "code_worker") || isOptionAllowedForLane(option, "verifier")
+  );
+  const haystacks = (option) => [option.label, option.vendor ?? "", option.family ?? "", option.modelId, option.id].join(" ").toLowerCase();
+  const ranked = [...usable].sort(
+    (a, b2) => Number(b2.userFacing === true) - Number(a.userFacing === true)
+  );
+  return ranked.find((option) => haystacks(option).includes(needle)) ?? null;
+}
+function applyFlockModelOverrides(plan, task) {
+  const report = { applied: [], unavailable: [] };
+  const hints = parseFlockModelHints(task);
+  for (const hint of hints) {
+    const option = resolveFlockModelOption(hint.modelText);
+    if (!option) {
+      if (hint.explicit) report.unavailable.push(hint);
+      continue;
+    }
+    const roles = new Set(ROLE_WORD_MAP[hint.roleText] ?? []);
+    const targets = plan.workers.filter(
+      (worker) => roles.has(worker.role) || worker.displayName.toLowerCase().includes(hint.roleText)
+    );
+    if (targets.length === 0) continue;
+    for (const worker of targets) {
+      if (worker.modelOverride) continue;
+      worker.modelOverride = { optionId: option.id, label: option.label };
+      report.applied.push({
+        flockWorkerId: worker.flockWorkerId,
+        displayName: worker.displayName,
+        modelText: hint.modelText,
+        label: option.label
+      });
+    }
+  }
+  return report;
+}
+function founderSelectionWithModelOverride(base, optionId) {
+  const selection = base ?? DEFAULT_FOUNDER_MODEL_SELECTION;
+  return {
+    ...selection,
+    chatModelId: optionId,
+    supervisorModelId: optionId,
+    fastWorkerModelId: optionId,
+    codeWorkerModelId: optionId,
+    dataWorkerModelId: optionId,
+    writerModelId: optionId,
+    verifierModelId: optionId
+  };
+}
+var ROLE_WORD_MAP, ROLE_WORDS;
+var init_flockModelHints = __esm({
+  "features/perchTerminal/runtime/flock/flockModelHints.ts"() {
+    "use strict";
+    init_modelRegistry();
+    ROLE_WORD_MAP = {
+      scout: ["scout"],
+      scouts: ["scout"],
+      explorer: ["scout"],
+      worker: ["worker"],
+      workers: ["worker"],
+      coder: ["worker"],
+      patcher: ["worker"],
+      builder: ["worker"],
+      reviewer: ["verifier", "reducer"],
+      reviewers: ["verifier", "reducer"],
+      verifier: ["verifier"],
+      verifiers: ["verifier"],
+      tester: ["verifier"],
+      checker: ["verifier"],
+      reducer: ["reducer"],
+      synthesizer: ["reducer"],
+      synthesiser: ["reducer"],
+      synth: ["reducer"],
+      summarizer: ["reducer"]
+    };
+    ROLE_WORDS = Object.keys(ROLE_WORD_MAP).join("|");
+  }
+});
+
 // features/perchTerminal/runtime/flock/flockNicknames.ts
 function seedFromFlockId(flockId) {
   let hash = 2166136261;
@@ -220622,6 +220782,7 @@ function buildPlanWorker(spec, index, flockId, task, writeScope, caps) {
     writeScope: spec.writesWorkspace ? writeScope : null,
     outputContract: spec.outputContract,
     dependsOn: [],
+    modelOverride: null,
     dynamicManifest: null
   };
 }
@@ -220685,7 +220846,7 @@ function buildFlockPlannerPrompts(ctx) {
     "- allowedTools: choose ONLY from availableTools in the input. Never request orchestration or delegation tools.",
     `- At most ${writeCap} workers with writesWorkspace=true; each writer needs a disjoint, clearly scoped responsibility, and writeJustification is required for more than ${resolveFlockWriteWorkerCap({ permissionMode: null, planJustifiesMoreWriters: false })}.`,
     `- maxIterations: 1-${caps.maxIterationsPerWorker}.`,
-    "- dependsOn: ids of earlier workers whose output this worker needs. No cycles.",
+    "- dependsOn: ids of earlier workers whose output this worker needs. No cycles. You decide the graph: parallel where independent, chained where not. Final verifier/reducer workers usually benefit from depending on the workers they check \u2014 guidance, not a requirement.",
     "- baseWorkerId: set ONLY to reuse an id from existingWorkers; otherwise null.",
     "- Decline (accepted=false, with reason) tasks that are trivial, conversational, or need no fanout."
   ].join("\n");
@@ -220814,6 +220975,8 @@ function validateLlmFlockPlan(record, ctx) {
       outputContract,
       dependsOn: [],
       // resolved below once all ids are known
+      modelOverride: null,
+      // applied later from explicit task hints only
       dynamicManifest: reusedManifest ? null : buildDynamicManifest({
         workerId: dynamicWorkerId,
         displayName,
@@ -221024,6 +221187,13 @@ async function runFlockTurn(input, deps, options = {}) {
         flockId
       });
     }
+    if (plan.accepted && typeof options.totalToolCallBudget === "number") {
+      plan.caps.maxTotalToolCalls = Math.max(
+        1,
+        Math.min(Math.floor(options.totalToolCallBudget), plan.caps.maxTotalToolCalls)
+      );
+    }
+    const modelOverrides = plan.accepted ? applyFlockModelOverrides(plan, task) : { applied: [], unavailable: [] };
     emitPlanEvent(emit, plan);
     if (!plan.accepted) {
       emit({
@@ -221070,9 +221240,12 @@ async function runFlockTurn(input, deps, options = {}) {
     const sharedContext = { task };
     let toolCallsUsed = 0;
     let toolCallsReserved = 0;
+    let workersAwaitingLaunch = plan.workers.length;
     try {
       const phases = [...new Set(plan.workers.map((worker) => FLOCK_ROLE_ORDER[worker.role]))].sort((a, b2) => a - b2);
       const runReadyWorker = async (worker) => {
+        const workersLeftIncludingThis = Math.max(1, workersAwaitingLaunch);
+        workersAwaitingLaunch = Math.max(0, workersAwaitingLaunch - 1);
         if (flockRun.controller.signal.aborted) {
           const outcome = {
             worker,
@@ -221094,9 +221267,13 @@ async function runFlockTurn(input, deps, options = {}) {
           emitWorkerUpdate(emit, plan, worker, "skipped", outcome.detail);
           return outcome;
         }
-        const reservedToolCalls = Math.max(
-          1,
-          Math.min(worker.maxIterations, remainingToolCalls)
+        const fairShare = Math.floor(remainingToolCalls / workersLeftIncludingThis);
+        const reservedToolCalls = Math.min(
+          remainingToolCalls,
+          Math.max(
+            FLOCK_MIN_WORKER_TOOL_CALLS,
+            Math.min(FLOCK_MAX_WORKER_TOOL_CALLS, fairShare)
+          )
         );
         toolCallsReserved += reservedToolCalls;
         emitWorkerUpdate(emit, plan, worker, "running");
@@ -221109,7 +221286,7 @@ async function runFlockTurn(input, deps, options = {}) {
               maxIterations: worker.maxIterations,
               maxToolCalls: reservedToolCalls
             },
-            buildSpawnContext(input, plan.flockId, flockRun.controller.signal, emit)
+            buildSpawnContext(input, plan.flockId, flockRun.controller.signal, emit, worker)
           );
           toolCallsReserved -= reservedToolCalls;
           toolCallsUsed += Math.min(result2.toolCalls ?? 0, reservedToolCalls);
@@ -221183,7 +221360,15 @@ async function runFlockTurn(input, deps, options = {}) {
     const workersDone = outcomes.filter((outcome) => outcome.status === "done").length;
     const workersFailed = outcomes.filter((outcome) => outcome.status === "failed").length;
     const flockStatus = userCancelled || wallTimeHit && workersDone === 0 ? "cancelled" : workersFailed === 0 && workersDone === plan.workers.length ? "completed" : workersDone > 0 ? "partial" : "failed";
-    const assistantText = buildFlockSummary(plan, outcomes, flockStatus, toolCallsUsed, wallTimeHit);
+    const assistantText = [
+      buildFlockSummary(plan, outcomes, flockStatus, toolCallsUsed, wallTimeHit),
+      ...modelOverrides.applied.map(
+        (override) => `Model override: ${override.displayName} ran on ${override.label}.`
+      ),
+      ...modelOverrides.unavailable.map(
+        (override) => `Requested model "${override.modelText}"${override.roleText ? ` for ${override.roleText}` : ""} is not available \u2014 that worker stayed on the default model path.`
+      )
+    ].join("\n");
     emit({
       type: "flock_run_completed",
       flockId: plan.flockId,
@@ -221234,7 +221419,8 @@ function emitPlanEvent(emit, plan) {
       maxIterations: worker.maxIterations,
       allowedTools: worker.allowedTools,
       writeScope: worker.writeScope,
-      outputContract: worker.outputContract
+      outputContract: worker.outputContract,
+      modelOverride: worker.modelOverride?.label ?? null
     })) : [],
     caps: plan.accepted ? plan.caps : { maxWorkers: 0, maxWallMs: 0, maxTotalToolCalls: 0, maxIterationsPerWorker: 0 },
     ts: now6()
@@ -221264,7 +221450,7 @@ function buildWorkerContext(worker, sharedContext, outputByFlockWorkerId, plan)
   }
   return { task: sharedContext.task, dependencies };
 }
-function buildSpawnContext(input, flockId, signal, emit) {
+function buildSpawnContext(input, flockId, signal, emit, worker) {
   return {
     workspaceRoot: input.activeRootPath ?? "",
     desktopConnected: input.desktopConnected,
@@ -221277,7 +221463,12 @@ function buildSpawnContext(input, flockId, signal, emit) {
     supabaseConfigured: input.supabaseConfigured,
     supabase: input.supabase ?? null,
     runId: flockId,
-    founderModelSelection: input.founderModelSelection ?? null,
+    // Default: the currently selected Perch model path. Only an explicit
+    // "use <model> as <role>" request in the task pins this worker elsewhere.
+    founderModelSelection: worker.modelOverride ? founderSelectionWithModelOverride(
+      input.founderModelSelection ?? null,
+      worker.modelOverride.optionId
+    ) : input.founderModelSelection ?? null,
     onEvent: emit,
     signal,
     mcpTools: input.mcpTools ?? []
@@ -221312,6 +221503,7 @@ var init_runFlockTurn = __esm({
     init_registry();
     init_flockCommand();
     init_flockLimits();
+    init_flockModelHints();
     init_flockLlmPlanner();
     init_flockPlanner();
     init_flockRoles();
@@ -285013,10 +285205,12 @@ var init_build2 = __esm({
 // scripts/perch-cli.ts
 var perch_cli_exports = {};
 __export(perch_cli_exports, {
+  FLOCK_NICKNAME_ACCENTS: () => FLOCK_NICKNAME_ACCENTS,
   HELP_TEXT: () => HELP_TEXT,
   INTERACTIVE_HELP_TEXT: () => INTERACTIVE_HELP_TEXT,
   PERCH_SPLASH_COMMANDS: () => PERCH_SPLASH_COMMANDS,
   flockEventToCliRow: () => flockEventToCliRow,
+  flockNicknameAccentColor: () => flockNicknameAccentColor,
   parseInteractiveSlashCommand: () => parseInteractiveSlashCommand,
   parsePerchCli: () => parsePerchCli,
   runPerchCli: () => runPerchCli
@@ -285648,6 +285842,8 @@ async function runInkInteractivePerchCli(writer, deps, options) {
           setLiveText("");
           liveTextRef.current = "";
           const toolNamesById = /* @__PURE__ */ new Map();
+          const flockWorkerNames = /* @__PURE__ */ new Map();
+          const flockLimitMeta = /* @__PURE__ */ new Map();
           const clientRunId = createCliRunId();
           const externalController = new AbortController();
           const runtimeRun = registerRuntimeRun({
@@ -285939,10 +286135,40 @@ async function runInkInteractivePerchCli(writer, deps, options) {
                   case "executor_waiting_for_user":
                     addItem({ label: "wait", text: event.prompt, tone: "muted" });
                     break;
+                  case "diagnostic": {
+                    if (event.code !== "tool_call_budget_exhausted") break;
+                    const limitKey = `limit-${event.workerId ?? "turn"}`;
+                    const meta2 = flockLimitMeta.get(limitKey) ?? { skipped: 0, tools: /* @__PURE__ */ new Set() };
+                    meta2.skipped += event.skippedCount ?? 0;
+                    for (const toolName of event.toolNames ?? []) meta2.tools.add(toolName);
+                    flockLimitMeta.set(limitKey, meta2);
+                    const who = event.workerId ? flockWorkerNames.get(event.workerId) ?? "A worker" : "The model";
+                    updateToolItem(limitKey, {
+                      label: "flock",
+                      text: `${who} hit its tool limit and is finishing from gathered evidence.`,
+                      tone: "muted",
+                      detailLines: [
+                        { tone: "meta", text: `cap tool-call budget \xB7 ${event.maxToolCalls ?? "?"} real calls allowed` },
+                        {
+                          tone: "meta",
+                          text: `skipped ${meta2.skipped} call(s)${meta2.tools.size ? `: ${[...meta2.tools].join(", ")}` : ""}`
+                        }
+                      ],
+                      expanded: false
+                    });
+                    break;
+                  }
                   case "flock_run_started":
                   case "flock_plan_ready":
                   case "flock_worker_update":
                   case "flock_run_completed": {
+                    if (event.type === "flock_plan_ready" && event.accepted) {
+                      for (const worker of event.workers) {
+                        flockWorkerNames.set(worker.workerId, worker.displayName);
+                      }
+                    } else if (event.type === "flock_worker_update") {
+                      flockWorkerNames.set(event.workerId, event.displayName);
+                    }
                     const row = flockEventToCliRow(event);
                     if (!row) break;
                     if (row.id) {
@@ -286102,6 +286328,43 @@ async function runInkInteractivePerchCli(writer, deps, options) {
             renderInkDetailContent(React11, Ink2, line)
           )
         );
+        const renderFlockRow = (key, line, tone, showLabel) => {
+          const dotParts = line.split(" \xB7 ");
+          const limitMatch = dotParts.length < 2 ? line.match(/^(.+?) (hit its tool limit .*)$/) : null;
+          if (dotParts.length < 2 && !limitMatch) {
+            return renderTranscriptRow(key, "flock", line, tone, showLabel);
+          }
+          if (limitMatch) {
+            return renderTranscriptRow(key, "flock", line, tone, showLabel);
+          }
+          const name = dotParts[0];
+          const nickname = dotParts[1] ?? "";
+          const restText = dotParts.length > 2 ? ` \xB7 ${dotParts.slice(2).join(" \xB7 ")}` : "";
+          return React11.createElement(
+            Ink2.Box,
+            { key },
+            React11.createElement(
+              Ink2.Box,
+              { width: INK_LABEL_WIDTH, flexShrink: 0 },
+              React11.createElement(
+                Ink2.Text,
+                { color: colorForInkTone(tone) },
+                showLabel ? renderInkSpeakerLabel("flock") : ""
+              )
+            ),
+            React11.createElement(
+              Ink2.Box,
+              { flexGrow: 1 },
+              React11.createElement(
+                Ink2.Text,
+                null,
+                React11.createElement(Ink2.Text, { color: bodyColorForInkTone(tone) }, `${name} \xB7 `),
+                React11.createElement(Ink2.Text, { color: flockNicknameAccentColor(nickname), bold: true }, nickname),
+                React11.createElement(Ink2.Text, { color: bodyColorForInkTone(tone) }, restText)
+              )
+            )
+          );
+        };
         const renderTranscriptItem = (item, index) => {
           const lines = item.text.split(/\r?\n/);
           const previous = items[index - 1];
@@ -286115,7 +286378,7 @@ async function runInkInteractivePerchCli(writer, deps, options) {
               React11.createElement(Ink2.Box, { width: INK_LABEL_WIDTH, flexShrink: 0 }),
               React11.createElement(Ink2.Text, { color: CLI_BRAND.divider }, INK_DIVIDER)
             ) : null,
-            lines.map((line, lineIndex) => renderTranscriptRow(
+            lines.map((line, lineIndex) => item.label === "flock" ? renderFlockRow(`${item.id}-${lineIndex}`, line, item.tone, lineIndex === 0) : renderTranscriptRow(
               `${item.id}-${lineIndex}`,
               item.label,
               line,
@@ -286851,6 +287114,13 @@ function colorForInkTone(tone) {
       return CLI_BRAND.patina;
   }
 }
+function flockNicknameAccentColor(name) {
+  let hash = 0;
+  for (let i = 0; i < name.length; i++) {
+    hash = hash * 31 + name.charCodeAt(i) >>> 0;
+  }
+  return FLOCK_NICKNAME_ACCENTS[hash % FLOCK_NICKNAME_ACCENTS.length];
+}
 function bodyColorForInkTone(tone) {
   switch (tone) {
     case "danger":
@@ -287533,7 +287803,7 @@ function defaultWriter() {
     stderr: (text) => process.stderr.write(text)
   };
 }
-var execFileAsync3, DEFAULT_CLI_LOGIN_APP_URL, CLI_PACKAGE_VERSION, CLI_BRAND, ANSI2, HELP_TEXT, INTERACTIVE_HELP_TEXT, FLOCK_STATUS_LABELS, INK_LABEL_WIDTH, INK_ROW_LIMIT, INK_DETAIL_LINE_LIMIT, INK_DIVIDER, PERCH_MOTION_FRAMES, PERCH_SPLASH_WIDTH, PERCH_SPLASH_SCENE, PERCH_SPLASH_COMMANDS;
+var execFileAsync3, DEFAULT_CLI_LOGIN_APP_URL, CLI_PACKAGE_VERSION, CLI_BRAND, ANSI2, HELP_TEXT, INTERACTIVE_HELP_TEXT, FLOCK_STATUS_LABELS, INK_LABEL_WIDTH, INK_ROW_LIMIT, INK_DETAIL_LINE_LIMIT, INK_DIVIDER, PERCH_MOTION_FRAMES, PERCH_SPLASH_WIDTH, PERCH_SPLASH_SCENE, PERCH_SPLASH_COMMANDS, FLOCK_NICKNAME_ACCENTS;
 var init_perch_cli = __esm({
   "scripts/perch-cli.ts"() {
     "use strict";
@@ -287669,6 +287939,11 @@ Commands:
       ["/permission", "change autonomy for the next turns"],
       ["/login", "connect your Perch account"]
     ];
+    FLOCK_NICKNAME_ACCENTS = [
+      CLI_BRAND.patinaActive,
+      CLI_BRAND.bronze,
+      CLI_BRAND.bronzeGlint
+    ];
     if (!process.env.PERCH_CLI_BUNDLE_ENTRY && process.argv[1] && import.meta.url === pathToFileURL(process.argv[1]).href) {
       runPerchCli(process.argv.slice(2)).then((code) => {
         process.exitCode = code;

package/package.json

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