@linghun/tui 0.1.0

package/dist/chunk-V7GDHHBL.js

@@ -0,0 +1,526 @@
+import {
+  PASS_BANNED_EVIDENCE_KINDS
+} from "./chunk-GCMH5P4W.js";
+
+// src/workflow-agent-runtime-bridge.ts
+var ELIGIBLE_SLICE_STATUSES = /* @__PURE__ */ new Set(["queued", "created", "sleeping"]);
+var SAFE_CONTEXT_REF_KINDS = /* @__PURE__ */ new Set([
+  "evidence",
+  "workspace_cache",
+  "file",
+  "architecture"
+]);
+function decideWorkflowStepCapability(input) {
+  if (!input.target) {
+    return { ok: false, reason: "missing structured targetRuntime" };
+  }
+  if (containsRawCommand(input.target)) {
+    return { ok: false, reason: "raw command strings are rejected by the workflow bridge" };
+  }
+  if (input.permissionMode === "plan" && input.target.mutating) {
+    return {
+      ok: false,
+      reason: "plan mode cannot produce executable mutating workflow proposals"
+    };
+  }
+  if (!input.request) {
+    return {
+      ok: false,
+      reason: "targetRuntime is outside the D.14H-C bridge allowlist"
+    };
+  }
+  if (input.target.mutating && !input.phaseStopPointConfirmed) {
+    return {
+      ok: false,
+      reason: "phase stopPoint must be confirmed before a mutating request becomes runnable"
+    };
+  }
+  return { ok: true, reason: "workflow step is executable through the existing main chain" };
+}
+function bridgeWorkflowPlanToMainChainRequests(plan, options = {}) {
+  const phases = plan.phases;
+  const currentPhase = selectCurrentPhase(phases, plan.currentPhaseId, options.currentPhaseId);
+  const currentPhaseId = currentPhase?.id ?? options.currentPhaseId ?? plan.currentPhaseId ?? "";
+  const runningCap = normalizeRunningCap(options.runningCap ?? plan.budget.maxRunningAgents) ?? deriveBridgeRunningCap(currentPhase);
+  const confirmedStopPoints = new Set(options.confirmedPhaseStopPoints ?? []);
+  const phaseStopPointConfirmed = confirmedStopPoints.has(currentPhaseId);
+  const phaseStatuses = phases.map((phase) => ({
+    phaseId: phase.id,
+    status: phase.status,
+    current: phase.id === currentPhaseId
+  }));
+  if (!currentPhase) {
+    return {
+      workflowId: plan.id,
+      currentPhaseId,
+      runningCap,
+      runnableSlots: 0,
+      phaseStopPointConfirmed,
+      requests: [],
+      phaseStatuses,
+      summary: emptySummary()
+    };
+  }
+  let runnableSlots = Math.max(
+    0,
+    runningCap - currentPhase.slices.filter((slice) => slice.status === "running").length
+  );
+  if (options.blockedProviderKeys && options.blockedProviderKeys.size > 0) {
+    runnableSlots = Math.min(runnableSlots, 1);
+  }
+  const initialRunnableSlots = runnableSlots;
+  const requests = currentPhase.slices.map((slice) => {
+    const contextRefs = createContextRefs(plan, slice);
+    const target = slice.targetRuntime;
+    const safety = createSafety(slice.role, target);
+    const base = {
+      id: `${plan.id}:${currentPhase.id}:${slice.id}`,
+      proposalOnly: true,
+      workflowId: plan.id,
+      phaseId: currentPhase.id,
+      sliceId: slice.id,
+      handoffProposal: contextRefs
+    };
+    const blockedReason = getBlockedReason(phases, currentPhase.id, slice.id);
+    if (blockedReason) {
+      return createProposal(base, {
+        status: "blocked",
+        reason: blockedReason,
+        executable: false,
+        request: null,
+        safety,
+        phase: currentPhase.title,
+        sliceTitle: slice.title,
+        nextAction: slice.nextAction ?? blockedReason,
+        contextRefs
+      });
+    }
+    if (!ELIGIBLE_SLICE_STATUSES.has(slice.status)) {
+      return createProposal(base, {
+        status: "status_only",
+        reason: `slice status is ${slice.status}; bridge does not convert it into execution`,
+        executable: false,
+        request: null,
+        safety,
+        phase: currentPhase.title,
+        sliceTitle: slice.title,
+        nextAction: slice.nextAction ?? "Inspect status before requesting another action.",
+        contextRefs
+      });
+    }
+    const request = createMainChainRequest(plan, currentPhase.id, currentPhase.title, slice);
+    const capability = decideWorkflowStepCapability({
+      permissionMode: plan.permissionMode,
+      phaseStopPointConfirmed,
+      target,
+      request
+    });
+    if (!capability.ok && capability.reason === "missing structured targetRuntime") {
+      return createProposal(base, {
+        status: "blocked",
+        reason: capability.reason,
+        executable: false,
+        request: null,
+        safety,
+        phase: currentPhase.title,
+        sliceTitle: slice.title,
+        nextAction: slice.nextAction ?? "Add a structured main-chain target.",
+        contextRefs
+      });
+    }
+    if (!capability.ok && capability.reason.includes("raw command strings")) {
+      return createProposal(base, {
+        status: "blocked",
+        reason: capability.reason,
+        executable: false,
+        request: null,
+        safety,
+        phase: currentPhase.title,
+        sliceTitle: slice.title,
+        nextAction: "Replace raw command text with a structured main-chain target.",
+        contextRefs
+      });
+    }
+    if (!capability.ok && capability.reason.includes("plan mode")) {
+      return createProposal(base, {
+        status: "blocked",
+        reason: capability.reason,
+        executable: false,
+        request: null,
+        safety,
+        phase: currentPhase.title,
+        sliceTitle: slice.title,
+        nextAction: "Leave plan mode through the existing approval path before mutating actions.",
+        contextRefs
+      });
+    }
+    if (!capability.ok && capability.reason.includes("allowlist")) {
+      return createProposal(base, {
+        status: "blocked",
+        reason: capability.reason,
+        executable: false,
+        request: null,
+        safety,
+        phase: currentPhase.title,
+        sliceTitle: slice.title,
+        nextAction: "Use /job create|run|status|report, /fork, /agents list|show, verification, or details.",
+        contextRefs
+      });
+    }
+    if (!capability.ok && capability.reason.includes("stopPoint")) {
+      return createProposal(base, {
+        status: "start_gate_needed",
+        reason: capability.reason,
+        executable: false,
+        request,
+        safety,
+        phase: currentPhase.title,
+        sliceTitle: slice.title,
+        nextAction: slice.nextAction ?? currentPhase.stopPoint.reason,
+        contextRefs,
+        startGateProposal: {
+          kind: "start-gate-proposal",
+          reason: currentPhase.stopPoint.reason,
+          scope: `${currentPhase.title} / ${slice.title}`,
+          requiresExactConfirmation: true,
+          doesNotReplacePermissionPipeline: true
+        }
+      });
+    }
+    if (!target) {
+      return createProposal(base, {
+        status: "blocked",
+        reason: "missing structured targetRuntime",
+        executable: false,
+        request: null,
+        safety,
+        phase: currentPhase.title,
+        sliceTitle: slice.title,
+        nextAction: slice.nextAction ?? "Add a structured main-chain target.",
+        contextRefs
+      });
+    }
+    if (target.mutating && hasArchitectureBoundaryRisk(plan, slice)) {
+      return createProposal(base, {
+        status: "blocked",
+        reason: "architecture boundary risk blocks mutating workflow step",
+        executable: false,
+        request: null,
+        safety,
+        phase: currentPhase.title,
+        sliceTitle: slice.title,
+        nextAction: "Review architecture findings before running the mutating step.",
+        contextRefs
+      });
+    }
+    if (target.mutating && runnableSlots <= 0) {
+      return createProposal(base, {
+        status: "queued",
+        reason: `running cap ${runningCap} reached; slice remains queued/sleeping`,
+        executable: false,
+        request: null,
+        safety,
+        phase: currentPhase.title,
+        sliceTitle: slice.title,
+        nextAction: "Wait for an existing agent/job to finish or inspect /agents and /job status.",
+        contextRefs
+      });
+    }
+    if (target.mutating) {
+      runnableSlots -= 1;
+    }
+    return createProposal(base, {
+      status: target.mutating ? "runnable" : "readonly",
+      reason: target.mutating ? "eligible slice converted into a proposal for the existing main chain" : "readonly target converted into a readonly main-chain proposal",
+      executable: true,
+      request,
+      safety,
+      phase: currentPhase.title,
+      sliceTitle: slice.title,
+      nextAction: slice.nextAction ?? "Hand this proposal to the existing main-chain dispatcher.",
+      contextRefs
+    });
+  });
+  return {
+    workflowId: plan.id,
+    currentPhaseId,
+    runningCap,
+    runnableSlots: initialRunnableSlots,
+    phaseStopPointConfirmed,
+    requests,
+    phaseStatuses,
+    summary: summarizeRequests(requests)
+  };
+}
+function createProposal(base, input) {
+  const permissionProposal = input.safety.requiresPermissionPipeline || input.safety.requiredPermissionAction !== "none" ? {
+    kind: "permission-proposal",
+    requiredPermissionAction: input.safety.requiredPermissionAction,
+    via: "decidePermission-or-pendingLocalApproval",
+    bypassed: false
+  } : void 0;
+  return {
+    ...base,
+    status: input.status,
+    reason: input.reason,
+    executable: input.executable,
+    request: input.request,
+    safety: input.safety,
+    startGateProposal: input.startGateProposal,
+    permissionProposal,
+    backgroundProjection: createBackgroundProjection(input),
+    taskSurfaceInput: {
+      phaseId: base.phaseId,
+      sliceId: base.sliceId,
+      requestStatus: input.status,
+      tokenEstimate: getRequestTokenEstimate(input.request),
+      durationEstimateMs: getRequestDurationEstimate(input.request),
+      evidenceRefs: input.contextRefs.evidenceRefs.map((ref) => ref.ref),
+      nextAction: input.nextAction
+    }
+  };
+}
+function createBackgroundProjection(input) {
+  const kind = input.request?.mainChain === "job" ? "job" : input.request?.mainChain === "fork" ? "agent" : input.request?.mainChain === "agents" || input.request?.mainChain === "workflows" ? "verification" : "verification";
+  return {
+    source: "background-task-projection",
+    kind,
+    jobAgentStatus: mapRequestStatusToJobAgentStatus(input.status),
+    userVisibleSummary: `${input.phase} / ${input.sliceTitle}: ${input.status}`,
+    nextAction: input.nextAction
+  };
+}
+function createMainChainRequest(plan, phaseId, phaseTitle, slice) {
+  const target = slice.targetRuntime;
+  if (!target) return null;
+  if (target.kind === "slash" && target.slash === "/job") {
+    if (!["list", "create", "run", "status", "report", "logs", "pause", "resume", "cancel"].includes(
+      target.action
+    ))
+      return null;
+    const action = target.action;
+    const mutating = ["create", "run", "pause", "resume", "cancel"].includes(target.action);
+    return {
+      mainChain: "job",
+      action: target.action,
+      workflowId: plan.id,
+      phaseId,
+      sliceId: slice.id,
+      goal: mutating ? slice.nextAction ?? slice.title : void 0,
+      jobRef: target.action === "status" || target.action === "report" || target.action === "logs" || target.action === "pause" || target.action === "resume" || target.action === "cancel" ? slice.nextAction ?? "latest" : void 0,
+      phase: phaseTitle,
+      target: "workflow-agent-runtime-bridge",
+      requestedAgents: slice.budget?.requestedAgents,
+      runningCap: slice.budget?.maxRunningAgents,
+      maxTokens: slice.budget?.maxTokens,
+      maxDurationMs: slice.budget?.maxDurationMs
+    };
+  }
+  if (target.kind === "slash" && target.slash === "/fork") {
+    return {
+      mainChain: "fork",
+      role: target.role,
+      task: slice.nextAction ?? slice.title,
+      workflowId: plan.id,
+      phaseId,
+      sliceId: slice.id,
+      contextRefs: createContextRefs(plan, slice)
+    };
+  }
+  if (target.kind === "slash" && target.slash === "/agents") {
+    if (!["list", "show", "cancel"].includes(target.action)) return null;
+    return {
+      mainChain: "agents",
+      action: target.action,
+      workflowId: plan.id,
+      phaseId,
+      sliceId: slice.id,
+      agentRef: target.action === "show" || target.action === "cancel" ? slice.nextAction : void 0
+    };
+  }
+  if (target.kind === "slash" && target.slash === "/workflows") {
+    if (!["list", "start_gate"].includes(target.action)) return null;
+    return {
+      mainChain: "workflows",
+      action: target.action,
+      workflowId: plan.id,
+      phaseId,
+      sliceId: slice.id,
+      goal: target.action === "start_gate" ? slice.nextAction ?? slice.title : void 0
+    };
+  }
+  if (target.kind === "verification") {
+    return {
+      mainChain: "verification",
+      level: target.level,
+      workflowId: plan.id,
+      phaseId,
+      sliceId: slice.id,
+      evidenceRefs: slice.evidence.map((item) => item.ref)
+    };
+  }
+  if (target.kind === "details") {
+    return {
+      mainChain: "details",
+      view: target.view,
+      workflowId: plan.id,
+      phaseId,
+      sliceId: slice.id,
+      refs: slice.references.map((ref) => ref.ref)
+    };
+  }
+  return null;
+}
+function createSafety(role, target) {
+  const mutating = Boolean(target?.mutating);
+  return {
+    readonly: !mutating,
+    mutating,
+    requiresStartGate: mutating,
+    requiresPermissionPipeline: mutating,
+    requiredPermissionAction: inferPermissionAction(role, target),
+    evidencePolicy: "neverTreatCompletionAsPass"
+  };
+}
+function hasArchitectureBoundaryRisk(plan, slice) {
+  if (slice.evidence.some(
+    (item) => item.passEvidence === false && isArchitectureRiskText(`${item.kind} ${item.ref} ${item.claim}`)
+  )) {
+    return true;
+  }
+  return [...slice.references, ...plan.references ?? []].some(
+    (item) => isArchitectureRiskReference(`${item.kind} ${item.ref} ${item.summary ?? ""}`)
+  );
+}
+function isArchitectureRiskReference(value) {
+  if (/\b(?:no architecture risk|no risk|passed|pass|clean|ok)\b/iu.test(value)) return false;
+  if (/无风险|已通过|通过|未发现(?:架构)?风险/u.test(value)) return false;
+  return isArchitectureRiskText(value);
+}
+function isArchitectureRiskText(value) {
+  return /architecture/iu.test(value) && /\b(?:risk|violation|boundary|god-file|code-blob|large-file)\b/iu.test(value);
+}
+function inferPermissionAction(role, target) {
+  if (!target?.mutating) return "none";
+  if (target.kind === "slash" && target.slash === "/fork" && role === "worker") return "Write";
+  return "none";
+}
+function createContextRefs(plan, slice) {
+  const refs = [...plan.references ?? [], ...slice.references];
+  const boundedRefs = refs.filter((ref) => SAFE_CONTEXT_REF_KINDS.has(ref.kind)).map((ref) => ({
+    kind: ref.kind,
+    ref: truncateText(ref.ref, 240),
+    summary: ref.summary ? truncateText(ref.summary, 300) : void 0
+  })).slice(0, 20);
+  const droppedRefKinds = Array.from(
+    new Set(refs.filter((ref) => !SAFE_CONTEXT_REF_KINDS.has(ref.kind)).map((ref) => ref.kind))
+  );
+  const workspaceCacheRefs = boundedRefs.filter((ref) => ref.kind === "workspace_cache").map((ref) => ref.ref);
+  const keyFilesSummary = boundedRefs.filter((ref) => ref.kind === "file").map((ref) => ref.summary ?? ref.ref).slice(0, 8);
+  const evidenceRefs = [...plan.evidence ?? [], ...slice.evidence].map((item) => ({
+    ref: truncateText(item.ref, 240),
+    kind: item.kind,
+    claim: truncateText(item.claim, 300),
+    passEvidenceAllowed: item.passEvidence === true && !PASS_BANNED_EVIDENCE_KINDS.has(item.kind)
+  })).slice(0, 20);
+  return {
+    boundedRefs,
+    workspaceCacheRefs,
+    evidenceRefs,
+    keyFilesSummary,
+    droppedRefKinds,
+    notIncluded: [
+      "full transcript",
+      "full source",
+      "full index",
+      "full log",
+      "provider/env/key/model route changes"
+    ]
+  };
+}
+function selectCurrentPhase(phases, planCurrentPhaseId, explicitPhaseId) {
+  const phaseId = explicitPhaseId ?? planCurrentPhaseId;
+  return phases.find((phase) => phase.id === phaseId) ?? phases.find((phase) => phase.status === "running" || phase.status === "blocked") ?? phases[0];
+}
+function getBlockedReason(phases, phaseId, sliceId) {
+  const phase = phases.find((item) => item.id === phaseId);
+  const slice = phase?.slices.find((item) => item.id === sliceId);
+  if (!phase || !slice) return "unknown phase or slice";
+  const phaseDeps = phase.dependsOnPhaseIds ?? [];
+  const unsatisfiedPhaseDep = phaseDeps.find(
+    (depId) => phases.find((item) => item.id === depId)?.status !== "completed"
+  );
+  if (unsatisfiedPhaseDep) {
+    return `phase dependency not satisfied: ${unsatisfiedPhaseDep}`;
+  }
+  const allSlices = new Map(phases.flatMap((item) => item.slices.map((s) => [s.id, s])));
+  const unsatisfiedSliceDep = (slice.dependsOnSliceIds ?? []).find((depId) => {
+    const status = allSlices.get(depId)?.status;
+    return status !== "completed" && status !== "partial";
+  });
+  return unsatisfiedSliceDep ? `slice dependency not satisfied: ${unsatisfiedSliceDep}` : null;
+}
+function containsRawCommand(value) {
+  if (!value || typeof value !== "object") return false;
+  if (Array.isArray(value)) return value.some(containsRawCommand);
+  return Object.entries(value).some(([key, child]) => {
+    const lowered = key.toLowerCase();
+    if ((lowered === "command" || lowered === "rawcommand") && typeof child === "string") {
+      return true;
+    }
+    return containsRawCommand(child);
+  });
+}
+function mapRequestStatusToJobAgentStatus(status) {
+  if (status === "runnable" || status === "readonly") return "queued";
+  if (status === "queued" || status === "start_gate_needed") return "queued";
+  if (status === "blocked") return "blocked";
+  return "created";
+}
+function getRequestTokenEstimate(request) {
+  return request?.mainChain === "job" ? request.maxTokens : void 0;
+}
+function getRequestDurationEstimate(request) {
+  return request?.mainChain === "job" ? request.maxDurationMs : void 0;
+}
+function normalizeRunningCap(value) {
+  if (!Number.isFinite(value) || value === void 0 || value < 1) {
+    return void 0;
+  }
+  return Math.max(1, Math.floor(value));
+}
+function deriveBridgeRunningCap(phase) {
+  if (!phase) return 1;
+  return Math.max(1, phase.slices.length);
+}
+function summarizeRequests(requests) {
+  return requests.reduce((summary, request) => {
+    if (request.status === "runnable") summary.runnable += 1;
+    if (request.status === "readonly") summary.readonly += 1;
+    if (request.status === "start_gate_needed") summary.startGateNeeded += 1;
+    if (request.status === "blocked") summary.blocked += 1;
+    if (request.status === "queued") summary.queued += 1;
+    if (request.status === "status_only") summary.statusOnly += 1;
+    return summary;
+  }, emptySummary());
+}
+function emptySummary() {
+  return {
+    runnable: 0,
+    readonly: 0,
+    startGateNeeded: 0,
+    blocked: 0,
+    queued: 0,
+    statusOnly: 0
+  };
+}
+function truncateText(text, max) {
+  const compact = text.replace(/\s+/gu, " ").trim();
+  if (compact.length <= max) return compact;
+  return `${compact.slice(0, Math.max(0, max - 1))}\u2026`;
+}
+
+export {
+  decideWorkflowStepCapability,
+  bridgeWorkflowPlanToMainChainRequests
+};

package/dist/chunk-VCSRBS47.js

@@ -0,0 +1,133 @@
+import {
+  createShellTheme
+} from "./chunk-GC55DMZV.js";
+import {
+  fitText,
+  wrapText
+} from "./chunk-APJIC2O5.js";
+
+// src/shell/components/ConfigPanel.tsx
+import { Box, Text, useInput } from "@linghun/ink-runtime";
+import { jsx, jsxs } from "react/jsx-runtime";
+var MAX_VISIBLE = 10;
+var MIN_PANEL_WIDTH = 64;
+var MAX_PANEL_WIDTH = 108;
+var HINT_TEXT = {
+  "zh-CN": {
+    list: "\u2191\u2193 \u9009\u62E9 \xB7 Enter \u8FDB\u5165 \xB7 Esc \u5173\u95ED",
+    detail: "\u2191\u2193 \u9009\u62E9 \xB7 Enter \u6267\u884C \xB7 Esc \u8FD4\u56DE",
+    count: (start, end, total) => `\u7B2C ${start}-${end} \u9879\uFF0C\u5171 ${total} \u9879`
+  },
+  "en-US": {
+    list: "\u2191\u2193 select \xB7 Enter open \xB7 Esc close",
+    detail: "\u2191\u2193 select \xB7 Enter dispatch \xB7 Esc back",
+    count: (start, end, total) => `${start}-${end} of ${total}`
+  }
+};
+function ConfigPanel({
+  panel,
+  controller: _controller,
+  width,
+  noColor,
+  language
+}) {
+  const theme = createShellTheme(noColor);
+  const hint = HINT_TEXT[language] ?? HINT_TEXT["zh-CN"];
+  useInput(() => void 0, { isActive: false });
+  const panelWidth = Math.max(
+    40,
+    Math.max(Math.min(width - 2, MIN_PANEL_WIDTH), Math.min(width - 2, MAX_PANEL_WIDTH))
+  );
+  const innerWidth = Math.max(36, panelWidth - 4);
+  if (panel.phase === "panel_list") {
+    const total2 = panel.panels.length;
+    const maxOffset2 = Math.max(0, total2 - MAX_VISIBLE);
+    const scrollOffset2 = Math.max(0, Math.min(panel.scrollOffset, maxOffset2));
+    const visible2 = panel.panels.slice(scrollOffset2, scrollOffset2 + MAX_VISIBLE);
+    const visibleEnd2 = Math.min(scrollOffset2 + MAX_VISIBLE, total2);
+    const titleWidth = Math.min(
+      18,
+      Math.max(8, ...panel.panels.map((p) => [...p.title].length)) + 2
+    );
+    const summaryWidth = Math.max(16, innerWidth - titleWidth - 5);
+    return /* @__PURE__ */ jsxs(
+      Box,
+      {
+        flexDirection: "column",
+        paddingX: 1,
+        marginTop: 1,
+        width: panelWidth,
+        borderStyle: "round",
+        borderColor: theme.panel ?? theme.border,
+        children: [
+          /* @__PURE__ */ jsxs(Box, { paddingX: 2, children: [
+            /* @__PURE__ */ jsx(Text, { color: theme.accent, bold: true, children: "CONFIG" }),
+            /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: true, children: fitText(
+              `  /config  ${total2 > 0 ? hint.count(scrollOffset2 + 1, visibleEnd2, total2) : ""}`,
+              innerWidth - 6
+            ) })
+          ] }),
+          /* @__PURE__ */ jsx(Box, { paddingX: 2, children: /* @__PURE__ */ jsx(Text, { color: theme.muted, children: fitText(hint.list, innerWidth) }) }),
+          /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, paddingX: 2, children: visible2.map((p, vi) => {
+            const realIdx = scrollOffset2 + vi;
+            const active = realIdx === panel.cursor;
+            const titleCol = p.title.padEnd(titleWidth);
+            return /* @__PURE__ */ jsxs(Box, { marginTop: vi > 0 ? 1 : 0, children: [
+              /* @__PURE__ */ jsx(Text, { color: active ? theme.accent : theme.dim ?? theme.muted, bold: active, children: active ? "\u258C " : "  " }),
+              /* @__PURE__ */ jsx(Text, { color: active ? theme.accent : void 0, bold: active, children: fitText(titleCol, titleWidth) }),
+              /* @__PURE__ */ jsx(Text, { color: active ? void 0 : theme.dim ?? theme.muted, children: fitText(p.summary, summaryWidth) })
+            ] }, p.id);
+          }) })
+        ]
+      }
+    );
+  }
+  const actions = panel.actions;
+  const total = actions.length;
+  const maxOffset = Math.max(0, total - MAX_VISIBLE);
+  const scrollOffset = Math.max(0, Math.min(panel.scrollOffset, maxOffset));
+  const visible = actions.slice(scrollOffset, scrollOffset + MAX_VISIBLE);
+  const visibleEnd = Math.min(scrollOffset + MAX_VISIBLE, total);
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      flexDirection: "column",
+      paddingX: 1,
+      marginTop: 1,
+      width: panelWidth,
+      borderStyle: "round",
+      borderColor: theme.panel ?? theme.border,
+      children: [
+        /* @__PURE__ */ jsxs(Box, { paddingX: 2, children: [
+          /* @__PURE__ */ jsx(Text, { color: theme.accent, bold: true, children: fitText(panel.panel.title.toUpperCase(), Math.max(8, Math.floor(innerWidth * 0.45))) }),
+          /* @__PURE__ */ jsx(Text, { color: theme.dim ?? theme.muted, dimColor: true, children: fitText(
+            `  /config \xB7 ${panel.panel.title}`,
+            Math.max(8, innerWidth - panel.panel.title.length - 2)
+          ) })
+        ] }),
+        /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, paddingX: 2, children: wrapText(panel.panel.summary, innerWidth).map((line, idx) => /* @__PURE__ */ jsx(Text, { color: theme.muted, children: line }, `summary-${idx}-${line}`)) }),
+        /* @__PURE__ */ jsx(Box, { paddingX: 2, children: /* @__PURE__ */ jsx(Text, { color: theme.muted, children: fitText(
+          [total > 0 ? hint.count(scrollOffset + 1, visibleEnd, total) : "", hint.detail].filter(Boolean).join(" \xB7 "),
+          innerWidth
+        ) }) }),
+        /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: 1, paddingX: 2, children: visible.map((a, vi) => {
+          const realIdx = scrollOffset + vi;
+          const active = realIdx === panel.actionCursor;
+          return /* @__PURE__ */ jsx(Box, { flexDirection: "column", marginTop: vi > 0 ? 1 : 0, children: wrapText(`${active ? "\u258C " : "  "}${a.label}`, innerWidth).map((part, lineIdx) => /* @__PURE__ */ jsx(
+            Text,
+            {
+              color: active ? theme.accent : void 0,
+              bold: active,
+              children: lineIdx === 0 ? part : `  ${fitText(part, Math.max(8, innerWidth - 2))}`
+            },
+            `${a.id}-${lineIdx}`
+          )) }, a.id);
+        }) })
+      ]
+    }
+  );
+}
+
+export {
+  ConfigPanel
+};