skillmux 0.1.1 → 0.1.3

package/dist/launch-tui-PHWJPIQZ.js

@@ -0,0 +1,1790 @@
+import {
+  ManifestValidationError,
+  buildEmptyManifest,
+  collectDoctorIssues,
+  dedupeAndSortIssues,
+  discoverAgents,
+  formatValidationIssues,
+  isPathInside,
+  manifestSchema,
+  resolveSkillmuxHome,
+  runAdopt,
+  runDisable,
+  runEnable,
+  runRemove,
+  runScan,
+  scanAgentSkills
+} from "./chunk-DBEVDI27.js";
+
+// src/tui/launch-tui.tsx
+import { render } from "ink";
+
+// src/tui/app.tsx
+import { readFileSync } from "fs";
+import { Text as Text9, useApp, useInput } from "ink";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+// src/tui/load-dashboard-state.ts
+import { homedir } from "os";
+
+// src/manifest/read-manifest-snapshot.ts
+import * as fs from "fs/promises";
+import { join, resolve } from "path";
+function normalizeHomePath(home) {
+  const resolvedHome = resolve(home);
+  return process.platform === "win32" ? resolvedHome.toLowerCase() : resolvedHome;
+}
+async function readManifestSnapshot(home) {
+  const manifestPath = join(home, "manifest.json");
+  try {
+    const contents = await fs.readFile(manifestPath, "utf8");
+    const parsed = manifestSchema.safeParse(JSON.parse(contents));
+    if (!parsed.success) {
+      throw new ManifestValidationError(
+        `Invalid manifest at ${manifestPath}: ${formatValidationIssues(parsed.error)}`
+      );
+    }
+    if (normalizeHomePath(parsed.data.skillmuxHome) !== normalizeHomePath(home)) {
+      throw new ManifestValidationError(
+        `Invalid manifest at ${manifestPath}: skillmuxHome must match ${home}`
+      );
+    }
+    return { manifest: parsed.data, exists: true };
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return { manifest: buildEmptyManifest(home), exists: false };
+    }
+    if (error instanceof SyntaxError) {
+      throw new ManifestValidationError(
+        `Invalid manifest at ${manifestPath}: malformed JSON`
+      );
+    }
+    throw error;
+  }
+}
+
+// src/tui/dashboard-model.ts
+var emptyCounts = () => ({
+  enabledCount: 0,
+  disabledCount: 0,
+  unmanagedCount: 0,
+  issueCount: 0
+});
+function sortById(values) {
+  return [...values].sort((left, right) => left.id.localeCompare(right.id));
+}
+function getSelectedAgentId(agents, requestedAgentId) {
+  if (requestedAgentId !== void 0) {
+    const requestedAgent = agents.find((agent) => agent.id === requestedAgentId);
+    if (requestedAgent !== void 0) {
+      return requestedAgent.id;
+    }
+  }
+  const availableAgent = agents.find(
+    (agent) => agent.exists && agent.supportedOnPlatform
+  );
+  return availableAgent?.id ?? agents[0]?.id ?? null;
+}
+function findEnabledActivation(manifest, skillId, agentId) {
+  return manifest.activations.find(
+    (activation) => activation.skillId === skillId && activation.agentId === agentId && activation.state === "enabled"
+  );
+}
+function findAnyActivation(manifest, skillId, agentId) {
+  return manifest.activations.find(
+    (activation) => activation.skillId === skillId && activation.agentId === agentId
+  );
+}
+function buildManagedSkillRow(manifest, skill, agentId) {
+  const enabledActivation = findEnabledActivation(manifest, skill.id, agentId);
+  if (enabledActivation !== void 0) {
+    return {
+      id: skill.id,
+      kind: "enabled",
+      marker: "\u25CF",
+      skillId: skill.id,
+      name: skill.name,
+      path: skill.path,
+      agentId,
+      activationLinkPath: enabledActivation.linkPath
+    };
+  }
+  return {
+    id: skill.id,
+    kind: "disabled",
+    marker: "\u25CB",
+    skillId: skill.id,
+    name: skill.name,
+    path: skill.path,
+    agentId,
+    activationLinkPath: findAnyActivation(manifest, skill.id, agentId)?.linkPath ?? null
+  };
+}
+function isAdoptableEntry(entry) {
+  return entry.kind === "unmanaged-directory" || entry.kind === "unmanaged-link";
+}
+function buildUnmanagedRows(entries, agentId) {
+  return entries.filter((entry) => entry.agentId === agentId).filter(isAdoptableEntry).sort(
+    (left, right) => `${left.skillName}:${left.path}`.localeCompare(
+      `${right.skillName}:${right.path}`
+    )
+  ).map((entry) => ({
+    id: `unmanaged:${entry.skillName}`,
+    kind: "unmanaged",
+    marker: "?",
+    skillName: entry.skillName,
+    name: entry.skillName,
+    path: entry.path,
+    agentId,
+    entryKind: entry.kind,
+    targetPath: entry.targetPath
+  }));
+}
+function relatedAgentIdsForIssue(issue, agents) {
+  if (issue.path === void 0) {
+    return [];
+  }
+  const issuePath = issue.path;
+  return agents.filter((agent) => isPathInside(agent.absoluteSkillsDirectoryPath, issuePath)).map((agent) => agent.id);
+}
+function buildIssueId(issue, agentId) {
+  return `issue:${agentId}:${issue.code}:${issue.path ?? issue.message}`;
+}
+function buildIssueRows(issues, agents, agentId) {
+  return issues.filter((issue) => {
+    const relatedAgentIds = relatedAgentIdsForIssue(issue, agents);
+    return relatedAgentIds.includes(agentId);
+  }).map((issue) => ({
+    id: buildIssueId(issue, agentId),
+    kind: "issue",
+    marker: "!",
+    issueCode: issue.code,
+    severity: issue.severity,
+    message: issue.message,
+    path: issue.path ?? null,
+    agentId
+  }));
+}
+function buildSkillRowsForAgent(input, agentId) {
+  const managedRows = sortById(Object.values(input.manifest.skills)).map(
+    (skill) => buildManagedSkillRow(input.manifest, skill, agentId)
+  );
+  const unmanagedRows = buildUnmanagedRows(input.entries, agentId);
+  const issueRows = buildIssueRows(input.issues, input.agents, agentId);
+  return [...managedRows, ...unmanagedRows, ...issueRows];
+}
+function countsForRows(rows) {
+  const counts = emptyCounts();
+  for (const row of rows) {
+    if (row.kind === "enabled") {
+      counts.enabledCount += 1;
+    } else if (row.kind === "disabled") {
+      counts.disabledCount += 1;
+    } else if (row.kind === "unmanaged") {
+      counts.unmanagedCount += 1;
+    } else {
+      counts.issueCount += 1;
+    }
+  }
+  return counts;
+}
+function countActivationsForAgent(manifest, agentId) {
+  return manifest.activations.filter((activation) => activation.agentId === agentId).length;
+}
+function buildAgentRows(input) {
+  return sortById(input.agents).map((agent) => {
+    const counts = countsForRows(buildSkillRowsForAgent(input, agent.id));
+    return {
+      id: agent.id,
+      name: agent.stableName,
+      path: agent.absoluteSkillsDirectoryPath,
+      discovery: agent.discovery,
+      exists: agent.exists,
+      supported: agent.supportedOnPlatform,
+      activationCount: countActivationsForAgent(input.manifest, agent.id),
+      ...counts
+    };
+  });
+}
+function buildDashboardModel(input) {
+  const sortedAgents = sortById(input.agents);
+  const selectedAgentId = getSelectedAgentId(
+    sortedAgents,
+    input.selectedAgentId
+  );
+  const skills = selectedAgentId === null ? [] : buildSkillRowsForAgent({ ...input, agents: sortedAgents }, selectedAgentId);
+  const selectedSkillId = skills.some((row) => row.id === input.selectedSkillId) ? input.selectedSkillId : skills[0]?.id ?? null;
+  return {
+    agents: buildAgentRows({ ...input, agents: sortedAgents }),
+    skills,
+    selectedAgentId,
+    selectedSkillId,
+    lastScanAt: input.manifest.lastScan.at,
+    issueCount: input.issues.length
+  };
+}
+
+// src/tui/load-dashboard-state.ts
+async function loadDashboardState(options = {}) {
+  const homeDir = options.homeDir ?? homedir();
+  const resolvedSkillmuxHome = resolveSkillmuxHome(homeDir).skillmuxHome;
+  const skillmuxHome = options.skillmuxHome ?? resolvedSkillmuxHome;
+  const { manifest } = await readManifestSnapshot(skillmuxHome);
+  const agents = await discoverAgents({
+    homeDir,
+    platform: options.platform,
+    skillmuxHome
+  });
+  const scanResults = [];
+  for (const agent of agents) {
+    scanResults.push(await scanAgentSkills(agent, skillmuxHome));
+  }
+  const entries = scanResults.flatMap((result) => result.entries);
+  const scanIssues = scanResults.flatMap((result) => result.issues);
+  const doctorIssues = await collectDoctorIssues({ manifest, agents, entries });
+  const issues = dedupeAndSortIssues([...scanIssues, ...doctorIssues]);
+  return buildDashboardModel({
+    manifest,
+    agents,
+    entries,
+    issues,
+    selectedAgentId: options.selectedAgentId,
+    selectedSkillId: options.selectedSkillId
+  });
+}
+
+// src/tui/actions.ts
+var defaultServices = {
+  runEnable,
+  runDisable,
+  runAdopt,
+  runRemove,
+  runScan,
+  reload: loadDashboardState
+};
+function stripTrailingNewlines(output) {
+  return output.replace(/[\r\n]+$/u, "");
+}
+function actionLabel(action) {
+  return action.charAt(0).toUpperCase() + action.slice(1);
+}
+function errorReason(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const firstLine = message.split(/\r?\n/u)[0]?.trim();
+  return firstLine === void 0 || firstLine.length === 0 ? "Unknown error" : firstLine;
+}
+function reloadOptions(input) {
+  return {
+    homeDir: input.homeDir,
+    skillmuxHome: input.skillmuxHome,
+    platform: input.platform,
+    selectedAgentId: input.model.selectedAgentId ?? void 0,
+    selectedSkillId: input.model.selectedSkillId ?? void 0
+  };
+}
+async function reloadAfterCommand(input, services, output) {
+  return {
+    model: await services.reload(reloadOptions(input)),
+    statusMessage: stripTrailingNewlines(output)
+  };
+}
+function refusal(model, statusMessage) {
+  return { model, statusMessage };
+}
+function resolveSelectedSkill(model) {
+  if (model.selectedSkillId === null) {
+    return null;
+  }
+  return model.skills.find((row) => row.id === model.selectedSkillId) ?? null;
+}
+function resolveSelectedAgent(model) {
+  if (model.selectedAgentId === null) {
+    return null;
+  }
+  return model.agents.find((row) => row.id === model.selectedAgentId) ?? null;
+}
+async function dispatchTuiAction(input) {
+  const services = { ...defaultServices, ...input.services };
+  try {
+    if (input.action === "scan") {
+      const result2 = await services.runScan({
+        homeDir: input.homeDir,
+        skillmuxHome: input.skillmuxHome,
+        platform: input.platform
+      });
+      return reloadAfterCommand(input, services, result2.output);
+    }
+    if (input.action === "adopt-all") {
+      const selectedAgent = resolveSelectedAgent(input.model);
+      if (selectedAgent === null) {
+        return refusal(input.model, "Select an agent first");
+      }
+      if (selectedAgent.unmanagedCount <= 0) {
+        return refusal(input.model, "No unmanaged skills to adopt for this agent");
+      }
+      const result2 = await services.runAdopt({
+        homeDir: input.homeDir,
+        skillmuxHome: input.skillmuxHome,
+        agent: selectedAgent.id
+      });
+      return reloadAfterCommand(input, services, result2.output);
+    }
+    const selectedSkill = resolveSelectedSkill(input.model);
+    if (selectedSkill === null) {
+      return refusal(input.model, "Select a skill first");
+    }
+    if (input.action === "toggle") {
+      if (selectedSkill.kind === "enabled") {
+        const result2 = await services.runDisable({
+          homeDir: input.homeDir,
+          skillmuxHome: input.skillmuxHome,
+          skill: selectedSkill.skillId,
+          agent: selectedSkill.agentId
+        });
+        return reloadAfterCommand(input, services, result2.output);
+      }
+      if (selectedSkill.kind === "disabled") {
+        const result2 = await services.runEnable({
+          homeDir: input.homeDir,
+          skillmuxHome: input.skillmuxHome,
+          skill: selectedSkill.skillId,
+          agent: selectedSkill.agentId
+        });
+        return reloadAfterCommand(input, services, result2.output);
+      }
+      return refusal(input.model, "Toggle is only available for managed rows");
+    }
+    if (input.action === "adopt") {
+      if (selectedSkill.kind !== "unmanaged") {
+        return refusal(input.model, "Adopt is only available for unmanaged rows");
+      }
+      const result2 = await services.runAdopt({
+        homeDir: input.homeDir,
+        skillmuxHome: input.skillmuxHome,
+        agent: selectedSkill.agentId,
+        skill: selectedSkill.skillName
+      });
+      return reloadAfterCommand(input, services, result2.output);
+    }
+    if (selectedSkill.kind === "enabled") {
+      return refusal(input.model, "Disable this skill before removing it");
+    }
+    if (selectedSkill.kind !== "disabled") {
+      return refusal(input.model, "Remove is only available for disabled rows");
+    }
+    const result = await services.runRemove({
+      homeDir: input.homeDir,
+      skillmuxHome: input.skillmuxHome,
+      skill: selectedSkill.skillId
+    });
+    return reloadAfterCommand(input, services, result.output);
+  } catch (error) {
+    return {
+      model: input.model,
+      statusMessage: `${actionLabel(input.action)} failed: ${errorReason(error)}`
+    };
+  }
+}
+
+// src/tui/components/Dashboard.tsx
+import { Box as Box8, Text as Text8 } from "ink";
+
+// src/tui/state.ts
+var focusOrder = ["agents", "skills"];
+function clampCursor(cursor, rowCount) {
+  if (rowCount <= 0) {
+    return 0;
+  }
+  return Math.min(Math.max(cursor, 0), rowCount - 1);
+}
+function normalizeQuery(query) {
+  return query.trim().toLocaleLowerCase();
+}
+function includesQuery(values, query) {
+  const normalizedQuery = normalizeQuery(query);
+  if (normalizedQuery.length === 0) {
+    return true;
+  }
+  return values.some(
+    (value) => (value ?? "").toLocaleLowerCase().includes(normalizedQuery)
+  );
+}
+function isRelevantAgentRow(row, selectedAgentId) {
+  return row.id === selectedAgentId || row.exists || (row.activationCount ?? 0) > 0 || row.enabledCount > 0 || row.unmanagedCount > 0 || row.issueCount > 0;
+}
+function skillMatchesQuery(row, query) {
+  if (row.kind === "issue") {
+    return includesQuery(
+      [row.id, row.issueCode, row.message, row.path, row.agentId],
+      query
+    );
+  }
+  if (row.kind === "unmanaged") {
+    return includesQuery(
+      [row.id, row.skillName, row.name, row.path, row.agentId],
+      query
+    );
+  }
+  return includesQuery([row.id, row.skillId, row.name, row.path, row.agentId], query);
+}
+function replaceModelSelection(state, selection) {
+  return {
+    ...state,
+    model: {
+      ...state.model,
+      ...selection
+    }
+  };
+}
+function clearTransientIntent(state) {
+  return {
+    ...state,
+    pendingAction: null,
+    statusMessage: null
+  };
+}
+function restoreSearchSelection(state) {
+  if (state.search === null) {
+    return state;
+  }
+  const previousSelection = state.search.previousSelection;
+  return {
+    ...state,
+    model: {
+      ...state.model,
+      selectedAgentId: previousSelection.selectedAgentId,
+      selectedSkillId: previousSelection.selectedSkillId
+    },
+    agentCursor: previousSelection.agentCursor,
+    skillCursor: previousSelection.skillCursor,
+    pendingAgentId: previousSelection.pendingAgentId
+  };
+}
+function searchHasVisibleResults(state) {
+  if (state.search === null) {
+    return false;
+  }
+  return state.search.panel === "agents" ? getVisibleAgents(state).length > 0 : getVisibleSkills(state).length > 0;
+}
+function selectedAgentIndex(model) {
+  if (model.selectedAgentId === null) {
+    return 0;
+  }
+  const index = model.agents.findIndex((row) => row.id === model.selectedAgentId);
+  return index < 0 ? 0 : index;
+}
+function selectedSkillIndex(model) {
+  if (model.selectedSkillId === null) {
+    return 0;
+  }
+  const index = model.skills.findIndex((row) => row.id === model.selectedSkillId);
+  return index < 0 ? 0 : index;
+}
+function selectedAgentSkill(skills, agentId) {
+  if (agentId === null) {
+    return null;
+  }
+  return skills.find((row) => row.agentId === agentId) ?? null;
+}
+function selectedAgentRow(state) {
+  if (state.model.selectedAgentId === null) {
+    return null;
+  }
+  return state.model.agents.find((row) => row.id === state.model.selectedAgentId) ?? null;
+}
+function moveFocus(focus, direction) {
+  const currentIndex = focusOrder.indexOf(focus);
+  const nextIndex = (currentIndex + direction + focusOrder.length) % focusOrder.length;
+  return focusOrder[nextIndex] ?? "agents";
+}
+function stateWithAgentCursor(state, cursor) {
+  const visibleAgents = getVisibleAgents(state);
+  const agentCursor = clampCursor(cursor, visibleAgents.length);
+  const selectedAgent = visibleAgents[agentCursor] ?? null;
+  const selectedSkill = selectedAgentSkill(state.model.skills, selectedAgent?.id ?? null);
+  const previousAgentId = state.model.selectedAgentId;
+  const selectedAgentId = selectedAgent?.id ?? null;
+  const model = {
+    ...state.model,
+    selectedAgentId,
+    selectedSkillId: selectedSkill?.id ?? null
+  };
+  const skillCursor = selectedSkill === null ? 0 : clampCursor(
+    getVisibleSkills({ ...state, model }).findIndex(
+      (row) => row.id === selectedSkill.id
+    ),
+    getVisibleSkills({ ...state, model }).length
+  );
+  return {
+    ...state,
+    model,
+    agentCursor,
+    skillCursor,
+    pendingAgentId: selectedAgentId !== null && selectedAgentId !== previousAgentId ? selectedAgentId : state.pendingAgentId
+  };
+}
+function stateWithSkillCursor(state, cursor) {
+  const visibleSkills = getVisibleSkills(state);
+  const skillCursor = clampCursor(cursor, visibleSkills.length);
+  const selectedSkill = visibleSkills[skillCursor] ?? null;
+  return replaceModelSelection(
+    {
+      ...state,
+      skillCursor
+    },
+    {
+      selectedAgentId: state.model.selectedAgentId,
+      selectedSkillId: selectedSkill?.id ?? null
+    }
+  );
+}
+function moveCursor(state, cursor) {
+  if (state.focus === "agents") {
+    return stateWithAgentCursor(state, cursor);
+  }
+  if (state.focus === "skills") {
+    return stateWithSkillCursor(state, cursor);
+  }
+  return state;
+}
+function isModalBackgroundEvent(event) {
+  return event.type === "focus-next" || event.type === "focus-previous" || event.type === "next-row" || event.type === "previous-row" || event.type === "first-row" || event.type === "last-row" || event.type === "open-search" || event.type === "search-query-changed" || event.type === "open-help" || event.type === "request-adopt" || event.type === "request-adopt-all" || event.type === "request-remove" || event.type === "request-toggle" || event.type === "request-scan" || event.type === "clear-pending-action";
+}
+function getVisibleAgents(state) {
+  if (state.search?.panel !== "agents") {
+    return state.model.agents.filter(
+      (row) => isRelevantAgentRow(row, state.model.selectedAgentId)
+    );
+  }
+  return state.model.agents.filter(
+    (row) => includesQuery([row.id, row.name, row.path, row.discovery], state.search?.query ?? "")
+  );
+}
+function getVisibleSkills(state) {
+  if (state.model.selectedAgentId === null) {
+    return [];
+  }
+  const agentSkills = state.model.skills.filter((row) => row.agentId === state.model.selectedAgentId);
+  if (state.search?.panel !== "skills") {
+    return agentSkills;
+  }
+  return agentSkills.filter((row) => skillMatchesQuery(row, state.search?.query ?? ""));
+}
+function getSelectedSkill(state) {
+  if (state.model.selectedSkillId === null) {
+    return null;
+  }
+  return state.model.skills.find((row) => row.id === state.model.selectedSkillId) ?? null;
+}
+function getAvailableActions(state) {
+  const selectedSkill = getSelectedSkill(state);
+  const selectedAgent = selectedAgentRow(state);
+  const canAcceptActions = state.modal === null && !state.busy;
+  const hasFocusedSkill = canAcceptActions && state.focus === "skills";
+  return {
+    toggle: hasFocusedSkill && (selectedSkill?.kind === "enabled" || selectedSkill?.kind === "disabled"),
+    adopt: hasFocusedSkill && selectedSkill?.kind === "unmanaged",
+    adoptAll: canAcceptActions && (selectedAgent?.unmanagedCount ?? 0) > 0,
+    remove: hasFocusedSkill && selectedSkill?.kind === "disabled",
+    scan: canAcceptActions,
+    help: canAcceptActions
+  };
+}
+function consumeActionIntent(state) {
+  return {
+    state: {
+      ...state,
+      pendingAction: null
+    },
+    action: state.pendingAction
+  };
+}
+function consumeAgentSelectionIntent(state) {
+  return {
+    state: {
+      ...state,
+      pendingAgentId: null
+    },
+    agentId: state.pendingAgentId
+  };
+}
+function createInitialTuiState(model) {
+  const state = {
+    model,
+    focus: "agents",
+    agentCursor: selectedAgentIndex(model),
+    skillCursor: selectedSkillIndex(model),
+    search: null,
+    statusMessage: null,
+    modal: null,
+    busy: false,
+    pendingAction: null,
+    pendingAgentId: null
+  };
+  return {
+    ...state,
+    agentCursor: clampCursor(state.agentCursor, getVisibleAgents(state).length),
+    skillCursor: clampCursor(state.skillCursor, getVisibleSkills(state).length)
+  };
+}
+function updateTuiState(state, event) {
+  if (state.modal !== null) {
+    if (event.type === "close") {
+      return {
+        ...state,
+        modal: null,
+        pendingAction: null
+      };
+    }
+    if (event.type === "set-busy") {
+      return {
+        ...state,
+        busy: event.busy
+      };
+    }
+    if (event.type === "set-status") {
+      return {
+        ...state,
+        statusMessage: event.message
+      };
+    }
+    if (isModalBackgroundEvent(event)) {
+      return state;
+    }
+  }
+  if (state.busy) {
+    if (event.type === "set-busy") {
+      return {
+        ...state,
+        busy: event.busy
+      };
+    }
+    if (event.type === "set-status") {
+      return {
+        ...state,
+        statusMessage: event.message
+      };
+    }
+    if (event.type === "request-toggle" || event.type === "request-adopt" || event.type === "request-remove" || event.type === "request-scan" || event.type === "open-help") {
+      return {
+        ...state,
+        pendingAction: null
+      };
+    }
+  }
+  const readyState = clearTransientIntent(state);
+  if (event.type === "focus-next") {
+    return {
+      ...readyState,
+      focus: moveFocus(state.focus, 1)
+    };
+  }
+  if (event.type === "focus-previous") {
+    return {
+      ...readyState,
+      focus: moveFocus(state.focus, -1)
+    };
+  }
+  if (event.type === "next-row") {
+    return moveCursor(
+      readyState,
+      state.focus === "agents" ? state.agentCursor + 1 : state.skillCursor + 1
+    );
+  }
+  if (event.type === "previous-row") {
+    return moveCursor(
+      readyState,
+      state.focus === "agents" ? state.agentCursor - 1 : state.skillCursor - 1
+    );
+  }
+  if (event.type === "first-row") {
+    return moveCursor(readyState, 0);
+  }
+  if (event.type === "last-row") {
+    const rowCount = state.focus === "agents" ? getVisibleAgents(state).length : getVisibleSkills(state).length;
+    return moveCursor(readyState, rowCount - 1);
+  }
+  if (event.type === "open-search") {
+    if (state.focus !== "agents" && state.focus !== "skills") {
+      return {
+        ...readyState,
+        statusMessage: "Search is available for agents and skills"
+      };
+    }
+    return {
+      ...readyState,
+      search: {
+        panel: state.focus,
+        query: "",
+        previousSelection: {
+          selectedAgentId: state.model.selectedAgentId,
+          selectedSkillId: state.model.selectedSkillId,
+          agentCursor: state.agentCursor,
+          skillCursor: state.skillCursor,
+          pendingAgentId: state.pendingAgentId
+        }
+      }
+    };
+  }
+  if (event.type === "search-query-changed") {
+    if (state.search === null) {
+      return readyState;
+    }
+    const searchedState = {
+      ...readyState,
+      search: {
+        ...state.search,
+        query: event.query
+      }
+    };
+    const rowCount = searchedState.search.panel === "agents" ? getVisibleAgents(searchedState).length : getVisibleSkills(searchedState).length;
+    return searchedState.search.panel === "agents" ? stateWithAgentCursor(searchedState, clampCursor(searchedState.agentCursor, rowCount)) : stateWithSkillCursor(searchedState, clampCursor(searchedState.skillCursor, rowCount));
+  }
+  if (event.type === "close") {
+    if (state.search !== null) {
+      return {
+        ...restoreSearchSelection(readyState),
+        search: null
+      };
+    }
+    if (state.modal !== null) {
+      return {
+        ...readyState,
+        modal: null
+      };
+    }
+    return readyState;
+  }
+  if (event.type === "submit-search") {
+    if (state.search !== null) {
+      if (!searchHasVisibleResults(state)) {
+        return {
+          ...restoreSearchSelection(readyState),
+          search: null
+        };
+      }
+      return {
+        ...readyState,
+        search: null
+      };
+    }
+    return readyState;
+  }
+  if (event.type === "open-help") {
+    return {
+      ...readyState,
+      modal: { kind: "help" }
+    };
+  }
+  if (event.type === "request-adopt") {
+    if (state.focus !== "skills") {
+      return readyState;
+    }
+    const selectedSkill = getSelectedSkill(state);
+    if (selectedSkill?.kind !== "unmanaged") {
+      return {
+        ...readyState,
+        statusMessage: "Adopt is only available for unmanaged rows"
+      };
+    }
+    return {
+      ...readyState,
+      modal: {
+        kind: "confirm-adopt",
+        skillId: selectedSkill.skillName,
+        agentId: selectedSkill.agentId
+      }
+    };
+  }
+  if (event.type === "request-adopt-all") {
+    const selectedAgent = selectedAgentRow(state);
+    if (selectedAgent === null) {
+      return {
+        ...readyState,
+        statusMessage: "Select an agent first"
+      };
+    }
+    if (selectedAgent.unmanagedCount <= 0) {
+      return {
+        ...readyState,
+        statusMessage: "No unmanaged skills to adopt for this agent"
+      };
+    }
+    return {
+      ...readyState,
+      modal: {
+        kind: "confirm-adopt-all",
+        agentId: selectedAgent.id,
+        unmanagedCount: selectedAgent.unmanagedCount
+      }
+    };
+  }
+  if (event.type === "request-remove") {
+    if (state.focus !== "skills") {
+      return readyState;
+    }
+    const selectedSkill = getSelectedSkill(state);
+    if (selectedSkill?.kind !== "disabled") {
+      return {
+        ...readyState,
+        statusMessage: selectedSkill?.kind === "enabled" ? "Disable this skill before removing it" : "Remove is only available for disabled rows"
+      };
+    }
+    return {
+      ...readyState,
+      modal: {
+        kind: "confirm-remove",
+        skillId: selectedSkill.skillId
+      }
+    };
+  }
+  if (event.type === "request-toggle") {
+    if (state.focus !== "skills") {
+      return readyState;
+    }
+    const selectedSkill = getSelectedSkill(state);
+    if (selectedSkill?.kind !== "enabled" && selectedSkill?.kind !== "disabled") {
+      return {
+        ...readyState,
+        statusMessage: "Toggle is only available for managed rows"
+      };
+    }
+    return {
+      ...readyState,
+      pendingAction: "toggle"
+    };
+  }
+  if (event.type === "request-scan") {
+    return {
+      ...readyState,
+      pendingAction: "scan"
+    };
+  }
+  if (event.type === "set-busy") {
+    return {
+      ...readyState,
+      busy: event.busy
+    };
+  }
+  if (event.type === "set-status") {
+    return {
+      ...readyState,
+      statusMessage: event.message
+    };
+  }
+  return readyState;
+}
+
+// src/tui/components/AgentList.tsx
+import { Box, Text } from "ink";
+import { jsx, jsxs } from "react/jsx-runtime";
+function statusMarker(agent) {
+  if (!agent.supported) {
+    return "!";
+  }
+  if (!agent.exists) {
+    return "?";
+  }
+  return "*";
+}
+function statusColor(agent) {
+  if (!agent.supported) {
+    return "red";
+  }
+  if (!agent.exists || agent.issueCount > 0) {
+    return "yellow";
+  }
+  return "green";
+}
+function AgentList({
+  agents,
+  selectedAgentId,
+  focused,
+  searchQuery,
+  width = 24,
+  height = 18
+}) {
+  const emptyMessage = searchQuery !== void 0 && searchQuery.trim().length > 0 ? "No matching agents" : "No agents found";
+  return /* @__PURE__ */ jsxs(Box, { flexDirection: "column", width, height, children: [
+    /* @__PURE__ */ jsx(Text, { bold: true, color: focused ? "cyan" : void 0, children: "Agents" }),
+    agents.length === 0 ? /* @__PURE__ */ jsx(Text, { dimColor: true, children: emptyMessage }) : agents.map((agent) => {
+      const selected = agent.id === selectedAgentId;
+      const selectionPrefix = selected ? ">" : " ";
+      return /* @__PURE__ */ jsxs(Text, { inverse: selected, children: [
+        /* @__PURE__ */ jsx(Text, { color: statusColor(agent), children: statusMarker(agent) }),
+        /* @__PURE__ */ jsxs(Text, { children: [
+          selectionPrefix,
+          " ",
+          agent.name
+        ] })
+      ] }, agent.id);
+    })
+  ] });
+}
+
+// src/tui/components/ConfirmDialog.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var confirmDialogHeight = 4;
+function confirmationText(modal) {
+  if (modal.kind === "confirm-adopt") {
+    return `Adopt ${modal.skillId} for ${modal.agentId}?`;
+  }
+  if (modal.kind === "confirm-adopt-all") {
+    return `Adopt all unmanaged skills for ${modal.agentId}?`;
+  }
+  return `Remove ${modal.skillId} from SkillMux?`;
+}
+function confirmationDetails(modal) {
+  if (modal.kind !== "confirm-adopt-all") {
+    return null;
+  }
+  return `${modal.unmanagedCount} unmanaged skills will be moved under SkillMux management.`;
+}
+function ConfirmDialog({ modal }) {
+  return /* @__PURE__ */ jsxs2(Box2, { flexDirection: "column", height: confirmDialogHeight, children: [
+    /* @__PURE__ */ jsx2(Text2, { bold: true, color: modal.kind === "confirm-remove" ? "yellow" : "cyan", children: "Confirm" }),
+    /* @__PURE__ */ jsx2(Text2, { children: confirmationText(modal) }),
+    confirmationDetails(modal) === null ? null : /* @__PURE__ */ jsx2(Text2, { children: confirmationDetails(modal) }),
+    /* @__PURE__ */ jsx2(Text2, { children: "[y] confirm   [Esc] cancel" })
+  ] });
+}
+
+// src/tui/components/DetailPane.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function compactPath(value, maxLength) {
+  if (value.length <= maxLength) {
+    return value;
+  }
+  const separator = value.includes("\\") ? "\\" : "/";
+  const parts = value.split(/[\\/]+/).filter((part) => part.length > 0);
+  let suffix = parts.at(-1) ?? value;
+  for (let index = parts.length - 2; index >= 0; index -= 1) {
+    const candidate = `${parts[index]}${separator}${suffix}`;
+    if (`...${separator}${candidate}`.length > maxLength) {
+      break;
+    }
+    suffix = candidate;
+  }
+  const shortened = `...${separator}${suffix}`;
+  if (shortened.length <= maxLength) {
+    return shortened;
+  }
+  if (maxLength <= 3) {
+    return ".".repeat(maxLength);
+  }
+  return `...${suffix.slice(-(maxLength - 3))}`;
+}
+function detailLines(skill) {
+  if (skill.kind === "enabled") {
+    return [
+      { label: "Name", value: skill.name, compact: false },
+      { label: "Status", value: "enabled", compact: false },
+      { label: "Store", value: skill.path, compact: true },
+      { label: "Link", value: skill.activationLinkPath, compact: true }
+    ];
+  }
+  if (skill.kind === "disabled") {
+    return [
+      { label: "Name", value: skill.name, compact: false },
+      { label: "Status", value: "disabled", compact: false },
+      { label: "Store", value: skill.path, compact: true },
+      {
+        label: "Link",
+        value: skill.activationLinkPath ?? "not linked",
+        compact: skill.activationLinkPath !== null
+      }
+    ];
+  }
+  if (skill.kind === "unmanaged") {
+    return [
+      { label: "Name", value: skill.name, compact: false },
+      { label: "Status", value: "unmanaged", compact: false },
+      { label: "Entry", value: skill.entryKind, compact: false },
+      { label: "Path", value: skill.path, compact: true }
+    ];
+  }
+  return [
+    { label: "Status", value: "issue", compact: false },
+    { label: "Code", value: skill.issueCode, compact: false },
+    { label: "Severity", value: skill.severity, compact: false },
+    { label: "Message", value: skill.message, compact: false },
+    { label: "Path", value: skill.path ?? "none", compact: skill.path !== null }
+  ];
+}
+function DetailPane({
+  selectedAgent,
+  selectedSkill,
+  focused: _focused,
+  loadingAgentName = null,
+  width = 28,
+  height = 18
+}) {
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width, height, children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Detail" }),
+    selectedAgent === null ? /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Select an agent" }) : /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      "Agent: ",
+      selectedAgent.name
+    ] }),
+    selectedSkill === null ? loadingAgentName !== null ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+      "Loading details for ",
+      loadingAgentName,
+      "..."
+    ] }) : /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "Select a skill row" }) : detailLines(selectedSkill).map(({ label, value, compact }) => {
+      const valueWidth = Math.max(width - (label.length + 2), 8);
+      const renderedValue = compact ? compactPath(value, valueWidth) : value;
+      return /* @__PURE__ */ jsxs3(Text3, { children: [
+        /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+          label,
+          ": "
+        ] }),
+        /* @__PURE__ */ jsx3(Text3, { children: renderedValue })
+      ] }, label);
+    })
+  ] });
+}
+
+// src/tui/components/Footer.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { Fragment, jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var agentLegend = "Agent icons: * ready  yellow * issues  ? missing  ! unsupported";
+var skillLegend = "Skill markers: \u25CF enabled  \u25CB disabled  ? unmanaged  ! issue";
+function Footer({ actions, search }) {
+  const shortcuts = [
+    "[Left/Right]focus",
+    actions.toggle ? "[Space]toggle" : null,
+    actions.adopt ? "[a]adopt" : null,
+    actions.adoptAll ? "[Shift+A]adopt all" : null,
+    actions.remove ? "[r]remove" : null,
+    actions.scan ? "[s]scan" : null,
+    actions.help ? "[?]help" : null,
+    "[q]quit"
+  ].filter((shortcut) => shortcut !== null);
+  return /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", height: 3, children: search === null ? /* @__PURE__ */ jsxs4(Fragment, { children: [
+    /* @__PURE__ */ jsx4(Text4, { children: shortcuts.join("   ") }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: agentLegend }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: skillLegend })
+  ] }) : /* @__PURE__ */ jsxs4(Text4, { children: [
+    /* @__PURE__ */ jsx4(Text4, { color: "cyan", children: "/" }),
+    /* @__PURE__ */ jsx4(Text4, { children: search.query }),
+    /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "   [Enter]keep   [Esc]cancel" })
+  ] }) });
+}
+
+// src/tui/components/HelpOverlay.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function HelpOverlay() {
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", height: 8, children: [
+    /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Help" }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Navigation" }),
+      /* @__PURE__ */ jsx5(Text5, { children: ": Left/Right switch panels, j/k or Up/Down move, g/G jump." })
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Actions" }),
+      /* @__PURE__ */ jsx5(Text5, { children: ": Space toggles, a adopts, Shift+A current-agent bulk adopt, r removes, s scans." })
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Search" }),
+      /* @__PURE__ */ jsx5(Text5, { children: ": / filters the focused list, Enter keeps the result, Esc cancels." })
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Agent icons" }),
+      /* @__PURE__ */ jsx5(Text5, { children: ": * ready, yellow * issues, ? missing, ! unsupported." })
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Skill markers" }),
+      /* @__PURE__ */ jsx5(Text5, { children: ": \u25CF enabled, \u25CB disabled, ? unmanaged, ! issue." })
+    ] }),
+    /* @__PURE__ */ jsxs5(Text5, { children: [
+      /* @__PURE__ */ jsx5(Text5, { bold: true, children: "Safety" }),
+      /* @__PURE__ */ jsx5(Text5, { children: ": Toggle, adopt, remove, and scan can update SkillMux state and agent links." })
+    ] })
+  ] });
+}
+
+// src/tui/components/SkillList.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function markerColor(skill) {
+  if (skill.kind === "enabled") {
+    return "green";
+  }
+  if (skill.kind === "issue") {
+    return skill.severity === "error" ? "red" : "yellow";
+  }
+  if (skill.kind === "unmanaged") {
+    return "yellow";
+  }
+  return "gray";
+}
+function skillLabel(skill) {
+  if (skill.kind === "issue") {
+    return skill.issueCode;
+  }
+  return skill.name;
+}
+function SkillList({
+  agentId,
+  skills,
+  selectedSkillId,
+  focused,
+  searchQuery,
+  loadingAgentName = null,
+  width = 28,
+  height = 18
+}) {
+  const emptyMessage = loadingAgentName !== null ? `Loading skills for ${loadingAgentName}...` : agentId === null ? "Select an agent" : searchQuery !== void 0 && searchQuery.trim().length > 0 ? "No matching skills" : "No skills for this agent";
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", width, height, children: [
+    /* @__PURE__ */ jsxs6(Text6, { bold: true, color: focused ? "cyan" : void 0, children: [
+      "Skills for ",
+      agentId ?? "none"
+    ] }),
+    skills.length === 0 ? /* @__PURE__ */ jsx6(Text6, { dimColor: true, children: emptyMessage }) : skills.map((skill) => {
+      const selected = skill.id === selectedSkillId;
+      return /* @__PURE__ */ jsxs6(Text6, { inverse: focused && selected, children: [
+        /* @__PURE__ */ jsx6(Text6, { color: markerColor(skill), children: skill.marker }),
+        /* @__PURE__ */ jsxs6(Text6, { children: [
+          " ",
+          skillLabel(skill)
+        ] })
+      ] }, skill.id);
+    })
+  ] });
+}
+
+// src/tui/components/StatusLine.tsx
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7 } from "react/jsx-runtime";
+function StatusLine({
+  busy,
+  statusMessage,
+  lastScanAt,
+  issueCount
+}) {
+  const message = statusMessage ?? (busy ? "scanning..." : `Last scan: ${lastScanAt ?? "never"} | issues: ${issueCount}`);
+  return /* @__PURE__ */ jsx7(Box7, { height: 1, children: /* @__PURE__ */ jsx7(Text7, { color: busy ? "cyan" : void 0, children: message }) });
+}
+
+// src/tui/components/Dashboard.tsx
+import { jsx as jsx8, jsxs as jsxs7 } from "react/jsx-runtime";
+var minimumWidth = 80;
+var minimumHeight = 24;
+var agentRatio = 0.26;
+var skillRatio = 0.3;
+var detailRatio = 0.44;
+var agentMinimumWidth = 20;
+var skillMinimumWidth = 24;
+var detailMinimumWidth = 28;
+function paneWidths(width) {
+  const agentWidth = Math.max(agentMinimumWidth, Math.round(width * agentRatio));
+  const skillWidth = Math.max(skillMinimumWidth, Math.round(width * skillRatio));
+  const detailWidth = Math.max(
+    detailMinimumWidth,
+    Math.round(width * detailRatio)
+  );
+  const widthDelta = width - (agentWidth + skillWidth + detailWidth);
+  if (widthDelta === 0) {
+    return { agentWidth, skillWidth, detailWidth };
+  }
+  return {
+    agentWidth,
+    skillWidth,
+    detailWidth: detailWidth + widthDelta
+  };
+}
+function Dashboard({
+  state,
+  width,
+  height
+}) {
+  if (width < minimumWidth || height < minimumHeight) {
+    return /* @__PURE__ */ jsx8(
+      Box8,
+      {
+        flexDirection: "column",
+        width,
+        height,
+        justifyContent: "center",
+        alignItems: "center",
+        children: /* @__PURE__ */ jsx8(Text8, { children: "Terminal too small. Resize to at least 80x24." })
+      }
+    );
+  }
+  const visibleAgents = getVisibleAgents(state);
+  const visibleSkills = getVisibleSkills(state);
+  const selectedAgent = state.model.agents.find((agent) => agent.id === state.model.selectedAgentId) ?? null;
+  const selectedSkill = getSelectedSkill(state);
+  const loadingAgentName = state.pendingAgentId ?? (state.busy && state.statusMessage === "loading agent..." ? state.model.selectedAgentId : null);
+  const loadingAgent = loadingAgentName === null ? null : state.model.agents.find((agent) => agent.id === loadingAgentName) ?? null;
+  const actions = getAvailableActions(state);
+  const footerHeight = 3;
+  const overlayHeight = state.modal?.kind === "help" ? 8 : state.modal?.kind === "confirm-adopt" || state.modal?.kind === "confirm-adopt-all" || state.modal?.kind === "confirm-remove" ? confirmDialogHeight : 0;
+  const bodyHeight = Math.max(height - 1 - footerHeight - overlayHeight, 0);
+  const { agentWidth, skillWidth, detailWidth } = paneWidths(width);
+  return /* @__PURE__ */ jsxs7(Box8, { flexDirection: "column", width, height, children: [
+    /* @__PURE__ */ jsx8(
+      StatusLine,
+      {
+        busy: state.busy,
+        statusMessage: state.statusMessage,
+        lastScanAt: state.model.lastScanAt,
+        issueCount: state.model.issueCount
+      }
+    ),
+    /* @__PURE__ */ jsxs7(Box8, { flexDirection: "row", width, height: bodyHeight, children: [
+      /* @__PURE__ */ jsx8(
+        AgentList,
+        {
+          agents: visibleAgents,
+          selectedAgentId: state.model.selectedAgentId,
+          focused: state.focus === "agents",
+          searchQuery: state.search?.panel === "agents" ? state.search.query : void 0,
+          width: agentWidth,
+          height: bodyHeight
+        }
+      ),
+      /* @__PURE__ */ jsx8(
+        SkillList,
+        {
+          agentId: state.model.selectedAgentId,
+          skills: visibleSkills,
+          selectedSkillId: state.model.selectedSkillId,
+          focused: state.focus === "skills",
+          searchQuery: state.search?.panel === "skills" ? state.search.query : void 0,
+          loadingAgentName: loadingAgent?.name ?? null,
+          width: skillWidth,
+          height: bodyHeight
+        }
+      ),
+      /* @__PURE__ */ jsx8(
+        DetailPane,
+        {
+          selectedAgent,
+          selectedSkill,
+          focused: state.focus === "detail",
+          loadingAgentName: loadingAgent?.name ?? null,
+          width: detailWidth,
+          height: bodyHeight
+        }
+      )
+    ] }),
+    state.modal?.kind === "help" ? /* @__PURE__ */ jsx8(HelpOverlay, {}) : null,
+    state.modal?.kind === "confirm-adopt" || state.modal?.kind === "confirm-adopt-all" || state.modal?.kind === "confirm-remove" ? /* @__PURE__ */ jsx8(ConfirmDialog, { modal: state.modal }) : null,
+    state.modal === null ? /* @__PURE__ */ jsx8(Footer, { actions, search: state.search }) : /* @__PURE__ */ jsx8(Box8, { height: 3 })
+  ] });
+}
+
+// src/tui/app.tsx
+import { jsx as jsx9 } from "react/jsx-runtime";
+var defaultServices2 = {
+  loadDashboardState,
+  dispatchTuiAction
+};
+function errorReason2(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  const firstLine = message.split(/\r?\n/u)[0]?.trim();
+  return firstLine === void 0 || firstLine.length === 0 ? "Unknown error" : firstLine;
+}
+function loadOptions(props, selectedAgentId, selectedSkillId) {
+  return {
+    homeDir: props.homeDir,
+    skillmuxHome: props.skillmuxHome,
+    platform: props.platform,
+    selectedAgentId,
+    selectedSkillId
+  };
+}
+function replaceStateModel(previous, model, statusMessage) {
+  const next = createInitialTuiState(model);
+  return {
+    ...next,
+    focus: previous.focus,
+    search: previous.search,
+    statusMessage,
+    modal: null,
+    busy: false
+  };
+}
+function isTextInput(input) {
+  return input.length > 0 && !/[\u0000-\u001F\u007F]/u.test(input);
+}
+function parseBridgedSize(value) {
+  try {
+    const parsed = JSON.parse(value);
+    if (typeof parsed.columns === "number" && typeof parsed.rows === "number" && Number.isFinite(parsed.columns) && Number.isFinite(parsed.rows)) {
+      return {
+        columns: parsed.columns,
+        rows: parsed.rows
+      };
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+function liveTerminalSize() {
+  return {
+    columns: process.stdout.columns ?? 80,
+    rows: process.stdout.rows ?? 24
+  };
+}
+function readSizeFile(path) {
+  try {
+    return parseBridgedSize(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+function useBridgedTerminalSize(path) {
+  const [size, setSize] = useState(
+    () => path === null ? null : readSizeFile(path)
+  );
+  useEffect(() => {
+    if (path === null) {
+      setSize(null);
+      return;
+    }
+    let cancelled = false;
+    const refresh = () => {
+      if (cancelled) {
+        return;
+      }
+      const nextSize = readSizeFile(path);
+      setSize(
+        (current) => nextSize === null ? current : current !== null && current.columns === nextSize.columns && current.rows === nextSize.rows ? current : nextSize
+      );
+    };
+    refresh();
+    const timer = setInterval(refresh, 50);
+    return () => {
+      cancelled = true;
+      clearInterval(timer);
+    };
+  }, [path]);
+  return size;
+}
+function LiveDashboardViewport({
+  state,
+  terminalWidth,
+  terminalHeight
+}) {
+  return /* @__PURE__ */ jsx9(
+    Dashboard,
+    {
+      state,
+      width: terminalWidth ?? liveTerminalSize().columns,
+      height: terminalHeight ?? liveTerminalSize().rows
+    }
+  );
+}
+function BridgedDashboardViewport({
+  state,
+  terminalWidth,
+  terminalHeight,
+  bridgePath
+}) {
+  const bridgedTerminalSize = useBridgedTerminalSize(bridgePath ?? null);
+  const fallbackSize = liveTerminalSize();
+  return /* @__PURE__ */ jsx9(
+    Dashboard,
+    {
+      state,
+      width: terminalWidth ?? bridgedTerminalSize?.columns ?? fallbackSize.columns,
+      height: terminalHeight ?? bridgedTerminalSize?.rows ?? fallbackSize.rows
+    }
+  );
+}
+function App({
+  homeDir,
+  skillmuxHome,
+  platform,
+  terminalWidth,
+  terminalHeight,
+  services: serviceOverrides
+}) {
+  const { exit } = useApp();
+  const [state, setState] = useState(null);
+  const [loadError, setLoadError] = useState(null);
+  const requestSequence = useRef(0);
+  const latestRequest = useRef(0);
+  const activeActionRequest = useRef(null);
+  const stableModel = useRef(null);
+  const services = useMemo(
+    () => ({ ...defaultServices2, ...serviceOverrides }),
+    [serviceOverrides]
+  );
+  const sizeBridgePath = process.env.SKILLMUX_TUI_PTY_SIZE_FILE?.trim() ?? null;
+  const sizeBridgeEnabled = sizeBridgePath !== null && sizeBridgePath.length > 0;
+  const beginRequest = useCallback(() => {
+    requestSequence.current += 1;
+    latestRequest.current = requestSequence.current;
+    return requestSequence.current;
+  }, []);
+  const isLatestRequest = useCallback((requestId) => {
+    return latestRequest.current === requestId;
+  }, []);
+  const startBusyState = useCallback(
+    (baseState, action) => updateTuiState(
+      updateTuiState(baseState, { type: "set-busy", busy: true }),
+      {
+        type: "set-status",
+        message: action === "scan" ? "scanning..." : "working..."
+      }
+    ),
+    []
+  );
+  useEffect(() => {
+    let cancelled = false;
+    services.loadDashboardState(loadOptions({ homeDir, skillmuxHome, platform })).then((model) => {
+      if (!cancelled) {
+        stableModel.current = model;
+        setState(createInitialTuiState(model));
+        setLoadError(null);
+      }
+    }).catch((error) => {
+      if (!cancelled) {
+        setLoadError(`Failed to load dashboard: ${errorReason2(error)}`);
+      }
+    });
+    return () => {
+      cancelled = true;
+    };
+  }, [homeDir, platform, services, skillmuxHome]);
+  const runAction = useCallback(
+    (action, model, baseState) => {
+      if (activeActionRequest.current !== null) {
+        return;
+      }
+      const requestId = beginRequest();
+      activeActionRequest.current = requestId;
+      setState(
+        (current) => current === null ? current : startBusyState(baseState ?? current, action)
+      );
+      services.dispatchTuiAction({
+        action,
+        model,
+        homeDir,
+        skillmuxHome,
+        platform
+      }).then((result) => {
+        if (!isLatestRequest(requestId)) {
+          return;
+        }
+        stableModel.current = result.model;
+        setState(
+          (current) => current === null ? current : replaceStateModel(current, result.model, result.statusMessage)
+        );
+      }).catch((error) => {
+        if (!isLatestRequest(requestId)) {
+          return;
+        }
+        setState(
+          (current) => current === null ? current : updateTuiState(
+            updateTuiState(current, { type: "set-busy", busy: false }),
+            {
+              type: "set-status",
+              message: `Action failed: ${errorReason2(error)}`
+            }
+          )
+        );
+      }).finally(() => {
+        if (activeActionRequest.current === requestId) {
+          activeActionRequest.current = null;
+        }
+      });
+    },
+    [
+      beginRequest,
+      homeDir,
+      isLatestRequest,
+      platform,
+      services,
+      skillmuxHome,
+      startBusyState
+    ]
+  );
+  const reloadAgent = useCallback(
+    (agentId) => {
+      const requestId = beginRequest();
+      setState(
+        (current) => current === null ? current : updateTuiState(
+          updateTuiState(current, { type: "set-busy", busy: true }),
+          { type: "set-status", message: "loading agent..." }
+        )
+      );
+      services.loadDashboardState(loadOptions({ homeDir, skillmuxHome, platform }, agentId)).then((model) => {
+        if (!isLatestRequest(requestId)) {
+          return;
+        }
+        stableModel.current = model;
+        setState(
+          (current) => current === null ? current : replaceStateModel(current, model, null)
+        );
+      }).catch((error) => {
+        if (!isLatestRequest(requestId)) {
+          return;
+        }
+        setState(
+          (current) => current === null ? current : stableModel.current === null ? updateTuiState(
+            updateTuiState(current, { type: "set-busy", busy: false }),
+            {
+              type: "set-status",
+              message: `Load failed: ${errorReason2(error)}`
+            }
+          ) : replaceStateModel(
+            current,
+            stableModel.current,
+            `Load failed: ${errorReason2(error)}`
+          )
+        );
+      });
+    },
+    [beginRequest, homeDir, isLatestRequest, platform, services, skillmuxHome]
+  );
+  useEffect(() => {
+    if (state?.pendingAction === null || state?.pendingAction === void 0) {
+      return;
+    }
+    const consumed = consumeActionIntent(state);
+    setState(consumed.state);
+    if (consumed.action !== null) {
+      runAction(consumed.action, consumed.state.model);
+    }
+  }, [runAction, state]);
+  useEffect(() => {
+    if (state?.pendingAgentId === null || state?.pendingAgentId === void 0) {
+      return;
+    }
+    const consumed = consumeAgentSelectionIntent(state);
+    setState(consumed.state);
+    if (consumed.agentId !== null) {
+      reloadAgent(consumed.agentId);
+    }
+  }, [reloadAgent, state]);
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      exit();
+      return;
+    }
+    if (state === null) {
+      if (input === "q") {
+        exit();
+      }
+      return;
+    }
+    if (state.search !== null) {
+      if (key.escape) {
+        setState(updateTuiState(state, { type: "close" }));
+        return;
+      }
+      if (key.return) {
+        setState(updateTuiState(state, { type: "submit-search" }));
+        return;
+      }
+      if (key.backspace || key.delete) {
+        setState(
+          updateTuiState(state, {
+            type: "search-query-changed",
+            query: state.search.query.slice(0, -1)
+          })
+        );
+        return;
+      }
+      if (!key.ctrl && !key.meta && isTextInput(input)) {
+        setState(
+          updateTuiState(state, {
+            type: "search-query-changed",
+            query: `${state.search.query}${input}`
+          })
+        );
+      }
+      return;
+    }
+    if (state.modal !== null) {
+      if (key.escape) {
+        setState(updateTuiState(state, { type: "close" }));
+        return;
+      }
+      if (input === "q") {
+        exit();
+        return;
+      }
+      if (activeActionRequest.current !== null) {
+        return;
+      }
+      if (input.toLocaleLowerCase() === "y" && state.modal.kind === "confirm-adopt") {
+        const closedState = updateTuiState(state, { type: "close" });
+        runAction("adopt", closedState.model, closedState);
+        return;
+      }
+      if (input.toLocaleLowerCase() === "y" && state.modal.kind === "confirm-adopt-all") {
+        const closedState = updateTuiState(state, { type: "close" });
+        runAction("adopt-all", closedState.model, closedState);
+        return;
+      }
+      if (input.toLocaleLowerCase() === "y" && state.modal.kind === "confirm-remove") {
+        const closedState = updateTuiState(state, { type: "close" });
+        runAction("remove", closedState.model, closedState);
+        return;
+      }
+      return;
+    }
+    if (input === "q") {
+      exit();
+      return;
+    }
+    if (activeActionRequest.current !== null) {
+      return;
+    }
+    if (key.rightArrow) {
+      setState(
+        updateTuiState(state, {
+          type: "focus-next"
+        })
+      );
+      return;
+    }
+    if (key.leftArrow) {
+      setState(
+        updateTuiState(state, {
+          type: "focus-previous"
+        })
+      );
+      return;
+    }
+    if (key.downArrow || input === "j") {
+      setState(updateTuiState(state, { type: "next-row" }));
+      return;
+    }
+    if (key.upArrow || input === "k") {
+      setState(updateTuiState(state, { type: "previous-row" }));
+      return;
+    }
+    if (input === "g") {
+      setState(updateTuiState(state, { type: "first-row" }));
+      return;
+    }
+    if (input === "G") {
+      setState(updateTuiState(state, { type: "last-row" }));
+      return;
+    }
+    if (input === "/") {
+      setState(updateTuiState(state, { type: "open-search" }));
+      return;
+    }
+    if (input === "?") {
+      setState(updateTuiState(state, { type: "open-help" }));
+      return;
+    }
+    if (key.escape) {
+      setState(updateTuiState(state, { type: "close" }));
+      return;
+    }
+    if (input === " ") {
+      setState(updateTuiState(state, { type: "request-toggle" }));
+      return;
+    }
+    if (input === "A" || key.shift && input === "a") {
+      setState(updateTuiState(state, { type: "request-adopt-all" }));
+      return;
+    }
+    if (input === "a") {
+      setState(updateTuiState(state, { type: "request-adopt" }));
+      return;
+    }
+    if (input === "r") {
+      setState(updateTuiState(state, { type: "request-remove" }));
+      return;
+    }
+    if (input === "s") {
+      setState(updateTuiState(state, { type: "request-scan" }));
+    }
+  });
+  if (loadError !== null) {
+    return /* @__PURE__ */ jsx9(Text9, { color: "red", children: loadError });
+  }
+  if (state === null) {
+    return /* @__PURE__ */ jsx9(Text9, { children: "loading dashboard..." });
+  }
+  return sizeBridgeEnabled ? /* @__PURE__ */ jsx9(
+    BridgedDashboardViewport,
+    {
+      state,
+      terminalWidth,
+      terminalHeight,
+      bridgePath: sizeBridgePath
+    }
+  ) : /* @__PURE__ */ jsx9(
+    LiveDashboardViewport,
+    {
+      state,
+      terminalWidth,
+      terminalHeight
+    }
+  );
+}
+
+// src/tui/launch-tui.tsx
+import { jsx as jsx10 } from "react/jsx-runtime";
+var alternateScreenEnter = "\x1B[?1049h";
+var alternateScreenExit = "\x1B[?1049l";
+var cursorHide = "\x1B[?25l";
+var cursorShow = "\x1B[?25h";
+var lifecycleTraceEnabled = process.env.SKILLMUX_TUI_PTY_TRACE === "1";
+async function launchTui(options = {}) {
+  let failure;
+  let instance = null;
+  let sigintRequested = false;
+  const handleSigint = () => {
+    sigintRequested = true;
+    instance?.unmount();
+  };
+  try {
+    process.once("SIGINT", handleSigint);
+    process.stdout.write(alternateScreenEnter);
+    process.stdout.write(cursorHide);
+    await writeLifecycleTrace("alt-screen-enter");
+    instance = render(/* @__PURE__ */ jsx10(App, { ...options }));
+    if (sigintRequested) {
+      instance.unmount();
+    }
+    await instance.waitUntilExit();
+    await writeLifecycleTrace("session-exit-clean");
+  } catch (error) {
+    failure = error;
+  } finally {
+    process.removeListener("SIGINT", handleSigint);
+    failure = await runCleanup(failure, () => writeLifecycleTrace("alt-screen-exit"));
+    failure = await runCleanup(failure, () => process.stdout.write(alternateScreenExit));
+    failure = await runCleanup(failure, () => process.stdout.write(cursorShow));
+  }
+  if (failure !== void 0) {
+    throw failure;
+  }
+}
+function writeLifecycleTrace(stage) {
+  if (!lifecycleTraceEnabled) {
+    return Promise.resolve();
+  }
+  process.stderr.write(`[skillmux:${stage}]
+`);
+  return stage === "session-exit-clean" ? sleep(0) : Promise.resolve();
+}
+async function runCleanup(failure, cleanup) {
+  try {
+    await cleanup();
+    return failure;
+  } catch (error) {
+    return failure === void 0 ? error : failure;
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+export {
+  launchTui
+};
+//# sourceMappingURL=launch-tui-PHWJPIQZ.js.map