skillmux 0.1.3 → 0.1.4

package/dist/launch-tui-IC7COEGE.js

@@ -0,0 +1,3188 @@
+import {
+  ManifestValidationError,
+  buildEmptyManifest,
+  collectDoctorIssues,
+  dedupeAndSortIssues,
+  discoverAgents,
+  formatValidationIssues,
+  isPathInside,
+  loadUserConfig,
+  manifestSchema,
+  normalizeAgentId,
+  resolveSkillmuxHome,
+  runAdopt,
+  runConfigAddAgent,
+  runConfigRemoveAgent,
+  runConfigUpdateAgent,
+  runDisable,
+  runDoctor,
+  runEnable,
+  runImport,
+  runRemove,
+  runScan,
+  scanAgentSkills
+} from "./chunk-EEIOA7GC.js";
+
+// src/tui/launch-tui.tsx
+import { render } from "ink";
+
+// src/tui/app.tsx
+import { readFileSync } from "fs";
+import { Text as Text11, useApp, useInput } from "ink";
+import { useCallback, useEffect, useMemo, useRef, useState } from "react";
+
+// src/tui/forms.ts
+function cloneValues(values) {
+  return Object.fromEntries(
+    Object.entries(values).map(([key, value]) => [
+      key,
+      Array.isArray(value) ? [...value] : value
+    ])
+  );
+}
+function isDirty(values, initialValues) {
+  return JSON.stringify(values) !== JSON.stringify(initialValues);
+}
+function trimOrEmpty(value) {
+  return (value ?? "").trim();
+}
+function normalizePlatformList(value) {
+  const platforms = value.map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0);
+  return platforms.length === 0 ? void 0 : [...new Set(platforms)];
+}
+function updateFormField(form, field, value) {
+  const nextValues = {
+    ...form.values,
+    [field]: value
+  };
+  return {
+    values: nextValues,
+    initialValues: form.initialValues,
+    dirty: isDirty(nextValues, form.initialValues),
+    error: null
+  };
+}
+function buildConfigAddAgentDefaults() {
+  return {
+    id: "",
+    root: "root",
+    skills: "skills",
+    name: "",
+    platforms: [],
+    disabledByDefault: false
+  };
+}
+function buildConfigUpdateAgentDefaults() {
+  return {
+    root: "",
+    skills: "skills",
+    name: "",
+    platforms: [],
+    enabledByDefault: false,
+    disabledByDefault: false,
+    preserveEnabledByDefault: false
+  };
+}
+function buildImportDefaults() {
+  return {
+    sourcePath: "",
+    skillName: ""
+  };
+}
+function normalizeConfigAddAgentValues(values) {
+  return {
+    id: trimOrEmpty(values.id),
+    root: trimOrEmpty(values.root),
+    skills: trimOrEmpty(values.skills) || void 0,
+    name: trimOrEmpty(values.name) || void 0,
+    platforms: normalizePlatformList(values.platforms),
+    disabledByDefault: values.disabledByDefault ? true : void 0
+  };
+}
+function normalizeConfigUpdateAgentValues(values, agentId) {
+  const enabledByDefault = values.enabledByDefault ? true : void 0;
+  const disabledByDefault = values.disabledByDefault ? true : void 0;
+  return {
+    id: agentId,
+    root: trimOrEmpty(values.root) || void 0,
+    skills: trimOrEmpty(values.skills) || void 0,
+    name: trimOrEmpty(values.name) || void 0,
+    platforms: normalizePlatformList(values.platforms),
+    ...values.preserveEnabledByDefault ? {} : {
+      enabledByDefault,
+      disabledByDefault
+    }
+  };
+}
+function normalizeImportValues(values) {
+  return {
+    sourcePath: trimOrEmpty(values.sourcePath),
+    skillName: trimOrEmpty(values.skillName)
+  };
+}
+function createConfigAddAgentForm(values = {}) {
+  const initialValues = {
+    ...buildConfigAddAgentDefaults(),
+    ...values
+  };
+  return {
+    values: cloneValues(initialValues),
+    initialValues: cloneValues(initialValues),
+    dirty: false,
+    error: null
+  };
+}
+function updateConfigAddAgentFormField(form, field, value) {
+  return updateFormField(form, field, value);
+}
+function validateConfigAddAgentForm(form) {
+  const values = normalizeConfigAddAgentValues(form.values);
+  if (values.id.length === 0 || values.root.length === 0) {
+    return "Agent id and root are required";
+  }
+  return null;
+}
+function buildRunConfigAddAgentOptions(form) {
+  return normalizeConfigAddAgentValues(form.values);
+}
+function normalizeRunConfigAddAgentOptions(input) {
+  return {
+    id: trimOrEmpty(input.id),
+    root: trimOrEmpty(input.root),
+    skills: input.skills === void 0 ? void 0 : trimOrEmpty(input.skills),
+    name: input.name === void 0 ? void 0 : trimOrEmpty(input.name),
+    platforms: input.platforms === void 0 ? void 0 : [...new Set(input.platforms.map((entry) => entry.trim().toLowerCase()).filter((entry) => entry.length > 0))],
+    disabledByDefault: input.disabledByDefault === true ? true : void 0
+  };
+}
+function createConfigUpdateAgentForm(values = {}) {
+  const initialValues = {
+    ...buildConfigUpdateAgentDefaults(),
+    ...values
+  };
+  return {
+    values: cloneValues(initialValues),
+    initialValues: cloneValues(initialValues),
+    dirty: false,
+    error: null
+  };
+}
+function updateConfigUpdateAgentFormField(form, field, value) {
+  const next = field === "enabledByDefault" && value === true ? updateFormField(
+    updateFormField(form, field, value),
+    "disabledByDefault",
+    false
+  ) : field === "disabledByDefault" && value === true ? updateFormField(updateFormField(form, field, value), "enabledByDefault", false) : updateFormField(form, field, value);
+  return {
+    ...next,
+    values: {
+      ...next.values,
+      enabledByDefault: field === "disabledByDefault" && value === true ? false : next.values.enabledByDefault,
+      disabledByDefault: field === "enabledByDefault" && value === true ? false : next.values.disabledByDefault,
+      preserveEnabledByDefault: field === "enabledByDefault" || field === "disabledByDefault" ? false : next.values.preserveEnabledByDefault
+    }
+  };
+}
+function validateConfigUpdateAgentForm(form) {
+  const values = normalizeConfigUpdateAgentValues(form.values, "agent");
+  if (values.root !== void 0 && values.root.length === 0) {
+    return "Root path cannot be empty";
+  }
+  if (form.values.enabledByDefault && form.values.disabledByDefault) {
+    return "Enabled by default and disabled by default cannot both be set";
+  }
+  return null;
+}
+function createConfigUpdateAgentFormFromSeed(seed) {
+  return createConfigUpdateAgentForm({
+    root: seed.homeRelativeRootPath ?? "",
+    skills: seed.skillsDirectoryPath ?? "",
+    name: seed.stableName ?? "",
+    platforms: [...seed.supportedPlatforms ?? []],
+    enabledByDefault: seed.overrideEnabledByDefault === true,
+    disabledByDefault: seed.overrideEnabledByDefault === false,
+    preserveEnabledByDefault: seed.overrideEnabledByDefault === void 0
+  });
+}
+function buildRunConfigUpdateAgentOptions(form, agentId) {
+  const values = normalizeConfigUpdateAgentValues(form.values, agentId);
+  return {
+    id: values.id,
+    ...values.root === void 0 ? {} : { root: values.root },
+    ...values.skills === void 0 ? {} : { skills: values.skills },
+    ...values.name === void 0 ? {} : { name: values.name },
+    ...values.platforms === void 0 ? {} : { platforms: values.platforms },
+    ...values.enabledByDefault === void 0 ? {} : { enabledByDefault: true },
+    ...values.disabledByDefault === void 0 ? {} : { disabledByDefault: true }
+  };
+}
+function normalizeRunConfigUpdateAgentOptions(input) {
+  return {
+    id: trimOrEmpty(input.id),
+    ...input.root === void 0 ? {} : { root: trimOrEmpty(input.root) },
+    ...input.skills === void 0 ? {} : { skills: trimOrEmpty(input.skills) },
+    ...input.name === void 0 ? {} : { name: trimOrEmpty(input.name) },
+    ...input.platforms === void 0 ? {} : {
+      platforms: [...new Set(input.platforms.map((entry) => entry.trim().toLowerCase()))]
+    },
+    ...input.enabledByDefault === true ? { enabledByDefault: true } : {},
+    ...input.disabledByDefault === true ? { disabledByDefault: true } : {}
+  };
+}
+function createImportSkillForm(values = {}) {
+  const initialValues = {
+    ...buildImportDefaults(),
+    ...values
+  };
+  return {
+    values: cloneValues(initialValues),
+    initialValues: cloneValues(initialValues),
+    dirty: false,
+    error: null
+  };
+}
+function updateImportSkillFormField(form, field, value) {
+  return updateFormField(form, field, value);
+}
+function validateImportSkillForm(form) {
+  const values = normalizeImportValues(form.values);
+  if (values.sourcePath.length === 0 || values.skillName.length === 0) {
+    return "Skill name and source path are required";
+  }
+  return null;
+}
+function buildRunImportOptions(form) {
+  return normalizeImportValues(form.values);
+}
+
+// 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 issuePath2 = issue.path;
+  return agents.filter((agent) => isPathInside(agent.absoluteSkillsDirectoryPath, issuePath2)).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 hasUserOverride(configuredAgentIds, agentId) {
+  return configuredAgentIds.has(agentId);
+}
+function buildAgentRows(input) {
+  const configuredAgentIds = new Set(input.configuredAgentIds ?? []);
+  return sortById(input.agents).map((agent) => {
+    const counts = countsForRows(buildSkillRowsForAgent(input, agent.id));
+    const userOverride = hasUserOverride(configuredAgentIds, agent.id);
+    const agentOverride = input.agentOverrides?.[agent.id];
+    return {
+      id: agent.id,
+      name: agent.stableName,
+      stableName: agent.stableName,
+      path: agent.absoluteSkillsDirectoryPath,
+      homeRelativeRootPath: agent.homeRelativeRootPath,
+      skillsDirectoryPath: agent.skillsDirectoryPath,
+      supportedPlatforms: [...agent.supportedPlatforms],
+      enabledByDefault: agent.enabledByDefault,
+      ...agentOverride?.stableName === void 0 ? {} : { overrideStableName: agentOverride.stableName },
+      ...agentOverride?.homeRelativeRootPath === void 0 ? {} : { overrideHomeRelativeRootPath: agentOverride.homeRelativeRootPath },
+      ...agentOverride?.skillsDirectoryPath === void 0 ? {} : { overrideSkillsDirectoryPath: agentOverride.skillsDirectoryPath },
+      ...agentOverride?.supportedPlatforms === void 0 ? {} : { overrideSupportedPlatforms: [...agentOverride.supportedPlatforms] },
+      ...agentOverride?.enabledByDefault === void 0 ? {} : { overrideEnabledByDefault: agentOverride.enabledByDefault },
+      discovery: agent.discovery,
+      exists: agent.exists,
+      supported: agent.supportedOnPlatform,
+      hasUserOverride: userOverride,
+      canEditOverride: userOverride,
+      canRemoveOverride: userOverride,
+      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 userConfig = await loadUserConfig(skillmuxHome);
+  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,
+    configuredAgentIds: Object.keys(userConfig.agents),
+    agentOverrides: userConfig.agents,
+    selectedAgentId: options.selectedAgentId,
+    selectedSkillId: options.selectedSkillId
+  });
+}
+
+// src/tui/actions.ts
+var defaultServices = {
+  runEnable,
+  runDisable,
+  runAdopt,
+  runConfigAddAgent,
+  runConfigUpdateAgent,
+  runConfigRemoveAgent,
+  runImport,
+  runDoctor,
+  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 commandLabel(kind) {
+  if (kind === "config-add-agent") {
+    return "Config add agent";
+  }
+  if (kind === "config-update-agent") {
+    return "Config update agent";
+  }
+  if (kind === "config-remove-agent") {
+    return "Config remove agent";
+  }
+  if (kind === "import-skill") {
+    return "Import skill";
+  }
+  return "Doctor";
+}
+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, selection = {}) {
+  const hasSelectedAgentId = Object.prototype.hasOwnProperty.call(
+    selection,
+    "selectedAgentId"
+  );
+  const hasSelectedSkillId = Object.prototype.hasOwnProperty.call(
+    selection,
+    "selectedSkillId"
+  );
+  return {
+    homeDir: input.homeDir,
+    skillmuxHome: input.skillmuxHome,
+    platform: input.platform,
+    selectedAgentId: hasSelectedAgentId ? selection.selectedAgentId ?? void 0 : input.model.selectedAgentId ?? void 0,
+    selectedSkillId: hasSelectedSkillId ? selection.selectedSkillId ?? void 0 : input.model.selectedSkillId ?? void 0
+  };
+}
+async function reloadAfterCommand(input, services, output, selection = {}) {
+  return {
+    model: await services.reload(reloadOptions(input, selection)),
+    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;
+}
+function isPendingCommand(action) {
+  return typeof action === "object";
+}
+async function dispatchTuiAction(input) {
+  const services = { ...defaultServices, ...input.services };
+  try {
+    if (isPendingCommand(input.action)) {
+      if (input.action.kind === "config-add-agent") {
+        const normalizedInput = normalizeRunConfigAddAgentOptions(input.action.input);
+        const result3 = await services.runConfigAddAgent({
+          homeDir: input.homeDir,
+          skillmuxHome: input.skillmuxHome,
+          ...normalizedInput
+        });
+        return reloadAfterCommand(
+          input,
+          services,
+          result3.output,
+          {
+            selectedAgentId: result3.agentId ?? normalizeAgentId(normalizedInput.id),
+            selectedSkillId: void 0
+          }
+        );
+      }
+      if (input.action.kind === "config-update-agent") {
+        const normalizedInput = normalizeRunConfigUpdateAgentOptions(input.action.input);
+        const result3 = await services.runConfigUpdateAgent({
+          homeDir: input.homeDir,
+          skillmuxHome: input.skillmuxHome,
+          ...normalizedInput
+        });
+        return reloadAfterCommand(
+          input,
+          services,
+          result3.output,
+          {
+            selectedAgentId: result3.agentId ?? normalizedInput.id,
+            selectedSkillId: void 0
+          }
+        );
+      }
+      if (input.action.kind === "config-remove-agent") {
+        const result3 = await services.runConfigRemoveAgent({
+          homeDir: input.homeDir,
+          skillmuxHome: input.skillmuxHome,
+          ...input.action.input
+        });
+        return reloadAfterCommand(
+          input,
+          services,
+          result3.output,
+          {
+            selectedAgentId: null,
+            selectedSkillId: void 0
+          }
+        );
+      }
+      if (input.action.kind === "import-skill") {
+        const result3 = await services.runImport({
+          homeDir: input.homeDir,
+          skillmuxHome: input.skillmuxHome,
+          ...input.action.input
+        });
+        return reloadAfterCommand(input, services, result3.output);
+      }
+      const result2 = await services.runDoctor({
+        homeDir: input.homeDir,
+        skillmuxHome: input.skillmuxHome,
+        platform: input.platform
+      });
+      return {
+        model: input.model,
+        statusMessage: stripTrailingNewlines(result2.output),
+        doctor: result2
+      };
+    }
+    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) {
+    const label = isPendingCommand(input.action) ? commandLabel(input.action.kind) : actionLabel(input.action);
+    return {
+      model: input.model,
+      statusMessage: `${label} failed: ${errorReason(error)}`,
+      commandSucceeded: false
+    };
+  }
+}
+
+// src/tui/components/Dashboard.tsx
+import { Box as Box10, Text as Text10 } 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.hasUserOverride === true || 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,
+    pendingCommand: null,
+    statusMessage: null
+  };
+}
+function isFormModal(modal) {
+  return modal?.kind === "add-agent" || modal?.kind === "edit-agent" || modal?.kind === "import";
+}
+function restoreDismissedForm(modal) {
+  if (modal.kind !== "confirm-discard-dirty-form") {
+    return modal;
+  }
+  return modal.modal;
+}
+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 === "open-add-agent" || event.type === "open-edit-agent" || event.type === "open-remove-agent" || event.type === "open-import" || event.type === "open-doctor" || event.type === "open-discard-dirty-form" || event.type === "submit-remove-agent" || 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";
+  const canEditSelectedAgent = selectedAgent?.canEditOverride === true;
+  const canRemoveSelectedAgent = selectedAgent?.canRemoveOverride === true;
+  return {
+    addAgent: canAcceptActions,
+    editAgent: canAcceptActions && canEditSelectedAgent,
+    removeAgent: canAcceptActions && canRemoveSelectedAgent,
+    importSkill: canAcceptActions,
+    doctor: canAcceptActions,
+    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 consumePendingCommandIntent(state) {
+  return {
+    state: {
+      ...state,
+      pendingCommand: null
+    },
+    command: state.pendingCommand
+  };
+}
+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,
+    pendingCommand: 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 === "confirm-discard-dirty-form") {
+      if (state.modal.kind !== "confirm-discard-dirty-form") {
+        return state;
+      }
+      return {
+        ...state,
+        modal: null,
+        pendingCommand: null
+      };
+    }
+    if (event.type === "close") {
+      if (state.modal.kind === "confirm-discard-dirty-form") {
+        return {
+          ...state,
+          modal: restoreDismissedForm(state.modal)
+        };
+      }
+      if (isFormModal(state.modal) && state.modal.form.dirty) {
+        return {
+          ...state,
+          modal: {
+            kind: "confirm-discard-dirty-form",
+            modal: state.modal
+          }
+        };
+      }
+      return {
+        ...state,
+        modal: null,
+        pendingAction: null,
+        pendingCommand: null
+      };
+    }
+    if (event.type === "set-busy") {
+      return {
+        ...state,
+        busy: event.busy
+      };
+    }
+    if (event.type === "set-status") {
+      return {
+        ...state,
+        statusMessage: event.message
+      };
+    }
+    if (state.modal.kind === "doctor") {
+      if (event.type === "doctor-result-loaded") {
+        return {
+          ...state,
+          modal: {
+            kind: "doctor",
+            status: "ready",
+            report: event.report
+          }
+        };
+      }
+      if (event.type === "doctor-result-failed") {
+        return {
+          ...state,
+          modal: {
+            kind: "doctor",
+            status: "error",
+            errorMessage: event.errorMessage
+          }
+        };
+      }
+    }
+    if (state.modal.kind === "add-agent") {
+      if (event.type === "add-agent-form-field-changed") {
+        return {
+          ...state,
+          modal: {
+            ...state.modal,
+            form: updateConfigAddAgentFormField(
+              state.modal.form,
+              event.field,
+              event.value
+            )
+          }
+        };
+      }
+      if (event.type === "submit-add-agent-form") {
+        const error = validateConfigAddAgentForm(state.modal.form);
+        if (error !== null) {
+          return {
+            ...state,
+            modal: {
+              ...state.modal,
+              form: {
+                ...state.modal.form,
+                error
+              }
+            }
+          };
+        }
+        return {
+          ...state,
+          pendingCommand: {
+            kind: "config-add-agent",
+            input: buildRunConfigAddAgentOptions(state.modal.form)
+          },
+          modal: {
+            ...state.modal,
+            form: {
+              ...state.modal.form,
+              error: null
+            }
+          }
+        };
+      }
+    }
+    if (state.modal.kind === "edit-agent") {
+      if (event.type === "edit-agent-form-field-changed") {
+        return {
+          ...state,
+          modal: {
+            ...state.modal,
+            form: updateConfigUpdateAgentFormField(
+              state.modal.form,
+              event.field,
+              event.value
+            )
+          }
+        };
+      }
+      if (event.type === "submit-edit-agent-form") {
+        const error = validateConfigUpdateAgentForm(state.modal.form);
+        if (error !== null) {
+          return {
+            ...state,
+            modal: {
+              ...state.modal,
+              form: {
+                ...state.modal.form,
+                error
+              }
+            }
+          };
+        }
+        return {
+          ...state,
+          pendingCommand: {
+            kind: "config-update-agent",
+            input: buildRunConfigUpdateAgentOptions(state.modal.form, state.modal.agentId)
+          },
+          modal: {
+            ...state.modal,
+            form: {
+              ...state.modal.form,
+              error: null
+            }
+          }
+        };
+      }
+    }
+    if (state.modal.kind === "confirm-remove-agent") {
+      if (event.type === "submit-remove-agent") {
+        return {
+          ...state,
+          pendingCommand: {
+            kind: "config-remove-agent",
+            input: { id: state.modal.agentId }
+          }
+        };
+      }
+    }
+    if (state.modal.kind === "import") {
+      if (event.type === "import-form-field-changed") {
+        return {
+          ...state,
+          modal: {
+            ...state.modal,
+            form: updateImportSkillFormField(
+              state.modal.form,
+              event.field,
+              event.value
+            )
+          }
+        };
+      }
+      if (event.type === "submit-import-form") {
+        const error = validateImportSkillForm(state.modal.form);
+        if (error !== null) {
+          return {
+            ...state,
+            modal: {
+              ...state.modal,
+              form: {
+                ...state.modal.form,
+                error
+              }
+            }
+          };
+        }
+        return {
+          ...state,
+          pendingCommand: {
+            kind: "import-skill",
+            input: buildRunImportOptions(state.modal.form)
+          },
+          modal: {
+            ...state.modal,
+            form: {
+              ...state.modal.form,
+              error: null
+            }
+          }
+        };
+      }
+    }
+    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" || event.type === "open-add-agent" || event.type === "open-edit-agent" || event.type === "open-remove-agent" || event.type === "open-import" || event.type === "open-doctor" || event.type === "open-discard-dirty-form") {
+      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 === "open-add-agent") {
+    return {
+      ...readyState,
+      modal: {
+        kind: "add-agent",
+        form: createConfigAddAgentForm()
+      }
+    };
+  }
+  if (event.type === "open-edit-agent") {
+    const selectedAgent = selectedAgentRow(state);
+    if (selectedAgent?.canEditOverride !== true) {
+      return {
+        ...readyState,
+        statusMessage: "Select an agent override first"
+      };
+    }
+    return {
+      ...readyState,
+      modal: {
+        kind: "edit-agent",
+        agentId: selectedAgent.id,
+        form: createConfigUpdateAgentFormFromSeed({
+          id: selectedAgent.id,
+          stableName: selectedAgent.overrideStableName,
+          homeRelativeRootPath: selectedAgent.overrideHomeRelativeRootPath,
+          skillsDirectoryPath: selectedAgent.overrideSkillsDirectoryPath,
+          supportedPlatforms: selectedAgent.overrideSupportedPlatforms,
+          overrideEnabledByDefault: selectedAgent.overrideEnabledByDefault
+        })
+      }
+    };
+  }
+  if (event.type === "open-remove-agent") {
+    const selectedAgent = selectedAgentRow(state);
+    if (selectedAgent?.canRemoveOverride !== true) {
+      return {
+        ...readyState,
+        statusMessage: "Select an agent override first"
+      };
+    }
+    return {
+      ...readyState,
+      modal: { kind: "confirm-remove-agent", agentId: selectedAgent.id }
+    };
+  }
+  if (event.type === "open-import") {
+    return {
+      ...readyState,
+      modal: {
+        kind: "import",
+        form: createImportSkillForm()
+      }
+    };
+  }
+  if (event.type === "open-doctor") {
+    return {
+      ...readyState,
+      modal: {
+        kind: "doctor",
+        status: "loading"
+      },
+      pendingCommand: {
+        kind: "doctor"
+      }
+    };
+  }
+  if (event.type === "open-discard-dirty-form") {
+    return {
+      ...readyState,
+      modal: {
+        kind: "confirm-discard-dirty-form",
+        modal: {
+          kind: "add-agent",
+          form: createConfigAddAgentForm()
+        }
+      }
+    };
+  }
+  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}?`;
+  }
+  if (modal.kind === "confirm-remove-agent") {
+    return `Remove agent override for ${modal.agentId}?`;
+  }
+  if (modal.kind === "confirm-discard-dirty-form") {
+    return "Discard unsaved changes?";
+  }
+  return `Remove ${modal.skillId} from SkillMux?`;
+}
+function confirmationDetails(modal) {
+  if (modal.kind !== "confirm-adopt-all") {
+    if (modal.kind === "confirm-remove-agent") {
+      return "This will remove the selected agent override from SkillMux.";
+    }
+    if (modal.kind === "confirm-discard-dirty-form") {
+      return "This will close the form and discard the current changes.";
+    }
+    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" || modal.kind === "confirm-remove-agent" ? "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/DoctorDialog.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { Fragment, jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function issueLabel(issue) {
+  return `${issue.severity} ${issue.code}`;
+}
+function issuePath(issue) {
+  return issue.path ?? null;
+}
+function visibleIssueCount(height) {
+  return Math.max(height - 5, 1);
+}
+function DoctorDialog({
+  modal,
+  scrollOffset = 0,
+  width = 72,
+  height = 14
+}) {
+  if (modal.status === "loading") {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width, height, children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Doctor" }),
+      /* @__PURE__ */ jsx3(Text3, { children: "Loading doctor diagnostics..." }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "[Esc] close" })
+    ] });
+  }
+  if (modal.status === "error") {
+    return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width, height, children: [
+      /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Doctor" }),
+      /* @__PURE__ */ jsx3(Text3, { color: "red", children: modal.errorMessage }),
+      /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "[Esc] close" })
+    ] });
+  }
+  const issues = modal.report.issues;
+  const maxIssues = visibleIssueCount(height);
+  const maxOffset = Math.max(issues.length - maxIssues, 0);
+  const clampedOffset = Math.min(Math.max(scrollOffset, 0), maxOffset);
+  const visibleIssues = issues.slice(clampedOffset, clampedOffset + maxIssues);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", width, height, children: [
+    /* @__PURE__ */ jsx3(Text3, { bold: true, children: "Doctor" }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: issues.length === 0 ? "No doctor issues found." : `${issues.length} issue(s) found` }),
+    issues.length === 0 ? null : /* @__PURE__ */ jsxs3(Fragment, { children: [
+      visibleIssues.map((issue) => /* @__PURE__ */ jsxs3(Text3, { children: [
+        /* @__PURE__ */ jsx3(Text3, { color: issue.severity === "error" ? "red" : "yellow", children: "! " }),
+        /* @__PURE__ */ jsxs3(Text3, { children: [
+          issueLabel(issue),
+          " - ",
+          issue.message,
+          issuePath(issue) === null ? "" : ` - ${issuePath(issue)}`
+        ] })
+      ] }, `${issue.code}:${issue.path ?? issue.message}`)),
+      issues.length > visibleIssues.length ? /* @__PURE__ */ jsxs3(Text3, { dimColor: true, children: [
+        "Showing ",
+        clampedOffset + 1,
+        "-",
+        clampedOffset + visibleIssues.length,
+        " of ",
+        issues.length
+      ] }) : null
+    ] }),
+    /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "[Up/Down] scroll   [Esc] close" })
+  ] });
+}
+
+// src/tui/components/DetailPane.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import { jsx as jsx4, jsxs as jsxs4 } 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__ */ jsxs4(Box4, { flexDirection: "column", width, height, children: [
+    /* @__PURE__ */ jsx4(Text4, { bold: true, children: "Detail" }),
+    selectedAgent === null ? /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Select an agent" }) : /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      "Agent: ",
+      selectedAgent.name
+    ] }),
+    selectedSkill === null ? loadingAgentName !== null ? /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+      "Loading details for ",
+      loadingAgentName,
+      "..."
+    ] }) : /* @__PURE__ */ jsx4(Text4, { 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__ */ jsxs4(Text4, { children: [
+        /* @__PURE__ */ jsxs4(Text4, { dimColor: true, children: [
+          label,
+          ": "
+        ] }),
+        /* @__PURE__ */ jsx4(Text4, { children: renderedValue })
+      ] }, label);
+    })
+  ] });
+}
+
+// src/tui/components/Footer.tsx
+import { Box as Box5, Text as Text5 } from "ink";
+import { Fragment as Fragment2, jsx as jsx5, jsxs as jsxs5 } 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 = [
+    actions.addAgent ? "[n]add agent" : null,
+    actions.editAgent ? "[e]edit agent" : null,
+    actions.removeAgent ? "[X]remove agent" : null,
+    actions.importSkill ? "[i]import" : null,
+    actions.doctor ? "[d]doctor" : null,
+    "[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__ */ jsx5(Box5, { flexDirection: "column", height: 3, children: search === null ? /* @__PURE__ */ jsxs5(Fragment2, { children: [
+    /* @__PURE__ */ jsx5(Text5, { children: shortcuts.join("   ") }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: agentLegend }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: skillLegend })
+  ] }) : /* @__PURE__ */ jsxs5(Text5, { children: [
+    /* @__PURE__ */ jsx5(Text5, { color: "cyan", children: "/" }),
+    /* @__PURE__ */ jsx5(Text5, { children: search.query }),
+    /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "   [Enter]keep   [Esc]cancel" })
+  ] }) });
+}
+
+// src/tui/components/HelpOverlay.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+function HelpOverlay() {
+  return /* @__PURE__ */ jsxs6(Box6, { flexDirection: "column", height: 8, children: [
+    /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Help" }),
+    /* @__PURE__ */ jsxs6(Text6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Navigation" }),
+      /* @__PURE__ */ jsx6(Text6, { children: ": Left/Right switch panels, j/k or Up/Down move, g/G jump." })
+    ] }),
+    /* @__PURE__ */ jsxs6(Text6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Actions" }),
+      /* @__PURE__ */ jsx6(Text6, { children: ": Space toggles, a adopts, Shift+A current-agent bulk adopt, r removes, s scans, n add agent, e edit selected override, X remove selected override, i import, d doctor." })
+    ] }),
+    /* @__PURE__ */ jsxs6(Text6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Search" }),
+      /* @__PURE__ */ jsx6(Text6, { children: ": / filters the focused list, Enter keeps the result, Esc cancels." })
+    ] }),
+    /* @__PURE__ */ jsxs6(Text6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Agent icons" }),
+      /* @__PURE__ */ jsx6(Text6, { children: ": * ready, yellow * issues, ? missing, ! unsupported." })
+    ] }),
+    /* @__PURE__ */ jsxs6(Text6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Skill markers" }),
+      /* @__PURE__ */ jsx6(Text6, { children: ": \u25CF enabled, \u25CB disabled, ? unmanaged, ! issue." })
+    ] }),
+    /* @__PURE__ */ jsxs6(Text6, { children: [
+      /* @__PURE__ */ jsx6(Text6, { bold: true, children: "Safety" }),
+      /* @__PURE__ */ jsx6(Text6, { children: ": Toggle, adopt, remove, and scan can update SkillMux state and agent links." })
+    ] })
+  ] });
+}
+
+// src/tui/components/FormDialog.tsx
+import { Box as Box7, Text as Text7 } from "ink";
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+var platformOptions = ["win32", "linux", "darwin"];
+function checkbox(value) {
+  return value ? "[x]" : "[ ]";
+}
+function renderTextField(label, value, active) {
+  return /* @__PURE__ */ jsxs7(Text7, { inverse: active, children: [
+    /* @__PURE__ */ jsxs7(Text7, { bold: true, children: [
+      label,
+      ": "
+    ] }),
+    /* @__PURE__ */ jsx7(Text7, { children: value.length > 0 ? value : " " })
+  ] }, label);
+}
+function renderBooleanField(label, value, active) {
+  return /* @__PURE__ */ jsxs7(Text7, { inverse: active, children: [
+    /* @__PURE__ */ jsxs7(Text7, { bold: true, children: [
+      label,
+      ": "
+    ] }),
+    /* @__PURE__ */ jsx7(Text7, { children: checkbox(value) })
+  ] }, label);
+}
+function renderPlatformField(selectedPlatforms, activePlatformIndex, active) {
+  return platformOptions.map((platform, index) => {
+    const selected = selectedPlatforms.includes(platform);
+    const isCurrent = active && index === activePlatformIndex;
+    return /* @__PURE__ */ jsxs7(Text7, { inverse: isCurrent, children: [
+      /* @__PURE__ */ jsx7(Text7, { children: isCurrent ? "> " : "  " }),
+      /* @__PURE__ */ jsxs7(Text7, { children: [
+        checkbox(selected),
+        " "
+      ] }),
+      /* @__PURE__ */ jsx7(Text7, { children: platform })
+    ] }, platform);
+  });
+}
+function FormDialog({
+  modal,
+  fieldIndex = 0,
+  platformIndex = 0,
+  width = 72,
+  height = 14
+}) {
+  const activeField = fieldIndex;
+  const submitFieldIndex = modal.kind === "import" ? 2 : 6;
+  if (modal.kind === "import") {
+    return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", width, height, children: [
+      /* @__PURE__ */ jsx7(Text7, { bold: true, children: "Import skill" }),
+      modal.form.error === null ? null : /* @__PURE__ */ jsx7(Text7, { color: "red", children: modal.form.error }),
+      renderTextField(
+        "Source path",
+        modal.form.values.sourcePath,
+        activeField === 0
+      ),
+      renderTextField(
+        "Skill name",
+        modal.form.values.skillName,
+        activeField === 1
+      ),
+      /* @__PURE__ */ jsx7(Text7, { inverse: activeField === submitFieldIndex, children: "Submit" }),
+      /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "[Up/Down] move   [Enter] submit selected row   [Esc] cancel" })
+    ] });
+  }
+  const title = modal.kind === "add-agent" ? "Add agent" : `Edit agent ${modal.agentId}`;
+  const fields = modal.kind === "add-agent" ? [
+    renderTextField("Agent id", modal.form.values.id, activeField === 0),
+    renderTextField("Root path", modal.form.values.root, activeField === 1),
+    renderTextField("Skills path", modal.form.values.skills, activeField === 2),
+    renderTextField("Display name", modal.form.values.name, activeField === 3)
+  ] : [
+    renderTextField("Root path", modal.form.values.root, activeField === 0),
+    renderTextField("Skills path", modal.form.values.skills, activeField === 1),
+    renderTextField("Display name", modal.form.values.name, activeField === 2)
+  ];
+  const platformFieldIndex = modal.kind === "add-agent" ? 4 : 3;
+  const booleanFieldIndex = modal.kind === "add-agent" ? 5 : 4;
+  const platformLines = renderPlatformField(
+    modal.form.values.platforms,
+    platformIndex,
+    activeField === platformFieldIndex
+  );
+  const booleanLabel = modal.kind === "add-agent" ? "Disabled by default" : "Enabled by default";
+  const booleanValue = modal.kind === "add-agent" ? modal.form.values.disabledByDefault : modal.form.values.enabledByDefault;
+  const secondaryBooleanLabel = modal.kind === "add-agent" ? null : "Disabled by default";
+  return /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", width, height, children: [
+    /* @__PURE__ */ jsx7(Text7, { bold: true, children: title }),
+    modal.form.error === null ? null : /* @__PURE__ */ jsx7(Text7, { color: "red", children: modal.form.error }),
+    fields,
+    /* @__PURE__ */ jsx7(Text7, { bold: true, inverse: activeField === platformFieldIndex, children: "Platforms" }),
+    platformLines,
+    renderBooleanField(
+      booleanLabel,
+      booleanValue,
+      activeField === booleanFieldIndex
+    ),
+    secondaryBooleanLabel === null ? null : renderBooleanField(
+      secondaryBooleanLabel,
+      modal.form.values.disabledByDefault,
+      activeField === booleanFieldIndex + 1
+    ),
+    /* @__PURE__ */ jsx7(Text7, { inverse: activeField === submitFieldIndex, children: "Submit" }),
+    modal.kind === "edit-agent" ? /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Leaving both defaults unchecked preserves the current setting." }) : null,
+    /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "[Up/Down] move   [Enter] submit selected row   [Esc] cancel" })
+  ] });
+}
+
+// src/tui/components/SkillList.tsx
+import { Box as Box8, Text as Text8 } from "ink";
+import { jsx as jsx8, jsxs as jsxs8 } 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__ */ jsxs8(Box8, { flexDirection: "column", width, height, children: [
+    /* @__PURE__ */ jsxs8(Text8, { bold: true, color: focused ? "cyan" : void 0, children: [
+      "Skills for ",
+      agentId ?? "none"
+    ] }),
+    skills.length === 0 ? /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: emptyMessage }) : skills.map((skill) => {
+      const selected = skill.id === selectedSkillId;
+      return /* @__PURE__ */ jsxs8(Text8, { inverse: focused && selected, children: [
+        /* @__PURE__ */ jsx8(Text8, { color: markerColor(skill), children: skill.marker }),
+        /* @__PURE__ */ jsxs8(Text8, { children: [
+          " ",
+          skillLabel(skill)
+        ] })
+      ] }, skill.id);
+    })
+  ] });
+}
+
+// src/tui/components/StatusLine.tsx
+import { Box as Box9, Text as Text9 } from "ink";
+import { jsx as jsx9 } from "react/jsx-runtime";
+function StatusLine({
+  busy,
+  statusMessage,
+  lastScanAt,
+  issueCount
+}) {
+  const message = statusMessage ?? (busy ? "scanning..." : `Last scan: ${lastScanAt ?? "never"} | issues: ${issueCount}`);
+  return /* @__PURE__ */ jsx9(Box9, { height: 1, children: /* @__PURE__ */ jsx9(Text9, { color: busy ? "cyan" : void 0, children: message }) });
+}
+
+// src/tui/components/Dashboard.tsx
+import { jsx as jsx10, jsxs as jsxs9 } 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;
+var largeModalWidth = 72;
+var largeModalHeight = 14;
+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,
+  modalInteraction
+}) {
+  const interaction = modalInteraction ?? {
+    fieldIndex: 0,
+    platformIndex: 0,
+    doctorScrollOffset: 0
+  };
+  if (width < minimumWidth || height < minimumHeight) {
+    return /* @__PURE__ */ jsx10(
+      Box10,
+      {
+        flexDirection: "column",
+        width,
+        height,
+        justifyContent: "center",
+        alignItems: "center",
+        children: /* @__PURE__ */ jsx10(Text10, { 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 largeModal = state.modal?.kind === "add-agent" || state.modal?.kind === "edit-agent" || state.modal?.kind === "import" || state.modal?.kind === "doctor" || state.modal?.kind === "confirm-remove-agent";
+  const overlayHeight = largeModal ? 0 : state.modal?.kind === "help" ? 8 : state.modal?.kind === "confirm-adopt" || state.modal?.kind === "confirm-adopt-all" || state.modal?.kind === "confirm-remove" ? confirmDialogHeight : 0;
+  const footerSpace = state.modal === null ? footerHeight : largeModal ? 0 : footerHeight;
+  const bodyHeight = Math.max(height - 1 - footerSpace - overlayHeight, 0);
+  const { agentWidth, skillWidth, detailWidth } = paneWidths(width);
+  const modalWidth = Math.min(width - 4, largeModalWidth);
+  const modalHeight = Math.min(bodyHeight, largeModalHeight);
+  return /* @__PURE__ */ jsxs9(Box10, { flexDirection: "column", width, height, children: [
+    /* @__PURE__ */ jsx10(
+      StatusLine,
+      {
+        busy: state.busy,
+        statusMessage: state.statusMessage,
+        lastScanAt: state.model.lastScanAt,
+        issueCount: state.model.issueCount
+      }
+    ),
+    largeModal ? /* @__PURE__ */ jsx10(
+      Box10,
+      {
+        flexDirection: "column",
+        width,
+        height: bodyHeight,
+        justifyContent: "center",
+        alignItems: "center",
+        children: /* @__PURE__ */ jsx10(Box10, { width: modalWidth, height: modalHeight, children: state.modal?.kind === "add-agent" || state.modal?.kind === "edit-agent" || state.modal?.kind === "import" ? /* @__PURE__ */ jsx10(
+          FormDialog,
+          {
+            modal: state.modal,
+            fieldIndex: interaction.fieldIndex,
+            platformIndex: interaction.platformIndex,
+            width: modalWidth,
+            height: modalHeight
+          }
+        ) : state.modal?.kind === "doctor" ? /* @__PURE__ */ jsx10(
+          DoctorDialog,
+          {
+            modal: state.modal,
+            scrollOffset: interaction.doctorScrollOffset,
+            width: modalWidth,
+            height: modalHeight
+          }
+        ) : state.modal?.kind === "confirm-remove-agent" ? /* @__PURE__ */ jsx10(ConfirmDialog, { modal: state.modal }) : null })
+      }
+    ) : /* @__PURE__ */ jsxs9(Box10, { flexDirection: "row", width, height: bodyHeight, children: [
+      /* @__PURE__ */ jsx10(
+        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__ */ jsx10(
+        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__ */ jsx10(
+        DetailPane,
+        {
+          selectedAgent,
+          selectedSkill,
+          focused: state.focus === "detail",
+          loadingAgentName: loadingAgent?.name ?? null,
+          width: detailWidth,
+          height: bodyHeight
+        }
+      )
+    ] }),
+    state.modal?.kind === "help" ? /* @__PURE__ */ jsx10(HelpOverlay, {}) : null,
+    state.modal?.kind === "confirm-adopt" || state.modal?.kind === "confirm-adopt-all" || state.modal?.kind === "confirm-remove" || state.modal?.kind === "confirm-discard-dirty-form" ? /* @__PURE__ */ jsx10(ConfirmDialog, { modal: state.modal }) : null,
+    state.modal === null ? /* @__PURE__ */ jsx10(Footer, { actions, search: state.search }) : largeModal ? null : /* @__PURE__ */ jsx10(Box10, { height: 3 })
+  ] });
+}
+
+// src/tui/app.tsx
+import { jsx as jsx11 } from "react/jsx-runtime";
+var defaultServices2 = {
+  loadDashboardState,
+  dispatchTuiAction
+};
+var addAgentFieldOrder = [
+  "id",
+  "root",
+  "skills",
+  "name",
+  "platforms",
+  "disabledByDefault"
+];
+var editAgentFieldOrder = [
+  "root",
+  "skills",
+  "name",
+  "platforms",
+  "enabledByDefault",
+  "disabledByDefault"
+];
+var importFieldOrder = ["sourcePath", "skillName"];
+var platformOptions2 = ["win32", "linux", "darwin"];
+function clampIndex(index, count) {
+  if (count <= 0) {
+    return 0;
+  }
+  return (index % count + count) % count;
+}
+function nextText(value, input) {
+  return `${value}${input}`;
+}
+function trimLast(value) {
+  return value.slice(0, Math.max(value.length - 1, 0));
+}
+function togglePlatform(values, platform) {
+  return values.includes(platform) ? values.filter((entry) => entry !== platform) : [...values, platform];
+}
+function commandFailureMessage(error) {
+  return `Action failed: ${errorReason2(error)}`;
+}
+function restoreFailedFormModal(modal, message) {
+  switch (modal.kind) {
+    case "add-agent":
+      return {
+        kind: "add-agent",
+        form: {
+          ...modal.form,
+          error: message
+        }
+      };
+    case "edit-agent":
+      return {
+        kind: "edit-agent",
+        agentId: modal.agentId,
+        form: {
+          ...modal.form,
+          error: message
+        }
+      };
+    case "import":
+      return {
+        kind: "import",
+        form: {
+          ...modal.form,
+          error: message
+        }
+      };
+  }
+}
+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,
+  modalInteraction
+}) {
+  return /* @__PURE__ */ jsx11(
+    Dashboard,
+    {
+      state,
+      width: terminalWidth ?? liveTerminalSize().columns,
+      height: terminalHeight ?? liveTerminalSize().rows,
+      modalInteraction
+    }
+  );
+}
+function BridgedDashboardViewport({
+  state,
+  terminalWidth,
+  terminalHeight,
+  bridgePath,
+  modalInteraction
+}) {
+  const bridgedTerminalSize = useBridgedTerminalSize(bridgePath ?? null);
+  const fallbackSize = liveTerminalSize();
+  return /* @__PURE__ */ jsx11(
+    Dashboard,
+    {
+      state,
+      width: terminalWidth ?? bridgedTerminalSize?.columns ?? fallbackSize.columns,
+      height: terminalHeight ?? bridgedTerminalSize?.rows ?? fallbackSize.rows,
+      modalInteraction
+    }
+  );
+}
+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 [modalInteraction, setModalInteraction] = useState({
+    fieldIndex: 0,
+    platformIndex: 0,
+    doctorScrollOffset: 0
+  });
+  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 modalKind = state?.modal?.kind ?? null;
+  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]);
+  useEffect(() => {
+    setModalInteraction({
+      fieldIndex: 0,
+      platformIndex: 0,
+      doctorScrollOffset: 0
+    });
+  }, [modalKind]);
+  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]);
+  useEffect(() => {
+    if (state?.pendingCommand === null || state?.pendingCommand === void 0) {
+      return;
+    }
+    const consumed = consumePendingCommandIntent(state);
+    setState(consumed.state);
+    if (consumed.command === null) {
+      return;
+    }
+    if (consumed.command.kind === "doctor") {
+      const requestId2 = beginRequest();
+      services.dispatchTuiAction({
+        action: consumed.command,
+        model: consumed.state.model,
+        homeDir,
+        skillmuxHome,
+        platform
+      }).then((result) => {
+        if (!isLatestRequest(requestId2)) {
+          return;
+        }
+        if (result.commandSucceeded === false) {
+          const failureMessage = result.statusMessage;
+          setState(
+            (current) => current === null ? current : updateTuiState(
+              updateTuiState(current, {
+                type: "doctor-result-failed",
+                errorMessage: failureMessage
+              }),
+              { type: "set-status", message: failureMessage }
+            )
+          );
+          return;
+        }
+        const doctorReport = result.doctor;
+        if (doctorReport === void 0) {
+          throw new Error("Doctor report missing");
+        }
+        stableModel.current = result.model;
+        setState(
+          (current) => current === null ? current : updateTuiState(
+            updateTuiState(current, {
+              type: "doctor-result-loaded",
+              report: doctorReport
+            }),
+            { type: "set-status", message: result.statusMessage }
+          )
+        );
+      }).catch((error) => {
+        if (!isLatestRequest(requestId2)) {
+          return;
+        }
+        setState(
+          (current) => current === null ? current : updateTuiState(
+            updateTuiState(current, {
+              type: "doctor-result-failed",
+              errorMessage: `Doctor failed: ${errorReason2(error)}`
+            }),
+            { type: "set-status", message: `Doctor failed: ${errorReason2(error)}` }
+          )
+        );
+      });
+      return;
+    }
+    if (activeActionRequest.current !== null) {
+      return;
+    }
+    const requestId = beginRequest();
+    activeActionRequest.current = requestId;
+    const busyState = {
+      ...consumed.state,
+      modal: null,
+      busy: true,
+      statusMessage: "working..."
+    };
+    setState(busyState);
+    services.dispatchTuiAction({
+      action: consumed.command,
+      model: busyState.model,
+      homeDir,
+      skillmuxHome,
+      platform
+    }).then((result) => {
+      if (!isLatestRequest(requestId)) {
+        return;
+      }
+      if (result.commandSucceeded === false) {
+        const failureMessage = result.statusMessage;
+        if (consumed.command?.kind === "doctor") {
+          setState({
+            ...consumed.state,
+            busy: false,
+            statusMessage: failureMessage,
+            modal: {
+              kind: "doctor",
+              status: "error",
+              errorMessage: failureMessage
+            }
+          });
+          return;
+        }
+        if (consumed.state.modal !== null && "form" in consumed.state.modal) {
+          setState({
+            ...consumed.state,
+            busy: false,
+            statusMessage: failureMessage,
+            modal: restoreFailedFormModal(consumed.state.modal, failureMessage)
+          });
+          return;
+        }
+        setState({
+          ...consumed.state,
+          busy: false,
+          statusMessage: failureMessage
+        });
+        return;
+      }
+      stableModel.current = result.model;
+      setState(
+        (current) => current === null ? current : replaceStateModel(current, result.model, result.statusMessage)
+      );
+    }).catch((error) => {
+      if (!isLatestRequest(requestId)) {
+        return;
+      }
+      const failedModal = consumed.state.modal;
+      const failureMessage = commandFailureMessage(error);
+      if (failedModal === null || failedModal.kind !== "add-agent" && failedModal.kind !== "edit-agent" && failedModal.kind !== "import") {
+        setState({
+          ...consumed.state,
+          busy: false,
+          statusMessage: failureMessage
+        });
+        return;
+      }
+      setState({
+        ...consumed.state,
+        busy: false,
+        statusMessage: failureMessage,
+        modal: restoreFailedFormModal(failedModal, failureMessage)
+      });
+    }).finally(() => {
+      if (activeActionRequest.current === requestId) {
+        activeActionRequest.current = null;
+      }
+    });
+  }, [
+    beginRequest,
+    homeDir,
+    isLatestRequest,
+    platform,
+    services,
+    skillmuxHome,
+    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 || input === "\x1B") {
+        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 (input === "q") {
+        if (state.modal.kind === "confirm-discard-dirty-form" || "form" in state.modal && state.modal.form.dirty) {
+          setState(updateTuiState(state, { type: "close" }));
+          return;
+        }
+        exit();
+        return;
+      }
+      if (activeActionRequest.current !== null) {
+        return;
+      }
+      if (state.modal.kind === "help") {
+        if (key.escape || input === "\x1B") {
+          setState(updateTuiState(state, { type: "close" }));
+        }
+        return;
+      }
+      if (state.modal.kind === "confirm-discard-dirty-form") {
+        if (input.toLocaleLowerCase() === "y") {
+          setState(updateTuiState(state, { type: "confirm-discard-dirty-form" }));
+          return;
+        }
+        if (key.escape || input === "\x1B" || input.toLocaleLowerCase() === "n") {
+          setState(updateTuiState(state, { type: "close" }));
+        }
+        return;
+      }
+      if (state.modal.kind === "confirm-adopt" || state.modal.kind === "confirm-adopt-all" || state.modal.kind === "confirm-remove" || state.modal.kind === "confirm-remove-agent") {
+        if (input.toLocaleLowerCase() === "y") {
+          const closedState = updateTuiState(state, { type: "close" });
+          if (state.modal.kind === "confirm-adopt") {
+            runAction("adopt", closedState.model, closedState);
+          } else if (state.modal.kind === "confirm-adopt-all") {
+            runAction("adopt-all", closedState.model, closedState);
+          } else if (state.modal.kind === "confirm-remove") {
+            runAction("remove", closedState.model, closedState);
+          } else {
+            setState(updateTuiState(state, { type: "submit-remove-agent" }));
+          }
+          return;
+        }
+        if (key.escape || input === "\x1B" || input.toLocaleLowerCase() === "n") {
+          setState(updateTuiState(state, { type: "close" }));
+        }
+        return;
+      }
+      if (state.modal.kind === "doctor") {
+        if (key.escape || input === "\x1B") {
+          setState(updateTuiState(state, { type: "close" }));
+          return;
+        }
+        if (key.downArrow || key.rightArrow || input === "j") {
+          setModalInteraction((current) => ({
+            ...current,
+            doctorScrollOffset: current.doctorScrollOffset + 1
+          }));
+          return;
+        }
+        if (key.upArrow || key.leftArrow || input === "k") {
+          setModalInteraction((current) => ({
+            ...current,
+            doctorScrollOffset: Math.max(current.doctorScrollOffset - 1, 0)
+          }));
+          return;
+        }
+        return;
+      }
+      if (state.modal.kind === "add-agent" || state.modal.kind === "edit-agent" || state.modal.kind === "import") {
+        const fieldOrder = state.modal.kind === "add-agent" ? addAgentFieldOrder : state.modal.kind === "edit-agent" ? editAgentFieldOrder : importFieldOrder;
+        const submitFieldIndex = fieldOrder.length;
+        const currentFieldIndex = clampIndex(
+          modalInteraction.fieldIndex,
+          fieldOrder.length + 1
+        );
+        const currentField = fieldOrder[currentFieldIndex];
+        const moveField = (direction) => {
+          setModalInteraction((current) => ({
+            ...current,
+            fieldIndex: clampIndex(
+              current.fieldIndex + direction,
+              fieldOrder.length + 1
+            ),
+            platformIndex: 0
+          }));
+        };
+        const updateAddAgent = (field, value) => {
+          setState(
+            updateTuiState(state, {
+              type: "add-agent-form-field-changed",
+              field,
+              value
+            })
+          );
+        };
+        const updateEditAgent = (field, value) => {
+          setState(
+            updateTuiState(state, {
+              type: "edit-agent-form-field-changed",
+              field,
+              value
+            })
+          );
+        };
+        const updateImport = (field, value) => {
+          setState(
+            updateTuiState(state, {
+              type: "import-form-field-changed",
+              field,
+              value
+            })
+          );
+        };
+        if (key.escape || input === "\x1B") {
+          setState(updateTuiState(state, { type: "close" }));
+          return;
+        }
+        if (key.return && currentFieldIndex === submitFieldIndex) {
+          if (state.modal.kind === "add-agent") {
+            setState(updateTuiState(state, { type: "submit-add-agent-form" }));
+          } else if (state.modal.kind === "edit-agent") {
+            setState(updateTuiState(state, { type: "submit-edit-agent-form" }));
+          } else {
+            setState(updateTuiState(state, { type: "submit-import-form" }));
+          }
+          return;
+        }
+        if (key.downArrow) {
+          moveField(1);
+          return;
+        }
+        if (key.upArrow) {
+          moveField(-1);
+          return;
+        }
+        if (currentField === void 0) {
+          return;
+        }
+        if (currentField === "platforms") {
+          const platform2 = platformOptions2[modalInteraction.platformIndex] ?? platformOptions2[0];
+          if (key.leftArrow) {
+            setModalInteraction((current) => ({
+              ...current,
+              platformIndex: clampIndex(current.platformIndex - 1, platformOptions2.length)
+            }));
+            return;
+          }
+          if (key.rightArrow) {
+            setModalInteraction((current) => ({
+              ...current,
+              platformIndex: clampIndex(current.platformIndex + 1, platformOptions2.length)
+            }));
+            return;
+          }
+          if (input === " ") {
+            if (state.modal.kind === "add-agent") {
+              updateAddAgent(
+                "platforms",
+                togglePlatform(state.modal.form.values.platforms, platform2)
+              );
+            } else if (state.modal.kind === "edit-agent") {
+              updateEditAgent(
+                "platforms",
+                togglePlatform(state.modal.form.values.platforms, platform2)
+              );
+            }
+            return;
+          }
+        }
+        if (currentField === "disabledByDefault" && state.modal.kind === "add-agent") {
+          if (input === " ") {
+            updateAddAgent("disabledByDefault", !state.modal.form.values.disabledByDefault);
+            return;
+          }
+        }
+        if (state.modal.kind === "edit-agent") {
+          if (currentField === "enabledByDefault") {
+            if (input === " ") {
+              updateEditAgent("enabledByDefault", !state.modal.form.values.enabledByDefault);
+              return;
+            }
+          }
+          if (currentField === "disabledByDefault") {
+            if (input === " ") {
+              updateEditAgent(
+                "disabledByDefault",
+                !state.modal.form.values.disabledByDefault
+              );
+              return;
+            }
+          }
+        }
+        if (isTextInput(input)) {
+          if (state.modal.kind === "add-agent") {
+            if (currentField === "id") {
+              updateAddAgent("id", nextText(state.modal.form.values.id, input));
+              return;
+            }
+            if (currentField === "root") {
+              updateAddAgent("root", nextText(state.modal.form.values.root, input));
+              return;
+            }
+            if (currentField === "skills") {
+              updateAddAgent("skills", nextText(state.modal.form.values.skills, input));
+              return;
+            }
+            if (currentField === "name") {
+              updateAddAgent("name", nextText(state.modal.form.values.name, input));
+              return;
+            }
+          } else if (state.modal.kind === "edit-agent") {
+            if (currentField === "root") {
+              updateEditAgent("root", nextText(state.modal.form.values.root, input));
+              return;
+            }
+            if (currentField === "skills") {
+              updateEditAgent("skills", nextText(state.modal.form.values.skills, input));
+              return;
+            }
+            if (currentField === "name") {
+              updateEditAgent("name", nextText(state.modal.form.values.name, input));
+              return;
+            }
+          } else if (state.modal.kind === "import") {
+            if (currentField === "sourcePath") {
+              updateImport("sourcePath", nextText(state.modal.form.values.sourcePath, input));
+              return;
+            }
+            if (currentField === "skillName") {
+              updateImport("skillName", nextText(state.modal.form.values.skillName, input));
+              return;
+            }
+          }
+        }
+        if (key.backspace || key.delete) {
+          if (state.modal.kind === "add-agent") {
+            if (currentField === "id") {
+              updateAddAgent("id", trimLast(state.modal.form.values.id));
+              return;
+            }
+            if (currentField === "root") {
+              updateAddAgent("root", trimLast(state.modal.form.values.root));
+              return;
+            }
+            if (currentField === "skills") {
+              updateAddAgent("skills", trimLast(state.modal.form.values.skills));
+              return;
+            }
+            if (currentField === "name") {
+              updateAddAgent("name", trimLast(state.modal.form.values.name));
+              return;
+            }
+          } else if (state.modal.kind === "edit-agent") {
+            if (currentField === "root") {
+              updateEditAgent("root", trimLast(state.modal.form.values.root));
+              return;
+            }
+            if (currentField === "skills") {
+              updateEditAgent("skills", trimLast(state.modal.form.values.skills));
+              return;
+            }
+            if (currentField === "name") {
+              updateEditAgent("name", trimLast(state.modal.form.values.name));
+              return;
+            }
+          } else if (state.modal.kind === "import") {
+            if (currentField === "sourcePath") {
+              updateImport("sourcePath", trimLast(state.modal.form.values.sourcePath));
+              return;
+            }
+            if (currentField === "skillName") {
+              updateImport("skillName", trimLast(state.modal.form.values.skillName));
+              return;
+            }
+          }
+        }
+        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 (input === "n") {
+      setState(updateTuiState(state, { type: "open-add-agent" }));
+      return;
+    }
+    if (input === "e") {
+      setState(updateTuiState(state, { type: "open-edit-agent" }));
+      return;
+    }
+    if (input === "X" || key.shift && input === "x") {
+      setState(updateTuiState(state, { type: "open-remove-agent" }));
+      return;
+    }
+    if (input === "i") {
+      setState(updateTuiState(state, { type: "open-import" }));
+      return;
+    }
+    if (input === "d") {
+      setState(updateTuiState(state, { type: "open-doctor" }));
+      return;
+    }
+    if (key.escape || input === "\x1B") {
+      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__ */ jsx11(Text11, { color: "red", children: loadError });
+  }
+  if (state === null) {
+    return /* @__PURE__ */ jsx11(Text11, { children: "loading dashboard..." });
+  }
+  return sizeBridgeEnabled ? /* @__PURE__ */ jsx11(
+    BridgedDashboardViewport,
+    {
+      state,
+      terminalWidth,
+      terminalHeight,
+      bridgePath: sizeBridgePath,
+      modalInteraction
+    }
+  ) : /* @__PURE__ */ jsx11(
+    LiveDashboardViewport,
+    {
+      state,
+      terminalWidth,
+      terminalHeight,
+      modalInteraction
+    }
+  );
+}
+
+// src/tui/launch-tui.tsx
+import { jsx as jsx12 } 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__ */ jsx12(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-IC7COEGE.js.map