@iowarp/clio-coder 0.4.2 → 0.4.4

package/dist/{chunk-UBRFI4HS.js → chunk-XULDXHTN.js}

@@ -4,16 +4,20 @@ import {
   TASK_MEMORY_POLICY_DEFAULT_TIMEOUT_MS,
   runTaskMemoryPolicy,
   taskMemoryBankDelta
-} from "./chunk-I66EAJFY.js";
+} from "./chunk-2WZ546HR.js";
 import {
   isTerminalRunEnvelope
-} from "./chunk-IKSLQ4XV.js";
+} from "./chunk-75W7L2E2.js";
+import {
+  hashToolCall
+} from "./chunk-6QOTUPRG.js";
 import {
   taskBoardCounts
-} from "./chunk-Q4XWMHX6.js";
+} from "./chunk-6PAZTBPA.js";
 import {
-  hashToolCall
-} from "./chunk-IDNA72AH.js";
+  legacyToolResultDigest,
+  sanitizeToolResultDigest
+} from "./chunk-NAI6ZFCY.js";
 import {
   SKILL_INSTALL_OFFER_OPTION_NEVER,
   SKILL_INSTALL_OFFER_OPTION_NOT_NOW,
@@ -21,36 +25,32 @@ import {
   SKILL_INSTALL_OFFER_OPTION_USER,
   SKILL_SUGGESTION_ANCHOR,
   SKILL_SUGGESTION_PREFIX
-} from "./chunk-FSP7CMNU.js";
-import {
-  legacyToolResultDigest,
-  sanitizeToolResultDigest
-} from "./chunk-B7HM5Z7T.js";
+} from "./chunk-54X7T7DK.js";
 import {
   ToolNames
-} from "./chunk-K6BSR66V.js";
+} from "./chunk-4NSRCOYP.js";
 import {
   registerForegroundStream
-} from "./chunk-BYMNWQ7O.js";
+} from "./chunk-JSD46VO2.js";
 import {
   ceilChars
-} from "./chunk-CWVRRIEI.js";
+} from "./chunk-NZMNUPZZ.js";
 import {
   BusChannels
 } from "./chunk-F4EKGO4N.js";
 import {
   reportCommitAttributionDiagnostic,
   withManagedGitCommitAttributionEnvironment
-} from "./chunk-JIEGK6UF.js";
+} from "./chunk-U6TMQNSI.js";
 import {
   require_dist
 } from "./chunk-APJ265NV.js";
-import {
-  clioConfigDir
-} from "./chunk-BYP5D4HI.js";
 import {
   safeResourceWrite
 } from "./chunk-WEPFGWHJ.js";
+import {
+  clioConfigDir
+} from "./chunk-BYP5D4HI.js";
 import {
   __toESM,
   init_esm_shims
@@ -970,8 +970,11 @@ function readPersistedHookReceipts(persistPath) {
 // src/domains/middleware/skills-reminder.ts
 init_esm_shims();
 var SKILLS_REMINDER_REGISTRATION_ID = "observer.skills-reminder";
-function skillsReminderMessage(installed, installable = 0) {
+function skillsReminderMessage(installed, installable = 0, modelActivation = false) {
   const counts = installable > 0 ? `${installed} installed, ${installable} installable from the marketplace` : `${installed} installed`;
+  if (modelActivation) {
+    return `[Skills] ${counts}. Start this task by listing them with context(scope="skills") and checking for a match; if one matches, load it with context(scope="skills", name="<name>") and continue the task in the same turn. A marketplace skill is not installed and is offered for install when the operator runs it. If none match, do not mention skills and continue with the task.`;
+  }
   return `[Skills] ${counts}. Start this task by listing them with context(scope="skills") and checking for a match; if one matches, open your reply with the line \`${SKILL_SUGGESTION_ANCHOR}\` (a comma-separated sequence, in order, when several compose) and then continue the task in the same turn without the skill. Only the operator loads a skill, and a marketplace skill is offered for install when the operator runs it. If none match, do not mention skills and continue with the task.`;
 }
 var NO_EFFECTS = [];
@@ -1070,7 +1073,18 @@ function createSkillsReminderRegistration(deps) {
         return NO_EFFECTS;
       }
       if (installed <= 0 && installable <= 0) return NO_EFFECTS;
-      return [{ kind: "inject_reminder", severity: "info", message: skillsReminderMessage(installed, installable) }];
+      let modelActivation = false;
+      try {
+        modelActivation = deps.modelMayActivateSkills?.() ?? false;
+      } catch {
+      }
+      return [
+        {
+          kind: "inject_reminder",
+          severity: "info",
+          message: skillsReminderMessage(installed, installable, modelActivation)
+        }
+      ];
     }
   };
 }
@@ -1203,11 +1217,11 @@ var NO_EFFECTS2 = [];
 function offerBindingTag(offerTag) {
   return `[clio-install:${offerTag}]`;
 }
-function marketplaceOfferReminder(entry, offerTag) {
-  return `[Marketplace] This request may need expertise no installed skill covers. The local marketplace has "${entry.name}" (not installed): ${entry.description} First check the installed side with context(scope="skills"); if ${entry.name} is genuinely the right fit and nothing installed serves, ask the operator with ask_user (mode=single_question, header "Install skill") whether to install ${entry.name}, offering exactly these options in this order: "${SKILL_INSTALL_OFFER_OPTION_PROJECT}", "${SKILL_INSTALL_OFFER_OPTION_USER}", "${SKILL_INSTALL_OFFER_OPTION_NOT_NOW}", "${SKILL_INSTALL_OFFER_OPTION_NEVER}". Include the exact tag ${offerBindingTag(offerTag)} verbatim in that question's text so the harness can bind the answer to this offer; the harness acts only on an answer carrying this tag. Then continue the task in the same turn. The harness handles the answer; never install or load a skill yourself. If it is not actually needed, do not mention it.`;
+function boundedDescription(text) {
+  return text.replace(/\[[^[\]]*\]/gu, " ").replace(/\s+/gu, " ").trim().slice(0, 200);
 }
-function marketplaceAutoInstallReminder(entry, result) {
-  return `[Marketplace] Installed skill "${entry.name}" from Clio's own local marketplace (full-auto) to ${result.path}. Source ${result.sourceUrl}, sha256 ${result.installedHash}. ${entry.description} It is installed but not active \u2014 activation stays operator-gated. If it fits this task, suggest /skill ${entry.name} to the operator; never load it yourself.`;
+function marketplaceOfferReminder(entry, offerTag) {
+  return `[Marketplace] This request may need expertise no installed skill covers. The local marketplace has "${entry.name}" (not installed): ${boundedDescription(entry.description)} First check the installed side with context(scope="skills"); if ${entry.name} is genuinely the right fit and nothing installed serves, ask the operator with ask_user (mode=single_question, header "Install skill") whether to install ${entry.name}, offering exactly these options in this order: "${SKILL_INSTALL_OFFER_OPTION_PROJECT}", "${SKILL_INSTALL_OFFER_OPTION_USER}", "${SKILL_INSTALL_OFFER_OPTION_NOT_NOW}", "${SKILL_INSTALL_OFFER_OPTION_NEVER}". Include the exact tag ${offerBindingTag(offerTag)} verbatim in that question's text so the harness can bind the answer to this offer; the harness acts only on an answer carrying this tag. Then continue the task in the same turn. The harness handles the answer; never install or load a skill yourself. If it is not actually needed, do not mention it.`;
 }
 function answersFromDetails(details) {
   const raw = details?.answers;
@@ -1355,18 +1369,14 @@ function createMarketplaceOfferRegistration(deps) {
       const match = bestMatch(input.text ?? "");
       if (!match) return NO_EFFECTS2;
       offeredNames.add(match.entry.name);
-      if (deps.getAutonomy() === "full-auto") {
-        try {
-          const result = installGated(match.entry, "project");
-          return [
-            {
-              kind: "inject_reminder",
-              severity: "info",
-              message: marketplaceAutoInstallReminder(match.entry, result)
-            }
-          ];
-        } catch {
-        }
+      if (deps.interactive === false) {
+        return [
+          {
+            kind: "inject_reminder",
+            severity: "info",
+            message: `[Marketplace] Skill "${match.entry.name}" matches this request; install with clio-coder skills install ${match.entry.name}.`
+          }
+        ];
       }
       const tag = newOfferTag();
       pendingOffer = { entry: match.entry, tag };
@@ -1387,6 +1397,10 @@ var MEMORY_INTERVENTION_ACTIVITY_LIMIT = 20;
 var CALL_DESCRIPTION_MAX_CHARS = 180;
 var NO_EFFECTS3 = [];
 function createMemoryInterventionRegistration(deps) {
+  let generation = 0;
+  let generationController = new AbortController();
+  let observedSessionId;
+  let disposed = false;
   const pending = /* @__PURE__ */ new Map();
   const trajectory = [];
   const failures = /* @__PURE__ */ new Map();
@@ -1411,11 +1425,17 @@ function createMemoryInterventionRegistration(deps) {
   let annotatedSinceTurnEnd = false;
   let consecutiveLlmTimeouts = 0;
   return {
+    reset,
+    dispose() {
+      disposed = true;
+      reset();
+    },
     id: MEMORY_INTERVENTION_REGISTRATION_ID,
     description: "maintain bounded task execution memory and selectively remind after repeated failures or compaction",
     hooks: ["before_tool", "after_tool", "turn_start", "turn_end", "on_compaction"],
     evaluate(input) {
-      if (!settings().enabled) return NO_EFFECTS3;
+      observeSession(input);
+      if (disposed || !settings().enabled) return NO_EFFECTS3;
       try {
         switch (input.hook) {
           case "before_tool":
@@ -1482,7 +1502,8 @@ function createMemoryInterventionRegistration(deps) {
      * would have been buffered anyway.
      */
     async evaluateAsync(input, context) {
-      if (!settings().enabled || input.hook !== "turn_end" || pendingTriggers.size === 0) return NO_EFFECTS3;
+      observeSession(input);
+      if (disposed || !settings().enabled || input.hook !== "turn_end" || pendingTriggers.size === 0) return NO_EFFECTS3;
       const boundary = input.turnId ?? input.metadata?.userTurnId?.toString() ?? `tool-step:${toolStep}`;
       if (boundary === lastPromptedBoundary) return NO_EFFECTS3;
       if (deps.deliversDeferredReminders === false) {
@@ -1512,31 +1533,68 @@ function createMemoryInterventionRegistration(deps) {
         (effect) => effect.kind === "inject_reminder" && effect.message.startsWith("Memory:")
       ) ?? false);
       rulesInjectedSincePromptedStep = false;
+      const stepGeneration = generation;
       promptedStepInFlight = true;
       outstandingStep = runPromptedStep({
         deterministicTrigger: triggers.some((trigger) => trigger !== "interval"),
         suppressIntervention: rulesAlreadySpoke,
         triggerReasons: triggers
       }).then((result) => {
+        if (stepGeneration !== generation || disposed) return;
         if (rulesAlreadySpoke && result.decision === "silent") lastDecision = "injected";
         if (result.reminder === null) return;
         lastInjectedMessage = result.reminder;
         deps.onDeferredReminder?.(result.reminder);
       }).catch(() => {
       }).finally(() => {
-        promptedStepInFlight = false;
+        if (stepGeneration === generation) promptedStepInFlight = false;
       });
       return NO_EFFECTS3;
     },
     runPromptedStep,
     signalLoop() {
-      if (settings().enabled) pendingTriggers.add("loop_signal");
+      if (!disposed && settings().enabled) pendingTriggers.add("loop_signal");
     },
     lastDecision: () => lastDecision,
     recentActivity: () => [...activity],
     stepInFlight: () => promptedStepInFlight,
     whenIdle: () => outstandingStep
   };
+  function observeSession(input) {
+    if (input.sessionId === void 0) return;
+    if (observedSessionId !== void 0 && observedSessionId !== input.sessionId) reset();
+    observedSessionId = input.sessionId;
+  }
+  function reset() {
+    generation += 1;
+    generationController.abort();
+    generationController = new AbortController();
+    deps.bank.clear();
+    pending.clear();
+    trajectory.length = 0;
+    failures.clear();
+    toolStep = 0;
+    lastTurnEndStep = 0;
+    reactivateAfterCompaction = false;
+    lastInjectedOperationFingerprint = null;
+    currentTask = "(current task unavailable)";
+    toolsSinceMemoryStep = 0;
+    consecutiveErrors = 0;
+    lastPromptedBoundary = null;
+    lastInjectedMessage = null;
+    lastDecision = null;
+    pendingTriggers.clear();
+    activity.length = 0;
+    annotatedThisTurn.clear();
+    telemetryBankSnapshot = deps.bank.snapshot();
+    promptedStepInFlight = false;
+    promptedStepTier = "rules";
+    outstandingStep = Promise.resolve();
+    rulesInjectedSincePromptedStep = false;
+    annotatedSinceTurnEnd = false;
+    consecutiveLlmTimeouts = 0;
+    observedSessionId = void 0;
+  }
   function settings() {
     const live = deps.getSettings?.();
     return {
@@ -1563,12 +1621,16 @@ function createMemoryInterventionRegistration(deps) {
       effects: NO_EFFECTS3
     });
     const live = settings();
-    if (!live.enabled) {
+    const stepGeneration = generation;
+    const isCurrent = () => !disposed && stepGeneration === generation;
+    const usageSink = deps.captureStepUsage?.();
+    if (disposed || !live.enabled) {
       const result = silent("no_client");
       lastDecision = result.decision;
       return result;
     }
     const started = process.hrtime.bigint();
+    let attemptStarted = started;
     const triggers = input.triggerReasons?.length ? input.triggerReasons : ["manual"];
     let tier = "rules";
     promptedStepTier = tier;
@@ -1589,7 +1651,13 @@ function createMemoryInterventionRegistration(deps) {
         } else {
           tier = "llm";
           promptedStepTier = tier;
-          promptedResult = await runTaskMemoryPolicy(deps.bank, client, {
+          const runClient = (selected, timeoutMs) => runTaskMemoryPolicy(deps.bank, selected, {
+            isCurrent,
+            signal: generationController.signal,
+            onStepUsage: (usage) => {
+              if (usageSink) usageSink(usage, isCurrent());
+              else deps.onStepUsage?.(usage);
+            },
             task: input.task?.trim() || currentTask,
             trajectory: [...trajectory],
             deterministicTrigger: input.deterministicTrigger,
@@ -1597,9 +1665,37 @@ function createMemoryInterventionRegistration(deps) {
             modelMaxTokens: positiveInteger(deps.getModelMaxTokens?.(live.maxTokens), live.maxTokens),
             ...input.suppressIntervention === void 0 ? {} : { suppressIntervention: input.suppressIntervention },
             previousReminder: lastInjectedMessage,
-            timeoutMs: live.timeoutMs,
+            timeoutMs,
             ...deps.onEnvelope === void 0 ? {} : { onEnvelope: deps.onEnvelope }
           });
+          const remainingMs = () => Math.floor(live.timeoutMs - Number(process.hrtime.bigint() - started) / 1e6);
+          const initialTimeoutMs = remainingMs();
+          promptedResult = initialTimeoutMs <= 0 ? { ...silent("deadline"), decision: "timeout" } : await runClient(client, initialTimeoutMs);
+          if (promptedResult.reason === "client_error" && isCurrent() && remainingMs() > 0) {
+            let fallback = null;
+            let fallbackReady = false;
+            try {
+              fallback = deps.getFallbackModelClient?.() ?? null;
+              fallbackReady = fallback !== null && deps.backgroundEndpointBusy?.() !== true;
+            } catch {
+            }
+            const fallbackTimeoutMs = remainingMs();
+            if (fallback !== null && fallbackReady && isCurrent() && fallbackTimeoutMs > 0) {
+              emitTelemetry(
+                triggers,
+                tier,
+                promptedResult.decision,
+                promptedResult.reason,
+                0,
+                promptedResult.inputTokens,
+                promptedResult.outputTokens,
+                started,
+                { bankOperations: promptedResult.bankOperations, droppedOperations: promptedResult.droppedOperations }
+              );
+              attemptStarted = process.hrtime.bigint();
+              promptedResult = await runClient(fallback, fallbackTimeoutMs);
+            }
+          }
         }
       }
     } catch (error) {
@@ -1616,15 +1712,11 @@ function createMemoryInterventionRegistration(deps) {
         error: error instanceof Error ? error.message : "resolving the background model client failed"
       });
     }
+    if (!isCurrent()) return { ...promptedResult, reminder: null, effects: NO_EFFECTS3 };
+    if (promptedResult.reason === "endpoint_busy") telemetryDecision = "dropped";
     if (tier === "llm" && promptedResult.decision === "timeout") consecutiveLlmTimeouts += 1;
     else if (tier === "llm" && telemetryDecision !== "dropped") consecutiveLlmTimeouts = 0;
     lastDecision = promptedResult.decision;
-    if (promptedResult.usage !== null) {
-      try {
-        deps.onStepUsage?.(promptedResult.usage);
-      } catch {
-      }
-    }
     if (promptedResult.decision === "injected") reportInjectedEntries(promptedResult.reminder);
     emitTelemetry(
       triggers,
@@ -1634,7 +1726,7 @@ function createMemoryInterventionRegistration(deps) {
       citedEntryCount(promptedResult.reminder),
       promptedResult.inputTokens,
       promptedResult.outputTokens,
-      started,
+      attemptStarted,
       { bankOperations: promptedResult.bankOperations, droppedOperations: promptedResult.droppedOperations }
     );
     return {
@@ -3004,4 +3096,4 @@ export {
   createWatchdogRegistration,
   MiddlewareDomainModule
 };
-//# sourceMappingURL=chunk-UBRFI4HS.js.map
+//# sourceMappingURL=chunk-XULDXHTN.js.map

package/dist/chunk-XXYSBZIQ.js

@@ -0,0 +1,283 @@
+import { createRequire as __clioCreateRequire } from "node:module"; const require = __clioCreateRequire(import.meta.url);
+import {
+  WORKER_OUTPUT_MAX_BYTES,
+  durableAssistantTextFromEvent
+} from "./chunk-I2DWJ4GM.js";
+import {
+  truncateUtf8
+} from "./chunk-6XLNIQDB.js";
+import {
+  init_esm_shims
+} from "./chunk-3R73A4XB.js";
+
+// src/domains/observability/worker-progress.ts
+init_esm_shims();
+var WORKER_LIVE_TAIL_LINES = 40;
+var WORKER_LIVE_TAIL_MAX_BYTES = 4096;
+var WORKER_TOOL_NAME_LIMIT = 8;
+var WORKER_ACTION_TRAIL_LIMIT = 4;
+var WORKER_PROGRESS_WINDOW_MS = 250;
+var WORKER_PROGRESS_WINDOW_BYTES = 16384;
+var TAIL_TRUNCATION_MARKER = "";
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value.trim().length > 0 ? value : void 0;
+}
+function workerTextDelta(event) {
+  if (!isRecord(event)) return "";
+  if (event.type === "message_update") {
+    const assistantEvent = isRecord(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
+    if (assistantEvent?.type !== "text_delta") return "";
+    return typeof assistantEvent.delta === "string" ? assistantEvent.delta : "";
+  }
+  if (event.type !== "text_delta") return "";
+  if (typeof event.delta === "string") return event.delta;
+  return typeof event.text === "string" ? event.text : "";
+}
+function isThinkingEvent(event) {
+  if (event.type === "thinking_delta") return true;
+  if (event.type !== "message_update") return false;
+  const assistantEvent = isRecord(event.assistantMessageEvent) ? event.assistantMessageEvent : null;
+  return assistantEvent?.type === "thinking_delta";
+}
+function toolEventAction(event) {
+  if (event.type !== "clio_coder_tool_start" && event.type !== "clio_coder_tool_finish") return null;
+  const payload = isRecord(event.payload) ? event.payload : null;
+  const tool = nonEmptyString(payload?.tool);
+  if (tool === void 0) return null;
+  const toolCallId = nonEmptyString(payload?.toolCallId);
+  const raw = isRecord(payload?.action) ? payload.action : void 0;
+  const verb = nonEmptyString(raw?.verb);
+  if (verb === void 0) return { tool, ...toolCallId !== void 0 ? { toolCallId } : {} };
+  const object = nonEmptyString(raw?.object);
+  return {
+    tool,
+    ...toolCallId !== void 0 ? { toolCallId } : {},
+    descriptor: {
+      verb,
+      ...object !== void 0 ? { object } : {},
+      ...raw?.truncated === true ? { truncated: true } : {}
+    }
+  };
+}
+function lineCount(text) {
+  if (text.length === 0) return 0;
+  let lines = 1;
+  for (let index = 0; index < text.length; index += 1) {
+    if (text[index] === "\n") lines += 1;
+  }
+  return lines;
+}
+function keepTailBytes(text, maxBytes) {
+  const buffer = Buffer.from(text, "utf8");
+  if (buffer.byteLength <= maxBytes) return text;
+  let cut = buffer.byteLength - maxBytes;
+  while (cut < buffer.byteLength) {
+    const byte = buffer[cut];
+    if (byte === void 0 || (byte & 192) !== 128) break;
+    cut += 1;
+  }
+  return buffer.subarray(cut).toString("utf8");
+}
+function boundLiveTail(text) {
+  const lines = text.split("\n");
+  let droppedLines = 0;
+  if (lines.length > WORKER_LIVE_TAIL_LINES) {
+    droppedLines = lines.length - WORKER_LIVE_TAIL_LINES;
+    lines.splice(0, droppedLines);
+  }
+  while (lines.length > 1 && Buffer.byteLength(lines.join("\n"), "utf8") > WORKER_LIVE_TAIL_MAX_BYTES) {
+    lines.shift();
+    droppedLines += 1;
+  }
+  const joined = lines.join("\n");
+  const bytes = Buffer.byteLength(joined, "utf8");
+  if (bytes <= WORKER_LIVE_TAIL_MAX_BYTES) return { text: joined, droppedLines, droppedBytes: 0 };
+  const kept = keepTailBytes(joined, WORKER_LIVE_TAIL_MAX_BYTES);
+  return { text: kept, droppedLines, droppedBytes: bytes - Buffer.byteLength(kept, "utf8") };
+}
+function boundSettledText(text) {
+  const bounded = truncateUtf8(text, WORKER_OUTPUT_MAX_BYTES, TAIL_TRUNCATION_MARKER);
+  if (bounded === text) return { text, dropped: 0 };
+  return { text: bounded, dropped: Math.max(0, lineCount(text) - lineCount(bounded)) };
+}
+var EMPTY_SNAPSHOT = {
+  revision: 0,
+  phase: "starting",
+  tailText: "",
+  droppedLines: 0,
+  droppedBytes: 0,
+  currentAction: null,
+  recentActions: [],
+  toolNames: [],
+  settled: false
+};
+function createWorkerProgressFold() {
+  let revision = 0;
+  let phase = "starting";
+  let tailText = "";
+  let droppedLines = 0;
+  let droppedBytes = 0;
+  let currentAction = null;
+  const recentActions = [];
+  const toolNames = [];
+  let settled = false;
+  let durable = "";
+  let betweenAssistantMessages = false;
+  const pendingActions = [];
+  const pendingActionsById = /* @__PURE__ */ new Map();
+  let windowStartMs = 0;
+  let windowBytes = 0;
+  let cached = EMPTY_SNAPSHOT;
+  const touch = () => {
+    revision += 1;
+    cached = null;
+    return true;
+  };
+  const setPhase = (next) => {
+    if (phase === next) return false;
+    phase = next;
+    return touch();
+  };
+  const admitDelta = (delta, nowMs) => {
+    if (nowMs - windowStartMs >= WORKER_PROGRESS_WINDOW_MS) {
+      windowStartMs = nowMs;
+      windowBytes = 0;
+    }
+    const bytes = Buffer.byteLength(delta, "utf8");
+    if (windowBytes + bytes <= WORKER_PROGRESS_WINDOW_BYTES) {
+      windowBytes += bytes;
+      return delta;
+    }
+    windowBytes = WORKER_PROGRESS_WINDOW_BYTES;
+    droppedBytes += bytes;
+    return "";
+  };
+  const appendTail = (text) => {
+    if (text.length === 0) return false;
+    const bounded = boundLiveTail(tailText + text);
+    tailText = bounded.text;
+    droppedLines += bounded.droppedLines;
+    droppedBytes += bounded.droppedBytes;
+    return touch();
+  };
+  const noteToolName = (tool) => {
+    if (toolNames.includes(tool) || toolNames.length >= WORKER_TOOL_NAME_LIMIT) return false;
+    toolNames.push(tool);
+    return touch();
+  };
+  const removePendingAction = (action) => {
+    const index = pendingActions.lastIndexOf(action);
+    if (index >= 0) pendingActions.splice(index, 1);
+    if (action.toolCallId !== void 0 && pendingActionsById.get(action.toolCallId) === action) {
+      pendingActionsById.delete(action.toolCallId);
+    }
+  };
+  const lastPendingActionForTool = (tool) => {
+    for (let index = pendingActions.length - 1; index >= 0; index -= 1) {
+      const candidate = pendingActions[index];
+      if (candidate?.tool === tool) return candidate;
+    }
+    return void 0;
+  };
+  return {
+    observe(event, nowMs = Date.now()) {
+      if (!isRecord(event) || settled) return false;
+      let changed = false;
+      const delta = workerTextDelta(event);
+      if (delta.length > 0) {
+        const separator = betweenAssistantMessages && tailText.length > 0 && !tailText.endsWith("\n") ? "\n\n" : "";
+        betweenAssistantMessages = false;
+        changed = appendTail(admitDelta(`${separator}${delta}`, nowMs)) || changed;
+        changed = setPhase("writing") || changed;
+      } else if (isThinkingEvent(event)) {
+        changed = setPhase("thinking") || changed;
+      }
+      const durableText = durableAssistantTextFromEvent(event);
+      if (durableText.trim().length > 0) {
+        durable = durableText;
+        if (delta.length === 0 && tailText.trim().length === 0) {
+          changed = appendTail(durableText) || changed;
+        }
+        betweenAssistantMessages = true;
+      }
+      const action = toolEventAction(event);
+      if (action !== null && event.type === "clio_coder_tool_start") {
+        if (action.toolCallId !== void 0) {
+          const duplicate = pendingActionsById.get(action.toolCallId);
+          if (duplicate !== void 0) removePendingAction(duplicate);
+          pendingActionsById.set(action.toolCallId, action);
+        }
+        pendingActions.push(action);
+        currentAction = action;
+        noteToolName(action.tool);
+        touch();
+        setPhase("tool");
+        changed = true;
+      } else if (action !== null && event.type === "clio_coder_tool_finish") {
+        const finished = (action.toolCallId !== void 0 ? pendingActionsById.get(action.toolCallId) : void 0) ?? lastPendingActionForTool(action.tool) ?? action;
+        removePendingAction(finished);
+        currentAction = pendingActions[pendingActions.length - 1] ?? null;
+        recentActions.unshift(finished);
+        if (recentActions.length > WORKER_ACTION_TRAIL_LIMIT) recentActions.length = WORKER_ACTION_TRAIL_LIMIT;
+        noteToolName(finished.tool);
+        touch();
+        setPhase(currentAction === null ? "waiting" : "tool");
+        changed = true;
+      }
+      if (event.type === "agent_start") changed = setPhase("starting") || changed;
+      return changed;
+    },
+    settle(text) {
+      const sealed = nonEmptyString(text) ?? nonEmptyString(durable);
+      if (sealed !== void 0) {
+        const bounded = boundSettledText(sealed);
+        tailText = bounded.text;
+        droppedLines = bounded.dropped;
+      }
+      currentAction = null;
+      pendingActions.length = 0;
+      pendingActionsById.clear();
+      settled = true;
+      phase = "settled";
+      touch();
+      return true;
+    },
+    restart() {
+      currentAction = null;
+      pendingActions.length = 0;
+      pendingActionsById.clear();
+      durable = "";
+      betweenAssistantMessages = false;
+      settled = false;
+      phase = "starting";
+      touch();
+    },
+    snapshot() {
+      if (cached !== null) return cached;
+      cached = {
+        revision,
+        phase,
+        tailText,
+        droppedLines,
+        droppedBytes,
+        currentAction: currentAction === null ? null : { ...currentAction },
+        recentActions: recentActions.map((entry) => ({ ...entry })),
+        toolNames: [...toolNames],
+        settled
+      };
+      return cached;
+    },
+    durableText() {
+      return durable;
+    }
+  };
+}
+
+export {
+  boundSettledText,
+  createWorkerProgressFold
+};
+//# sourceMappingURL=chunk-XXYSBZIQ.js.map