@linghun/tui 0.1.1 → 0.1.3

package/dist/{chunk-6RJVTUWI.js → chunk-T6UOCF5D.js}

@@ -1,3 +1,7 @@
+import {
+  fitText
+} from "./chunk-GTIZNO5O.js";
+
 // src/shell/components/StatusTray.tsx
 import { Box, Text } from "@linghun/ink-runtime";
 import { jsx } from "react/jsx-runtime";
@@ -8,7 +12,7 @@ function StatusTray({
 }) {
   const items = [status.project, status.model, status.permission, status.index, status.background];
   const visible = width < 60 ? [items[0], items[1], items[2], items[4]] : items;
-  return /* @__PURE__ */ jsx(Box, { marginTop: 0, marginBottom: 0, children: /* @__PURE__ */ jsx(Text, { color: theme.subtle ?? theme.muted, children: visible.join("  ") }) });
+  return /* @__PURE__ */ jsx(Box, { marginTop: 0, marginBottom: 0, children: /* @__PURE__ */ jsx(Text, { color: theme.subtle ?? theme.muted, children: fitText(visible.join("  "), Math.max(8, width - 2)) }) });
 }
 
 export {

package/dist/{chunk-P277M7Z5.js → chunk-TO6IN4LA.js}

@@ -4,7 +4,7 @@ import {
   extractStructuredFinalAnswerClaims,
   finalAnswerHasCompletenessClassification,
   hasArchitectureEvidenceForClaims
-} from "./chunk-K56D3X7S.js";
+} from "./chunk-NWZ44SFI.js";
 import {
   detectArchitectureDrift
 } from "./chunk-MVONSJEN.js";
@@ -170,17 +170,44 @@ function isBetaVerdictEvidence(item) {
   ) || hasReportWriteEvidence([item]);
 }
 function checkClaimSupport(claim, context) {
+  const headlessRisk = createHeadlessBenchDiagnosticRiskSummary(context);
+  const validationContractRisk = createHeadlessBenchValidationContractRiskSummary(context);
   const structuredClaims = extractStructuredFinalAnswerClaims(claim);
   if (structuredClaims.some((item) => item.kind === "beta_readiness")) {
     return {
       status: "needs_disclaimer",
-      unsupportedClaims: structuredClaims.filter((item) => item.kind === "beta_readiness").map((item) => item.phrase),
+      unsupportedClaims: [
+        ...structuredClaims.filter((item) => item.kind === "beta_readiness").map((item) => item.phrase),
+        ...validationContractRisk ? [validationContractRisk] : [],
+        ...headlessRisk ? [headlessRisk] : []
+      ],
       verdict: createPhase15BetaVerdictScope(context.evidence)
     };
   }
   if (structuredClaims.length === 0) {
     const nlCheck = detectNaturalLanguageHighRiskClaims(claim);
-    if (nlCheck.status !== "passed") return nlCheck;
+    if (nlCheck.status !== "passed") {
+      return {
+        ...nlCheck,
+        unsupportedClaims: [
+          ...nlCheck.unsupportedClaims,
+          ...validationContractRisk ? [validationContractRisk] : [],
+          ...headlessRisk ? [headlessRisk] : []
+        ]
+      };
+    }
+    if (validationContractRisk) {
+      return {
+        status: "needs_disclaimer",
+        unsupportedClaims: [validationContractRisk]
+      };
+    }
+    if (headlessRisk) {
+      return {
+        status: "needs_disclaimer",
+        unsupportedClaims: [headlessRisk]
+      };
+    }
     return { status: "passed", unsupportedClaims: [] };
   }
   if (structuredClaims.some(
@@ -190,19 +217,187 @@ function checkClaimSupport(claim, context) {
     if (extended.status === "needs_disclaimer") {
       return {
         status: "needs_disclaimer",
-        unsupportedClaims: extended.verdict.matchedClaims.map((item) => item.phrase)
+        unsupportedClaims: [
+          ...extended.verdict.matchedClaims.map((item) => item.phrase),
+          ...validationContractRisk ? [validationContractRisk] : [],
+          ...headlessRisk ? [headlessRisk] : []
+        ]
       };
     }
   }
   const verdict = evaluateFinalAnswerClaims(claim, context.evidence);
   if (verdict.status === "passed") {
+    if (validationContractRisk) {
+      return {
+        status: "needs_disclaimer",
+        unsupportedClaims: [validationContractRisk]
+      };
+    }
+    if (headlessRisk) {
+      return {
+        status: "needs_disclaimer",
+        unsupportedClaims: [headlessRisk]
+      };
+    }
     return { status: "passed", unsupportedClaims: [] };
   }
   return {
     status: "needs_disclaimer",
-    unsupportedClaims: structuredClaims.map((item) => item.phrase)
+    unsupportedClaims: [
+      ...structuredClaims.map((item) => item.phrase),
+      ...validationContractRisk ? [validationContractRisk] : [],
+      ...headlessRisk ? [headlessRisk] : []
+    ]
   };
 }
+function createHeadlessBenchValidationContractRiskSummary(context) {
+  const tools = context.tools;
+  if (tools.headlessBench?.enabled !== true) return void 0;
+  const items = tools.validationContract?.items ?? [];
+  if (items.length === 0) return void 0;
+  const risks = items.map((item) => summarizeValidationContractItemRisk(item, context.evidence)).filter((risk) => Boolean(risk));
+  if (risks.length === 0) return void 0;
+  return `validation contract needs validation: ${risks.slice(0, 4).join("; ")}`;
+}
+function summarizeValidationContractItemRisk(item, evidence) {
+  const matching = collectMatchingValidationEvidence(item, evidence);
+  if (matching.some((entry) => entry.ok === true)) {
+    if (item.kind === "service" && item.validation === "semantic" && !hasSemanticServiceEvidence(item, matching, evidence)) {
+      const subject2 = item.path ?? item.target ?? item.id;
+      return `${item.kind} ${subject2} missing semantic response probe evidence; status/readiness alone is not enough`;
+    }
+    return void 0;
+  }
+  const subject = item.path ?? item.target ?? item.id;
+  if (matching.some((entry) => entry.ok === false)) {
+    return `${item.kind} ${subject} failed explicit ${item.requiredTool}; needs_repair before final`;
+  }
+  return `${item.kind} ${subject} missing explicit ${item.requiredTool}`;
+}
+function collectMatchingValidationEvidence(item, evidence) {
+  return evidence.flatMap((record) => readValidationEvidence(record)).filter(
+    (entry) => entry.kind === item.kind && entry.tool === item.requiredTool && validationEvidenceSubjectMatches(item, entry)
+  );
+}
+function readValidationEvidence(evidence) {
+  if (!evidence.data || typeof evidence.data !== "object") return [];
+  const value = evidence.data.validationEvidence;
+  if (!Array.isArray(value)) return [];
+  return value.map((entry) => entry && typeof entry === "object" ? entry : void 0).filter((entry) => Boolean(entry));
+}
+function validationEvidenceSubjectMatches(item, evidence) {
+  if (item.path) return validationPathsMatch(evidence.path, item.path);
+  if (item.target) return normalizeValidationTarget(evidence.target) === normalizeValidationTarget(item.target);
+  return false;
+}
+function validationPathsMatch(evidencePath, contractPath) {
+  const evidence = normalizeValidationPath(evidencePath);
+  const contract = normalizeValidationPath(contractPath);
+  if (!evidence || !contract) return false;
+  if (evidence === contract) return true;
+  return stripKnownWorkspaceRoot(evidence) === stripKnownWorkspaceRoot(contract);
+}
+function stripKnownWorkspaceRoot(path) {
+  for (const prefix of ["/app/", "/workspace/"]) {
+    if (path.startsWith(prefix)) return path.slice(prefix.length);
+  }
+  return path;
+}
+function normalizeValidationPath(path) {
+  if (!path) return void 0;
+  return path.replace(/\\/gu, "/").replace(/\/$/u, "");
+}
+function normalizeValidationTarget(target) {
+  if (!target) return void 0;
+  try {
+    const url = target.startsWith("http://") || target.startsWith("https://") ? new URL(target) : new URL(`http://${target}`);
+    const port = url.port || (url.protocol === "https:" ? "443" : "80");
+    const path = target.startsWith("http://") || target.startsWith("https://") ? url.pathname.replace(/\/$/u, "") : "";
+    return `${url.hostname}:${port}${path}`;
+  } catch {
+    return target.replace(/\/$/u, "");
+  }
+}
+function hasSemanticServiceEvidence(item, matching, evidence) {
+  const tokens = item.semanticTokens ?? [];
+  if (matching.some((entry) => serviceFetchEvidenceHasSemanticChecks(entry, tokens))) return true;
+  return evidence.some((record) => commandOrVerificationEvidenceHasSemanticProbe(record, tokens));
+}
+function serviceFetchEvidenceHasSemanticChecks(entry, tokens) {
+  if (entry.ok !== true) return false;
+  const fetch = readRecord(entry.checks?.fetch);
+  const bodyContains = readStringList(fetch?.bodyContains);
+  if (bodyContains.length === 0) return false;
+  if (tokens.length === 0) return true;
+  const haystack = bodyContains.join("\n").toLowerCase();
+  return tokens.some((token) => haystack.includes(token.toLowerCase()));
+}
+function commandOrVerificationEvidenceHasSemanticProbe(record, tokens) {
+  if (record.kind === "test_result" && record.supportsClaims.includes("verification_passed")) return true;
+  if (record.kind !== "command_output") return false;
+  if (!record.supportsClaims.includes("bash_exit_0")) return false;
+  const semanticProbe = readRecord(readEvidenceDataRecord(record, "semanticProbe"));
+  const semanticProbeTokens = readStringList(semanticProbe?.tokens);
+  const haystack = `${record.summary}
+${record.source}
+${semanticProbeTokens.join("\n")}`.toLowerCase();
+  const matchedTokens = tokens.filter((token) => haystack.includes(token.toLowerCase()));
+  return matchedTokens.length >= Math.min(2, tokens.length);
+}
+function readRecord(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function readStringList(value) {
+  if (typeof value === "string" && value.trim()) return [value];
+  if (!Array.isArray(value)) return [];
+  return value.filter((item) => typeof item === "string" && item.trim().length > 0);
+}
+function createHeadlessBenchDiagnosticRiskSummary(context) {
+  const tools = context.tools;
+  if (tools.headlessBench?.enabled !== true) return void 0;
+  const risky = (tools.recentDiagnostics ?? []).slice(0, 10).filter(
+    (diagnostic) => (diagnostic.severity === "recoverable" || diagnostic.severity === "blocking") && (diagnostic.type === "service_readiness" || diagnostic.type === "artifact_preservation" || diagnostic.type === "binary_tool_missing" || diagnostic.type === "missing_command" || diagnostic.type === "timeout" || diagnostic.type === "provider_or_network") && !isDiagnosticRiskResolved(diagnostic, context.evidence)
+  );
+  if (risky.length === 0) return void 0;
+  return `headless bench risk: ${risky.slice(0, 3).map((diagnostic) => `${diagnostic.type}: ${diagnostic.evidence ?? ""}`.trim()).join("; ")}`;
+}
+function isDiagnosticRiskResolved(diagnostic, evidence) {
+  if (diagnostic.type === "service_readiness" || diagnostic.type === "timeout") {
+    const target = readDiagnosticServiceTarget(diagnostic);
+    if (!target) return false;
+    return evidence.some((item) => {
+      const serviceHint = readEvidenceDataRecord(item, "serviceHint");
+      const service = readEvidenceDataRecord(item, "service");
+      return serviceHint?.ready === true && serviceHint.target === target || service?.ready === true && service.target === target;
+    });
+  }
+  if (diagnostic.type === "artifact_preservation") {
+    if (!diagnostic.path) return false;
+    return evidence.some((item) => {
+      const artifactHint = readEvidenceDataRecord(item, "artifactHint");
+      return artifactHint?.exists === true && artifactHint.path === diagnostic.path;
+    });
+  }
+  if (diagnostic.type === "binary_tool_missing") {
+    if (!diagnostic.path) return false;
+    return evidence.some(
+      (item) => readEvidenceDataRecord(item, "binaryHint")?.path === diagnostic.path || readEvidenceDataRecord(item, "binaryPreflight")?.path === diagnostic.path
+    );
+  }
+  return false;
+}
+function readDiagnosticServiceTarget(diagnostic) {
+  if (diagnostic.target) return diagnostic.target;
+  if (diagnostic.targetHost && diagnostic.targetPort !== void 0) {
+    return `${diagnostic.targetHost}:${diagnostic.targetPort}`;
+  }
+  return void 0;
+}
+function readEvidenceDataRecord(evidence, key) {
+  if (!evidence.data || typeof evidence.data !== "object") return void 0;
+  const value = evidence.data[key];
+  return value && typeof value === "object" ? value : void 0;
+}
 var HIGH_RISK_NL_CLAIM_PATTERNS = [
   // ── Chinese patterns（无 \b，CJK 字符无需 ASCII 单词边界）──
   {
@@ -299,5 +494,6 @@ export {
   createHandoffRiskItems,
   createPhase15BetaVerdictScope,
   checkClaimSupport,
+  createHeadlessBenchValidationContractRiskSummary,
   formatClaimCheck
 };

package/dist/{chunk-VTQL23UM.js → chunk-TVNWAEJR.js}

@@ -1,6 +1,6 @@
 import {
   truncateDisplay
-} from "./chunk-OMZYPQVA.js";
+} from "./chunk-UGYFQF6M.js";
 
 // src/memory-extraction-runtime.ts
 import { randomUUID } from "crypto";

package/dist/chunk-TY4KIVA6.js

@@ -0,0 +1,50 @@
+// src/shell/components/useAnchoredCursor.ts
+import { useBoxMetrics, useCursor } from "@linghun/ink-runtime";
+import { useLayoutEffect, useState } from "react";
+function getAbsoluteOrigin(node) {
+  if (!node) return null;
+  let x = 0;
+  let y = 0;
+  let cur = node;
+  while (cur && cur.nodeName !== "ink-root") {
+    const yogaNode = cur.yogaNode;
+    if (!yogaNode) return null;
+    const layout = yogaNode.getComputedLayout();
+    x += layout.left;
+    y += layout.top;
+    cur = cur.parentNode;
+  }
+  if (!cur || cur.nodeName !== "ink-root") return null;
+  return { x, y };
+}
+function useAnchoredCursor(declared, anchorRef, capability) {
+  const { setCursorPosition } = useCursor();
+  const [committedPosition, setCommittedPosition] = useState(void 0);
+  useBoxMetrics(anchorRef);
+  setCursorPosition(committedPosition);
+  useLayoutEffect(() => {
+    const next = resolveAnchoredCursorPosition(declared, anchorRef, capability);
+    setCommittedPosition((previous) => samePosition(previous, next) ? previous : next);
+  });
+}
+function resolveAnchoredCursorPosition(declared, anchorRef, capability) {
+  if (!declared || !capability.cursorPositioning) return void 0;
+  let origin = null;
+  try {
+    origin = getAbsoluteOrigin(anchorRef.current);
+  } catch {
+    origin = null;
+  }
+  if (!origin) return void 0;
+  return {
+    x: Math.max(0, Math.round(origin.x + declared.col)),
+    y: Math.max(0, Math.round(origin.y + declared.row))
+  };
+}
+function samePosition(left, right) {
+  return left?.x === right?.x && left?.y === right?.y;
+}
+
+export {
+  useAnchoredCursor
+};

package/dist/{chunk-UT2TYK2A.js → chunk-TYTVAFGB.js}

@@ -1,6 +1,6 @@
 import {
   isRecord
-} from "./chunk-QLRTQHTR.js";
+} from "./chunk-6JGRNES6.js";
 
 // src/index-runtime.ts
 import { readFile, stat } from "fs/promises";

package/dist/{chunk-OMZYPQVA.js → chunk-UGYFQF6M.js}

@@ -1,6 +1,6 @@
 import {
   charWidth
-} from "./chunk-APJIC2O5.js";
+} from "./chunk-GTIZNO5O.js";
 
 // src/startup-runtime.ts
 import { homedir } from "os";

package/dist/{chunk-JGDIO2NF.js → chunk-UO3KYTBU.js}

@@ -6,7 +6,7 @@ import {
 } from "./chunk-RBOQJFIZ.js";
 import {
   fitText
-} from "./chunk-APJIC2O5.js";
+} from "./chunk-GTIZNO5O.js";
 
 // src/shell/components/TaskListView.tsx
 import { Box, Text } from "@linghun/ink-runtime";

package/dist/{chunk-MXPBYB54.js → chunk-UYU4QN3P.js}

@@ -1,9 +1,9 @@
 import {
   redactedPath
-} from "./chunk-KOULRCYJ.js";
+} from "./chunk-HMGYFENJ.js";
 import {
   truncateDisplay
-} from "./chunk-OMZYPQVA.js";
+} from "./chunk-UGYFQF6M.js";
 
 // src/mcp-index-command-runtime.ts
 import { basename } from "path";

package/dist/{chunk-J6CYFWSW.js → chunk-VDQTNA4W.js}

@@ -48,6 +48,13 @@ var ProcessGuardRegistry = class {
       label: entry.label
     }));
   }
+  activeSnapshot() {
+    return Array.from(this.tracked.values()).filter((entry) => !entry.retainAfterExit).map((entry) => ({
+      pid: entry.pid,
+      detached: entry.detached,
+      label: entry.label
+    }));
+  }
   stopAll(kind, force, deps, allowAsyncWindowsTreeKill, onlyPids) {
     const result = {
       kind,
@@ -61,6 +68,10 @@ var ProcessGuardRegistry = class {
       if (onlyPids && !onlyPids.has(entry.pid)) {
         continue;
       }
+      if (kind === "exit-cleanup" && entry.retainAfterExit) {
+        result.skipped += 1;
+        continue;
+      }
       if (stopEntry(entry, force, deps, allowAsyncWindowsTreeKill, result)) {
         removePids.push(entry.pid);
       }
@@ -111,19 +122,25 @@ function requestTrackedProcessStop(force) {
 function cleanupTrackedProcessesForExit() {
   return recordStopResult(defaultRegistry.stopAll("exit-cleanup", true, resolveDeps(), false));
 }
+function cleanupTrackedProcessesBeforeExit() {
+  return recordStopResult(defaultRegistry.stopAll("exit-cleanup", false, resolveDeps(), false));
+}
 function consumeProcessGuardStopResultsForTest() {
   return recentStopResults.splice(0, recentStopResults.length);
 }
 function getTrackedProcessSnapshot() {
   return defaultRegistry.snapshot();
 }
+function getActiveTrackedProcessSnapshot() {
+  return defaultRegistry.activeSnapshot();
+}
 function installProcessGuardExitHandlers() {
   if (hooksInstalled) {
     return;
   }
   hooksInstalled = true;
   process.once("beforeExit", () => {
-    requestTrackedProcessStop(false);
+    cleanupTrackedProcessesBeforeExit();
   });
   process.once("exit", () => {
     cleanupTrackedProcessesForExit();
@@ -258,7 +275,9 @@ export {
   trackChildProcess,
   requestTrackedProcessStop,
   cleanupTrackedProcessesForExit,
+  cleanupTrackedProcessesBeforeExit,
   consumeProcessGuardStopResultsForTest,
   getTrackedProcessSnapshot,
+  getActiveTrackedProcessSnapshot,
   installProcessGuardExitHandlers
 };

package/dist/{chunk-KI7C6ZOD.js → chunk-VIJ7GDKI.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-K4FSYBSY.js";
 import {
   truncateDisplay
-} from "./chunk-OMZYPQVA.js";
+} from "./chunk-UGYFQF6M.js";
 
 // src/runtime-status-presenter.ts
 function formatRuntimeStatusLine(view, language) {

package/dist/{chunk-NKFKOEYX.js → chunk-WCMHJ6SS.js}

@@ -1,6 +1,6 @@
 import {
   charWidth
-} from "./chunk-APJIC2O5.js";
+} from "./chunk-GTIZNO5O.js";
 
 // src/shell/models/transcript-selection-state.ts
 import {

package/dist/{chunk-EORRZP3F.js → chunk-WX2OTJXL.js}

@@ -1,6 +1,6 @@
 import {
   truncateDisplay
-} from "./chunk-OMZYPQVA.js";
+} from "./chunk-UGYFQF6M.js";
 
 // src/memory-rules-runtime.ts
 import { readFile } from "fs/promises";

package/dist/{chunk-CRQORMFF.js → chunk-X37FSYAX.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-GC55DMZV.js";
 import {
   fitText
-} from "./chunk-APJIC2O5.js";
+} from "./chunk-GTIZNO5O.js";
 
 // src/shell/components/TaskSuggestionBar.tsx
 import { Box, Text } from "@linghun/ink-runtime";

package/dist/chunk-X7HMDZZQ.js

@@ -0,0 +1,85 @@
+import {
+  WheelAccelerator
+} from "./chunk-PGWW3DVE.js";
+import {
+  useScrollRuntime
+} from "./chunk-LL7LBRDL.js";
+import {
+  isXtermJsTerminal
+} from "./chunk-DICVLZHH.js";
+
+// src/shell/components/MouseInputRouter.tsx
+import {
+  useWheelInput,
+  useMouseInput,
+  useTerminalInput
+} from "@linghun/ink-runtime";
+import { useCallback, useMemo, useRef } from "react";
+function MouseInputRouter({
+  active,
+  scroll,
+  selectionActive = true,
+  onInput
+}) {
+  const accelerator = useMemo(() => {
+    const base = Number.parseInt(process.env.LINGHUN_SCROLL_SPEED ?? "1", 10) || 1;
+    const terminalType = isXtermJsTerminal() ? "xterm.js" : "native";
+    return new WheelAccelerator({ base, terminalType });
+  }, []);
+  const scrollRef = useRef(scroll);
+  scrollRef.current = scroll;
+  const dispatchScroll = useCallback(
+    (delta) => {
+      onInput({ type: "transcript-scroll", delta });
+    },
+    [onInput]
+  );
+  const accumulateScroll = useScrollRuntime(dispatchScroll);
+  useWheelInput(
+    useCallback(
+      (event) => {
+        const step = accelerator.recordEvent(Date.now(), event.direction, scrollRef.current?.viewportHeight);
+        if (step !== 0) {
+          accumulateScroll(event.direction === "up" ? step : -step);
+        }
+      },
+      [accelerator, accumulateScroll]
+    ),
+    { isActive: active }
+  );
+  useMouseInput(
+    useCallback(
+      (event) => {
+        if (!selectionActive) return;
+        onInput({
+          type: "transcript-mouse",
+          event: {
+            x: Math.max(0, event.x - 1),
+            y: Math.max(0, event.y - 1),
+            button: event.button === 0 || event.button === 3 ? "left" : "other",
+            action: event.action === "press" ? "down" : event.action === "release" ? "up" : event.action
+          }
+        });
+      },
+      [onInput, selectionActive]
+    ),
+    { isActive: active }
+  );
+  useTerminalInput(
+    useCallback(
+      (event) => {
+        if (event.kind !== "terminal-response") return;
+        if (event.response !== "\x1B[O") return;
+        if (!selectionActive) return;
+        onInput({ type: "transcript-mouse", event: { x: 0, y: 0, button: "left", action: "focus-out" } });
+      },
+      [onInput, selectionActive]
+    ),
+    { isActive: active }
+  );
+  return null;
+}
+
+export {
+  MouseInputRouter
+};

package/dist/{chunk-624A7BBJ.js → chunk-XYY5LRSF.js}

@@ -4,18 +4,18 @@ import {
   registerCapabilityProvider,
   setCapabilityConnectionResolver,
   unregisterCapabilitiesByApp
-} from "./chunk-LIPZJNXS.js";
+} from "./chunk-CQCJGMXG.js";
 import {
   ensureSession,
   showCommandPanel
-} from "./chunk-AZU7HXIT.js";
+} from "./chunk-6JPUBF7B.js";
 import {
   budgetToolResultTranscriptContent
-} from "./chunk-L2GU3PWU.js";
+} from "./chunk-DEIYY6NI.js";
 import {
   truncateDisplay,
   writeLine
-} from "./chunk-OMZYPQVA.js";
+} from "./chunk-UGYFQF6M.js";
 
 // src/connector-runtime.ts
 import { randomUUID } from "crypto";

package/dist/{chunk-CDVYF7RU.js → chunk-YBTXLLO5.js}

@@ -9,21 +9,21 @@ import {
   getDurableJobPaths,
   getDurableJobsRoot,
   listDurableJobs
-} from "./chunk-VAGL7CNR.js";
+} from "./chunk-NMOVU75L.js";
 import {
   formatJobNextAction,
   mapDurableJobToBackgroundResult,
   mapDurableJobToBackgroundStatus
-} from "./chunk-UDQT5CWK.js";
+} from "./chunk-PI6T2AGS.js";
 import {
   MAX_BACKGROUND_TASKS
 } from "./chunk-RDGM4RUE.js";
 import {
   formatIndexRuntimeRef
-} from "./chunk-UT2TYK2A.js";
+} from "./chunk-TYTVAFGB.js";
 import {
   truncateDisplay
-} from "./chunk-OMZYPQVA.js";
+} from "./chunk-UGYFQF6M.js";
 
 // src/tui-agent-job-runtime.ts
 function isAgentType(value) {

package/dist/{chunk-UN53MBAR.js → chunk-YGXPS5F2.js}

@@ -1,11 +1,11 @@
 import {
   deriveAgentDisplayName
-} from "./chunk-VAGL7CNR.js";
+} from "./chunk-NMOVU75L.js";
 import {
   formatDisplayPath,
   sanitizeDisplayPaths,
   truncateDisplay
-} from "./chunk-OMZYPQVA.js";
+} from "./chunk-UGYFQF6M.js";
 
 // src/tui-details-runtime.ts
 import { join } from "path";