thoth-agents 0.12.0 → 0.13.1

package/dist/tui/index.js

@@ -0,0 +1,1386 @@
+import {
+  profileRpc,
+  toolRpc
+} from "../chunk-6O4GKDS7.js";
+
+// src/tui/model.ts
+var DEFAULT_PROFILE = "default";
+var profileKey = (name, scope) => scope ? `${scope}:${name}` : "default";
+function profileRows(state) {
+  return [
+    {
+      key: "default",
+      name: DEFAULT_PROFILE,
+      shadowed: false,
+      profile: state.defaultProfile
+    },
+    ...state.profiles.map((entry) => ({
+      key: profileKey(entry.name, entry.scope),
+      name: entry.name,
+      scope: entry.scope,
+      shadowed: entry.shadowed,
+      profile: entry.profile,
+      revision: entry.revision
+    }))
+  ];
+}
+function markersFor(state, row) {
+  const points = (scope) => !row.shadowed && state.selections[scope] === row.name;
+  const { effective } = state;
+  return {
+    effective: effective.name === row.name && (effective.source === void 0 || effective.source === row.scope) && !row.shadowed,
+    session: points("session"),
+    project: points("project"),
+    global: points("global")
+  };
+}
+var markerLetters = (markers) => [
+  markers.session ? "S" : "",
+  markers.project ? "P" : "",
+  markers.global ? "G" : ""
+].join("");
+function profileTitle(row, markers) {
+  const flags = `${markers.effective ? "\u25CF" : " "} ${markerLetters(markers).padEnd(3)}`;
+  return `${flags} ${row.name}${row.shadowed ? " ~" : ""}`;
+}
+function profileDescription(row) {
+  if (!row.scope) return "built-in \xB7 read-only";
+  return `${row.scope}${row.shadowed ? " \xB7 shadowed by project profile" : ""}`;
+}
+var PROFILE_LEGEND = "\u25CF effective \xB7 S session \xB7 P project pin \xB7 G global \xB7 ~ shadowed";
+function roleViews(state, profile, isDefault) {
+  return state.roles.map((role) => {
+    const own = profile.agents[role];
+    if (own?.model)
+      return { role, inherited: false, model: own.model, variant: own.variant };
+    const ownVariant = own?.variant;
+    const withVariant = (view) => ownVariant ? { ...view, variant: ownVariant, variantInherited: false } : view;
+    const base = state.defaultProfile.agents[role];
+    if (!isDefault && base?.model)
+      return withVariant({
+        role,
+        inherited: true,
+        model: base.model,
+        variant: base.variant,
+        inheritedFrom: "default"
+      });
+    if (role === "orchestrator" && state.orchestrator?.model)
+      return withVariant({
+        role,
+        inherited: true,
+        model: state.orchestrator.model,
+        variant: state.orchestrator.variant,
+        inheritedFrom: "session"
+      });
+    return { role, inherited: true };
+  });
+}
+function roleLabel(view) {
+  const model = view.model ?? "unset";
+  const variant = view.model ? view.variant ?? "none" : "-";
+  const prefix = `${view.role.padEnd(12)} ${model}`;
+  if (view.inherited && view.variantInherited === false)
+    return `${prefix} (inherited) \xB7 ${variant}`;
+  const text = `${prefix} \xB7 ${variant}`;
+  return view.inherited ? `${text} (inherited)` : text;
+}
+function roleDescription(view) {
+  if (!view.inherited) return "set in this profile";
+  if (view.inheritedFrom === "session") return "inherited from session model";
+  return view.inheritedFrom === "default" ? "inherited from default" : "unset \xB7 host default";
+}
+function providerModels(state, providerID) {
+  const provider = state.providers.find((item) => item.id === providerID);
+  return provider && {
+    id: provider.id,
+    name: provider.name,
+    models: provider.models.map((model) => ({
+      ...model,
+      // Profiles store the full `provider/model` id.
+      id: `${provider.id}/${model.id}`
+    }))
+  };
+}
+function variantsOf(state, modelId) {
+  for (const provider of state.providers)
+    for (const model of provider.models)
+      if (`${provider.id}/${model.id}` === modelId) return model.variants;
+  return [];
+}
+function searchOptions(query, options) {
+  const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+  return options.filter((option) => {
+    const id = typeof option.value === "string" ? option.value : "";
+    const text = `${option.title} ${id} ${option.description ?? ""}`.toLowerCase();
+    return words.every((word) => text.includes(word));
+  });
+}
+function validateProfileName(raw, scope, state) {
+  const name = raw.trim();
+  if (!name) return "Profile name must not be empty.";
+  if (name.toLowerCase() === DEFAULT_PROFILE)
+    return '"default" is reserved and read-only.';
+  if (state.profiles.some((p) => p.scope === scope && p.name === name))
+    return `A ${scope} profile named "${name}" already exists.`;
+  return void 0;
+}
+var normalize = (profile) => JSON.stringify(
+  Object.entries(profile.agents).filter(([, value]) => value?.model || value?.variant).map(([role, value]) => [role, value?.model, value?.variant]).sort(([a], [b]) => String(a).localeCompare(String(b)))
+);
+var isDirty = (draft) => draft.isNew || normalize(draft.profile) !== normalize(draft.base);
+function withRole(profile, role, value) {
+  const agents = { ...profile.agents };
+  if (value?.model || value?.variant) agents[role] = value;
+  else delete agents[role];
+  return { agents };
+}
+function cloneProfile(profile) {
+  return { agents: structuredClone(profile.agents) };
+}
+function openDraft(row) {
+  if (!row.scope) return void 0;
+  return {
+    scope: row.scope,
+    name: row.name,
+    isNew: false,
+    base: cloneProfile(row.profile),
+    revision: row.revision,
+    profile: cloneProfile(row.profile)
+  };
+}
+function newDraft(scope, name, from) {
+  return {
+    scope,
+    name,
+    isNew: true,
+    base: { agents: {} },
+    profile: cloneProfile(from)
+  };
+}
+var SCOPE_LABEL = {
+  session: "this session",
+  project: "this project",
+  global: "globally"
+};
+function effectiveSummary(state) {
+  const { effective } = state;
+  return effective.selectedBy === "default" ? `${effective.name} (built-in) is effective` : `${effective.name} is effective (${effective.selectedBy} selection)`;
+}
+function activationMessage(scope, name, state) {
+  const { effective } = state;
+  const head = `${name} set ${SCOPE_LABEL[scope]}`;
+  if (effective.selectedBy === scope && effective.name === name)
+    return `${head}; it is now effective.`;
+  if (effective.selectedBy === "session" && scope !== "session")
+    return `${head}, but this session keeps its session selection: ${effectiveSummary(state)}.`;
+  if (effective.selectedBy === "project" && scope === "global")
+    return `${head}, but the project pin takes precedence: ${effectiveSummary(state)}.`;
+  return `${head}; ${effectiveSummary(state)}.`;
+}
+function clearMessage(scope, state) {
+  return `Cleared ${scope} selection; ${effectiveSummary(state)}.`;
+}
+function selectionClearable(state, sessionAvailable) {
+  return ["session", "project", "global"].filter(
+    (scope) => state.selections[scope] !== void 0 && (scope !== "session" || sessionAvailable)
+  );
+}
+
+// src/tui/flow.ts
+var TITLE = "Subagent model profiles";
+var NONE = "none";
+async function runModelProfilesFlow(ports) {
+  const { ui, rpc } = ports;
+  const sessionID = ports.sessionID();
+  const session = sessionID ? { sessionID } : {};
+  const sessionRequired = "Open a session to use this action.";
+  async function call(run) {
+    try {
+      return await run();
+    } catch (error) {
+      return {
+        ok: false,
+        error: {
+          code: "OPERATION_FAILED",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
+  const toast = (message, variant = "info") => ui.toast.show({ title: TITLE, message, variant, duration: 6e3 });
+  const fail = (error) => toast(`${error.code}: ${error.message}`, "error");
+  let state;
+  const loaded = await call(() => rpc.state(session));
+  if (!loaded.ok) return fail(loaded.error);
+  state = loaded.value;
+  const refresh = async () => {
+    const next2 = await call(() => rpc.state(session));
+    if (!next2.ok) {
+      fail(next2.error);
+      return false;
+    }
+    state = next2.value;
+    return true;
+  };
+  const rowOf = (key) => profileRows(state).find((row) => row.key === key);
+  const markers = (row) => markersFor(state, row);
+  const effectiveText = () => state.effective.selectedBy === "default" ? `${state.effective.name} (built-in)` : `${state.effective.name} (${state.effective.selectedBy})`;
+  async function pickProvider(role) {
+    if (!state.providers.length) {
+      toast("No models available in the catalog.", "warning");
+      return void 0;
+    }
+    const picked = await ui.select({
+      title: `Provider for ${role}`,
+      placeholder: "Search providers",
+      options: [
+        {
+          title: "Reset to inherited",
+          value: "",
+          category: "Actions",
+          description: "remove this role override"
+        },
+        ...state.providers.map((provider) => ({
+          title: provider.name,
+          value: provider.id,
+          description: `${provider.models.length} model${provider.models.length === 1 ? "" : "s"}`,
+          category: "Providers"
+        }))
+      ],
+      search: searchOptions
+    });
+    return picked === void 0 ? void 0 : picked || null;
+  }
+  async function pickModel(role, providerID, current) {
+    const provider = providerModels(state, providerID);
+    if (!provider) return void 0;
+    return ui.select({
+      title: `${provider.name} model for ${role}`,
+      placeholder: "Search models",
+      current,
+      options: provider.models.map((model) => ({
+        // Names can collide across Codex/API models and dated snapshots. Put
+        // the exact local ID first; a non-shrinking footer crowds it out.
+        title: model.id.slice(provider.id.length + 1),
+        value: model.id,
+        description: model.variants.length ? `${model.name} \xB7 variants: ${model.variants.join(", ")}` : model.name
+      })),
+      search: searchOptions
+    });
+  }
+  async function pickVariant(role, modelId, current) {
+    const variants = variantsOf(state, modelId);
+    return ui.select({
+      title: `Variant for ${role}`,
+      placeholder: "Search variants",
+      current: current ?? NONE,
+      options: [
+        {
+          title: NONE,
+          value: NONE,
+          description: `${modelId} default`
+        },
+        ...variants.map((variant) => ({ title: variant, value: variant }))
+      ],
+      search: searchOptions
+    });
+  }
+  async function editModel(draft, view, withVariant) {
+    const providerID = await pickProvider(view.role);
+    if (providerID === void 0) return;
+    if (providerID === null) {
+      draft.profile = withRole(draft.profile, view.role, void 0);
+      return;
+    }
+    const model = await pickModel(view.role, providerID, view.model);
+    if (!model) return;
+    let variant;
+    if (withVariant && variantsOf(state, model).length) {
+      const picked = await pickVariant(view.role, model);
+      if (picked === void 0) return;
+      variant = picked === NONE ? void 0 : picked;
+    }
+    draft.profile = withRole(draft.profile, view.role, {
+      model,
+      ...variant ? { variant } : {}
+    });
+  }
+  async function editVariant(draft, view) {
+    if (!view.model) {
+      toast("Set a model first; the variant belongs to the model.", "warning");
+      return;
+    }
+    if (!variantsOf(state, view.model).length) {
+      toast(`${view.model} has no variants.`, "info");
+      return;
+    }
+    const picked = await pickVariant(view.role, view.model, view.variant);
+    if (picked === void 0) return;
+    if (!view.inherited) {
+      draft.profile = withRole(draft.profile, view.role, {
+        model: view.model,
+        ...picked === NONE ? {} : { variant: picked }
+      });
+      return;
+    }
+    draft.profile = withRole(
+      draft.profile,
+      view.role,
+      picked === NONE ? void 0 : { variant: picked }
+    );
+  }
+  async function editRole(draft, view) {
+    const picked = await ui.select({
+      title: `Edit ${view.role}`,
+      options: [
+        {
+          title: "Change model and variant",
+          value: "both",
+          description: view.model ? `now ${roleLabel(view)}` : void 0
+        },
+        {
+          title: "Change variant only",
+          value: "variant",
+          description: view.model ? `variants of ${view.model}` : "needs a model first"
+        },
+        {
+          title: "Reset to inherited",
+          value: "reset",
+          description: "remove this role override",
+          disabled: view.inherited && view.variantInherited !== false
+        }
+      ]
+    });
+    if (picked === "both") await editModel(draft, view, true);
+    else if (picked === "variant") await editVariant(draft, view);
+    else if (picked === "reset")
+      draft.profile = withRole(draft.profile, view.role, void 0);
+  }
+  async function persist(draft) {
+    if (draft.isNew) {
+      const created = await call(
+        () => rpc.create({
+          scope: draft.scope,
+          name: draft.name,
+          profile: draft.profile
+        })
+      );
+      if (!created.ok) {
+        fail(created.error);
+        return false;
+      }
+      draft.revision = created.value.revision;
+    } else {
+      const baseRevision = draft.revision;
+      if (baseRevision === void 0) return false;
+      const saved = await call(
+        () => rpc.save({
+          scope: draft.scope,
+          name: draft.name,
+          profile: draft.profile,
+          baseRevision
+        })
+      );
+      if (!saved.ok) {
+        if (saved.error.code === "PROFILE_CONFLICT") {
+          await offerReload(draft, saved.error);
+          return false;
+        }
+        fail(saved.error);
+        return false;
+      }
+      draft.revision = saved.value.revision;
+    }
+    draft.isNew = false;
+    draft.base = { agents: structuredClone(draft.profile.agents) };
+    await refresh();
+    toast(`Saved ${draft.name} (${draft.scope}).`, "success");
+    return true;
+  }
+  async function offerReload(draft, error) {
+    const reload = await ui.confirm({
+      title: "Profile changed on disk",
+      message: `${error.message}
+Reload the saved profile and discard your edits?`,
+      label: { confirm: "Reload", cancel: "Keep editing" }
+    });
+    if (!reload || !await refresh()) return;
+    const row = rowOf(profileKey(draft.name, draft.scope));
+    const fresh = row && openDraft(row);
+    if (fresh) Object.assign(draft, fresh);
+    else toast(`${draft.name} no longer exists on disk.`, "warning");
+  }
+  async function activate(draft, row, scope) {
+    if (draft && isDirty(draft)) {
+      const choice = await ui.select({
+        title: "Unsaved changes",
+        options: [
+          { title: "Save, then activate", value: "save" },
+          { title: "Cancel", value: "cancel" }
+        ]
+      });
+      if (choice !== "save" || !await persist(draft)) return;
+    }
+    if (row.shadowed) {
+      const go = await ui.confirm({
+        title: "Shadowed profile",
+        message: `A project profile named "${row.name}" shadows this global one; selecting by name activates the project profile.`,
+        label: { confirm: "Activate anyway", cancel: "Cancel" }
+      });
+      if (!go) return;
+    }
+    const result = await call(
+      () => rpc.activate({ ...session, scope, name: row.name })
+    );
+    if (!result.ok) return fail(result.error);
+    state = result.value;
+    toast(
+      activationMessage(scope, row.name, state),
+      state.effective.name === row.name ? "success" : "warning"
+    );
+  }
+  async function clearSelection(scope) {
+    const result = await call(() => rpc.clear({ ...session, scope }));
+    if (!result.ok) return fail(result.error);
+    state = result.value;
+    toast(clearMessage(scope, state), "success");
+  }
+  async function askName(scope, initial) {
+    let value = initial;
+    for (; ; ) {
+      const raw = await ui.prompt({
+        title: "Profile name",
+        description: `New ${scope} profile (\`default\` is reserved)`,
+        placeholder: "e.g. fast-review",
+        value
+      });
+      if (raw === void 0) return void 0;
+      const problem = validateProfileName(raw, scope, state);
+      if (!problem) return raw.trim();
+      toast(problem, "warning");
+      value = raw;
+    }
+  }
+  async function startNew(source) {
+    const scope = await ui.select({
+      title: "Where should the profile live?",
+      options: [
+        { title: "global", value: "global", description: "all projects" },
+        {
+          title: "project",
+          value: "project",
+          description: "this project only (.opencode/thoth)"
+        }
+      ]
+    });
+    if (!scope) return void 0;
+    const name = await askName(scope);
+    if (!name) return void 0;
+    const from = (source ?? profileRows(state)[0]).profile;
+    return newDraft(scope, name, from);
+  }
+  async function pickSource() {
+    const rows = profileRows(state);
+    const key = await ui.select({
+      title: "Create from",
+      placeholder: "Search profiles",
+      options: rows.map((row) => ({
+        title: row.key === "default" ? "Start from default" : `Clone ${row.name}`,
+        value: row.key,
+        description: profileDescription(row),
+        category: row.key === "default" ? "Default" : "Clone"
+      })),
+      search: searchOptions
+    });
+    return key ? rowOf(key) : void 0;
+  }
+  const pending = /* @__PURE__ */ new Map();
+  async function settlePending() {
+    for (const [key, draft] of [...pending]) {
+      const choice = await ui.select({
+        title: `Unsaved changes in ${draft.name}`,
+        options: [
+          { title: "Save", value: "save" },
+          { title: "Discard", value: "discard" },
+          { title: "Keep editing", value: "keep" }
+        ]
+      });
+      if (!choice || choice === "keep") return false;
+      if (choice === "save" && !await persist(draft)) return false;
+      pending.delete(key);
+    }
+    return true;
+  }
+  async function detail(start) {
+    const resumed = "key" in start ? pending.get(start.key) : void 0;
+    if (resumed && "key" in start) pending.delete(start.key);
+    let draft = "key" in start ? resumed ?? openDraft(start) : start;
+    const readonlyRow = "key" in start && !draft ? start : void 0;
+    for (; ; ) {
+      const row = draft ? rowOf(profileKey(draft.name, draft.scope)) ?? (draft.isNew ? {
+        key: profileKey(draft.name, draft.scope),
+        name: draft.name,
+        scope: draft.scope,
+        shadowed: false,
+        profile: draft.profile
+      } : void 0) : readonlyRow && rowOf(readonlyRow.key);
+      if (!row) return void 0;
+      const profile = draft?.profile ?? row.profile;
+      const views = roleViews(state, profile, row.key === "default");
+      const dirty = draft ? isDirty(draft) : false;
+      const flags = markers(row);
+      const options = [
+        ...views.map((view) => ({
+          title: roleLabel(view),
+          value: { t: "role", role: view.role },
+          description: roleDescription(view),
+          category: "Roles"
+        })),
+        ...dirty ? [
+          {
+            title: "Save changes",
+            value: { t: "save" },
+            category: "Edit"
+          },
+          {
+            title: draft?.isNew ? "Discard draft" : "Discard edits",
+            value: { t: "discard" },
+            category: "Edit"
+          }
+        ] : [],
+        ...draft ? [
+          {
+            title: "Capture session model into orchestrator",
+            value: { t: "capture" },
+            disabled: !sessionID,
+            description: !sessionID ? sessionRequired : state.orchestrator?.model ? `now ${state.orchestrator.model}${state.orchestrator.variant ? ` \xB7 ${state.orchestrator.variant}` : ""}` : "no session model yet",
+            category: "Edit"
+          }
+        ] : [],
+        {
+          title: "Use for this session",
+          value: { t: "use", scope: "session" },
+          category: "Activate",
+          disabled: !sessionID,
+          description: !sessionID ? sessionRequired : flags.session ? "already selected" : void 0
+        },
+        {
+          title: "Pin to this project",
+          value: { t: "use", scope: "project" },
+          category: "Activate",
+          description: flags.project ? "already selected" : void 0
+        },
+        {
+          title: "Set as global active",
+          value: { t: "use", scope: "global" },
+          category: "Activate",
+          description: flags.global ? "already selected" : void 0
+        },
+        {
+          title: "Clone this profile",
+          value: { t: "clone" },
+          category: "Manage"
+        },
+        ...draft && !draft.isNew ? [
+          {
+            title: "Rename",
+            value: { t: "rename" },
+            category: "Manage"
+          },
+          {
+            title: "Delete",
+            value: { t: "delete" },
+            category: "Manage"
+          }
+        ] : [],
+        {
+          title: "Back",
+          value: { t: "back" },
+          category: "Manage"
+        }
+      ];
+      const title = `${profileTitle(row, flags).trim()}${row.scope ? ` (${row.scope})` : ""}${dirty ? " *" : ""}`;
+      const pick = await ui.select({
+        title: `${title} \u2014 ${effectiveText()} effective`,
+        placeholder: draft ? "Search roles and actions" : "Search (read-only)",
+        options,
+        search: searchOptions
+      });
+      if (!pick || pick.t === "back") {
+        if (draft && isDirty(draft)) {
+          const choice = await ui.select({
+            title: `Unsaved changes in ${draft.name}`,
+            options: [
+              { title: "Save", value: "save" },
+              { title: "Discard", value: "discard" },
+              { title: "Keep editing", value: "keep" }
+            ]
+          });
+          if (!choice || choice === "keep") continue;
+          if (choice === "save" && !await persist(draft)) continue;
+        }
+        return void 0;
+      }
+      if (pick.t === "role") {
+        const view = views.find((item) => item.role === pick.role);
+        if (!view) continue;
+        if (!draft) toast("default is read-only; clone it to edit.", "info");
+        else await editRole(draft, view);
+      } else if (pick.t === "save") await persist(draft);
+      else if (pick.t === "discard") {
+        const ok = await ui.confirm({
+          title: "Discard changes",
+          message: `Discard unsaved changes to ${draft?.name}?`,
+          label: { confirm: "Discard", cancel: "Keep editing" }
+        });
+        if (!ok) continue;
+        if (draft?.isNew) return void 0;
+        const fresh = openDraft(row);
+        if (fresh) draft = fresh;
+      } else if (pick.t === "capture" && sessionID) {
+        const captured = await call(() => rpc.capture({ sessionID }));
+        if (!captured.ok) fail(captured.error);
+        else if (!captured.value.model)
+          toast("No session model to capture yet.", "warning");
+        else if (draft) {
+          const { model, variant } = captured.value;
+          draft.profile = withRole(draft.profile, "orchestrator", {
+            model,
+            ...variant ? { variant } : {}
+          });
+          toast(`Orchestrator set to ${model} (unsaved).`, "info");
+        }
+      } else if (pick.t === "use") await activate(draft, row, pick.scope);
+      else if (pick.t === "clone") {
+        const clone = await startNew({ ...row, profile });
+        if (clone) {
+          if (draft && isDirty(draft)) {
+            pending.set(profileKey(draft.name, draft.scope), draft);
+            toast("Cloned including your unsaved edits.", "info");
+          }
+          return clone;
+        }
+      } else if (pick.t === "rename" && draft) {
+        if (isDirty(draft)) {
+          toast("Save or discard your edits before renaming.", "warning");
+          continue;
+        }
+        const newName = await askName(draft.scope, draft.name);
+        if (!newName || newName === draft.name) continue;
+        const renamed = await call(
+          () => rpc.rename({
+            scope: draft?.scope,
+            name: draft?.name,
+            newName
+          })
+        );
+        if (!renamed.ok) {
+          fail(renamed.error);
+          continue;
+        }
+        if (!await refresh()) return void 0;
+        const next2 = rowOf(profileKey(newName, draft.scope));
+        draft = next2 && openDraft(next2);
+        toast(`Renamed to ${newName}.`, "success");
+        if (!draft) return void 0;
+      } else if (pick.t === "delete" && draft) {
+        const ok = await ui.confirm({
+          title: `Delete ${draft.name}`,
+          message: `Delete the ${draft.scope} profile "${draft.name}"? Selections pointing at it fall back.`,
+          label: { confirm: "Delete", cancel: "Cancel" }
+        });
+        if (!ok) continue;
+        const deleted = await call(
+          () => rpc.delete({
+            scope: draft?.scope,
+            name: draft?.name
+          })
+        );
+        if (!deleted.ok) {
+          fail(deleted.error);
+          continue;
+        }
+        await refresh();
+        toast(`Deleted ${draft.name}.`, "success");
+        return void 0;
+      }
+    }
+  }
+  let next;
+  let last = state.effective.source ? profileKey(state.effective.name, state.effective.source) : "default";
+  for (; ; ) {
+    if (next) {
+      const follow = await detail(next);
+      next = follow;
+      continue;
+    }
+    const rows = profileRows(state);
+    const clearable = selectionClearable(state, !!sessionID);
+    const options = [
+      ...rows.map((row) => ({
+        title: profileTitle(row, markers(row)),
+        value: `profile:${row.key}`,
+        description: profileDescription(row),
+        category: "Profiles"
+      })),
+      {
+        title: "New profile\u2026",
+        value: "new",
+        description: "from default or by cloning",
+        category: "Actions"
+      },
+      ...!sessionID ? [
+        {
+          title: "Clear session selection",
+          value: "clear:session",
+          disabled: true,
+          description: sessionRequired,
+          category: "Actions"
+        }
+      ] : [],
+      ...clearable.map((scope) => ({
+        title: `Clear ${scope} selection`,
+        value: `clear:${scope}`,
+        description: `currently ${state.selections[scope]}`,
+        category: "Actions"
+      })),
+      ...state.warnings.length ? [
+        {
+          title: `Warnings (${state.warnings.length})`,
+          value: "warnings",
+          description: state.warnings[0],
+          category: "Actions"
+        }
+      ] : []
+    ];
+    const pick = await ui.select({
+      title: `${TITLE} \u2014 ${effectiveText()}`,
+      placeholder: `Search profiles \xB7 ${PROFILE_LEGEND}`,
+      options,
+      current: `profile:${last}`,
+      search: searchOptions
+    });
+    if (!pick) {
+      if (await settlePending()) return;
+      continue;
+    }
+    if (pick.startsWith("profile:")) {
+      last = pick.slice("profile:".length);
+      const row = rowOf(last);
+      if (row) next = row;
+    } else if (pick === "new") {
+      const source = await pickSource();
+      if (source) next = await startNew(source);
+    } else if (pick.startsWith("clear:"))
+      await clearSelection(pick.slice("clear:".length));
+    else
+      await ui.alert({
+        title: "Profile warnings",
+        message: state.warnings.join("\n")
+      });
+  }
+}
+
+// src/tui/tools/model.ts
+var LOCKED_ACTION = "subagent";
+var LOCKED_MESSAGE = "subagent is locked: specialists can never delegate, so it cannot be changed.";
+function matchAction(input, pattern, platform = typeof process === "undefined" ? "" : process.platform) {
+  const normalized = input.replaceAll("\\", "/");
+  let escaped = pattern.replaceAll("\\", "/").replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*/g, ".*").replace(/\?/g, ".");
+  if (escaped.endsWith(" .*")) escaped = `${escaped.slice(0, -3)}( .*)?`;
+  return new RegExp(`^${escaped}$`, platform === "win32" ? "si" : "s").test(
+    normalized
+  );
+}
+var removeOverride = (overrides, action) => overrides.filter((entry) => entry.action !== action).map((e) => ({ ...e }));
+var setOverride = (overrides, value) => [...removeOverride(overrides, value.action), { ...value }];
+var hasWildcard = (pattern) => /[*?]/.test(pattern);
+var roleOf = (state, role) => {
+  const found = state.roles.find((item) => item.role === role);
+  if (!found) throw new Error(`Unknown role ${role}`);
+  return found;
+};
+var stripCounts = (entries) => entries.map(({ action, effect }) => ({ action, effect }));
+function openDraft2(state, role, scope) {
+  const view = roleOf(state, role)[scope];
+  const overrides = stripCounts(view.overrides);
+  return {
+    role,
+    scope,
+    base: structuredClone(overrides),
+    overrides: structuredClone(overrides),
+    present: view.present,
+    basePresent: view.present,
+    revision: view.revision
+  };
+}
+var isDirty2 = (draft) => draft.present !== draft.basePresent || JSON.stringify(draft.base) !== JSON.stringify(draft.overrides);
+function applyOverrides(draft, next) {
+  if (JSON.stringify(next) !== JSON.stringify(draft.overrides)) {
+    draft.overrides = next;
+    if (draft.scope === "project") draft.present = true;
+  }
+}
+function maskGlobal(draft) {
+  if (draft.scope === "project") draft.present = true;
+}
+function effectiveLayer(state, draft) {
+  const role = roleOf(state, draft.role);
+  if (draft.scope === "project") {
+    if (draft.present)
+      return { scope: "project", overrides: draft.overrides, controls: true };
+    return {
+      scope: role.global.present ? "global" : "default",
+      overrides: stripCounts(role.global.overrides),
+      controls: false
+    };
+  }
+  if (role.project.present)
+    return {
+      scope: "project",
+      overrides: stripCounts(role.project.overrides),
+      controls: false
+    };
+  return { scope: "global", overrides: draft.overrides, controls: true };
+}
+var isInactiveScope = (state, draft) => draft.scope === "global" && roleOf(state, draft.role).project.present;
+function scopeStatus(state, draft) {
+  if (isInactiveScope(state, draft))
+    return "INACTIVE PREVIEW: project controls this role, global edits do not apply here";
+  if (draft.scope === "project" && !draft.present)
+    return "project entry absent: global applies";
+  if (draft.scope === "project" && !draft.overrides.length)
+    return "project masks global overrides";
+  return "effective after save";
+}
+var defaultScope = (role) => role.effectiveScope === "default" ? "global" : role.effectiveScope;
+var plural = (count, word) => `${count} ${word}${count === 1 ? "" : "s"}`;
+function roleSummary(role) {
+  if (role.effectiveScope === "default") return "defaults";
+  const entries = role[role.effectiveScope].overrides;
+  if (!entries.length) return "no overrides";
+  const parts = [];
+  const count = (effect) => entries.filter((entry) => entry.effect === effect).length;
+  if (count("deny")) parts.push(`${count("deny")} denied`);
+  if (count("ask")) parts.push(`${count("ask")} ask`);
+  if (count("allow")) parts.push(`${count("allow")} allowed`);
+  return parts.join(", ");
+}
+var scopeMarker = (role) => role.effectiveScope === "global" ? "G" : role.effectiveScope === "project" ? "P" : " ";
+function overviewTitle(role) {
+  const count = role.effectiveScope === "default" ? 0 : role[role.effectiveScope].overrides.length;
+  return `${scopeMarker(role).padEnd(1)} ${role.role.padEnd(10)} ${plural(count, "override")}`;
+}
+var OVERVIEW_LEGEND = "G global \xB7 P project \xB7 project replaces global";
+var lastMatch = (overrides, action, platform) => {
+  let match;
+  for (const entry of overrides)
+    if (matchAction(action, entry.action, platform)) match = entry;
+  return match;
+};
+function previewRows(state, draft) {
+  const role = roleOf(state, draft.role);
+  const platform = typeof process === "undefined" ? "" : process.platform;
+  const layer = effectiveLayer(state, draft);
+  const dirty = isDirty2(draft);
+  return state.inventory.map((item) => {
+    const current = role.actions.find((a) => a.action === item.action);
+    const locked = item.locked || current?.locked === true;
+    if (locked)
+      return {
+        action: item.action,
+        tools: item.tools,
+        locked: true,
+        effect: current?.effect ?? "deny",
+        source: "default",
+        origin: "default",
+        editScope: draft.scope,
+        inactive: false,
+        changed: false
+      };
+    const match = lastMatch(layer.overrides, item.action, platform);
+    const base = current?.baseEffect ?? "ask";
+    const effect = match?.effect ?? base;
+    const source = !match ? "default" : match.action === item.action ? "entry" : "pattern";
+    const own = layer.controls ? void 0 : lastMatch(draft.overrides, item.action, platform)?.effect ?? base;
+    return {
+      action: item.action,
+      tools: item.tools,
+      locked: false,
+      effect,
+      source,
+      via: source === "pattern" ? match?.action : void 0,
+      origin: match ? layer.scope === "default" ? "default" : layer.scope : "default",
+      editScope: draft.scope,
+      inactive: draft.scope === "global" && !layer.controls,
+      scopeEffect: draft.scope === "global" ? own : void 0,
+      changed: dirty && effect !== current?.effect
+    };
+  });
+}
+function rowTitle(row) {
+  const mark = row.locked ? "\u{1F512}" : row.source === "default" ? "\xB7" : row.source === "entry" ? "\u25CF" : "\u25CB";
+  return `${mark} ${row.effect.padEnd(5)} ${row.action}${row.changed ? " *" : ""}`;
+}
+function rowDescription(row) {
+  const origin = row.locked ? "locked" : row.source === "default" ? "default (inherited)" : row.source === "entry" ? "override" : `via ${row.via}`;
+  const tools = row.tools.length ? row.tools.join(", ") : "no tools";
+  const from = row.origin !== "default" && row.origin !== row.editScope ? `${row.origin} ` : "";
+  const alone = row.inactive ? ` \xB7 global alone would ${row.scopeEffect}` : "";
+  return `${from}${origin}${alone} \xB7 ${tools}`;
+}
+var ROLE_LEGEND = "\u25CF override \xB7 \u25CB via pattern \xB7 \xB7 default \xB7 \u{1F512} locked";
+var countMatches = (state, pattern) => {
+  const platform = typeof process === "undefined" ? "" : process.platform;
+  return state.inventory.filter(
+    (item) => matchAction(item.action, pattern, platform)
+  ).length;
+};
+function manualEntries(state, draft) {
+  const known = new Set(state.inventory.map((item) => item.action));
+  const saved = roleOf(state, draft.role)[draft.scope].overrides;
+  return draft.overrides.filter((entry) => hasWildcard(entry.action) || !known.has(entry.action)).map((entry) => ({
+    ...entry,
+    // Saved patterns use host matching semantics; only new patterns need a local estimate.
+    matchCount: saved.find((item) => item.action === entry.action)?.matchCount ?? countMatches(state, entry.action)
+  }));
+}
+var entryDescription = (entry) => `matches ${plural(entry.matchCount, "action")}${entry.matchCount === 0 ? " (no registered tool)" : ""}`;
+function validatePattern(raw) {
+  const pattern = raw.trim();
+  if (!pattern) return "Enter a tool action or a wildcard pattern.";
+  if (pattern === LOCKED_ACTION) return LOCKED_MESSAGE;
+  return void 0;
+}
+function searchOptions2(query, options) {
+  const words = query.toLowerCase().split(/\s+/).filter(Boolean);
+  return options.filter((option) => {
+    const text = `${option.title} ${option.description ?? ""}`.toLowerCase();
+    return words.every((word) => text.includes(word));
+  });
+}
+
+// src/tui/tools/flow.ts
+var TITLE2 = "Subagent tool permissions";
+var EFFECTS = ["allow", "ask", "deny"];
+async function runToolsFlow(ports) {
+  const { ui, rpc } = ports;
+  async function call(run) {
+    try {
+      return await run();
+    } catch (error) {
+      return {
+        ok: false,
+        error: {
+          code: "OPERATION_FAILED",
+          message: error instanceof Error ? error.message : String(error)
+        }
+      };
+    }
+  }
+  const toast = (message, variant = "info") => ui.toast.show({ title: TITLE2, message, variant, duration: 6e3 });
+  const fail = (error) => toast(`${error.code}: ${error.message}`, "error");
+  const loaded = await call(() => rpc.state({}));
+  if (!loaded.ok) return fail(loaded.error);
+  let state = loaded.value;
+  const refresh = async () => {
+    const next = await call(() => rpc.state({}));
+    if (!next.ok) {
+      fail(next.error);
+      return false;
+    }
+    state = next.value;
+    return true;
+  };
+  const reopen = (draft) => Object.assign(draft, openDraft2(state, draft.role, draft.scope));
+  async function offerReload(draft, error) {
+    const reload = await ui.confirm({
+      title: "Tool overrides changed on disk",
+      message: `${error.message}
+Reload the saved overrides and discard your edits?`,
+      label: { confirm: "Reload", cancel: "Keep editing" }
+    });
+    if (reload && await refresh()) reopen(draft);
+  }
+  async function persist(draft) {
+    const saved = await call(
+      () => rpc.save({
+        scope: draft.scope,
+        role: draft.role,
+        overrides: draft.overrides,
+        baseRevision: draft.revision
+      })
+    );
+    if (!saved.ok) {
+      if (saved.error.code === "TOOLS_CONFLICT")
+        await offerReload(draft, saved.error);
+      else fail(saved.error);
+      return false;
+    }
+    state = saved.value;
+    reopen(draft);
+    toast(`Saved ${draft.role} (${draft.scope}).`, "success");
+    return true;
+  }
+  async function resetRole(draft) {
+    const ok = await ui.confirm({
+      title: `Reset ${draft.role} to defaults`,
+      message: `Remove all ${draft.scope} overrides for ${draft.role}${isDirty2(draft) ? " and discard unsaved edits" : ""}?${draft.scope === "project" ? "" : " A project entry for this role would still replace global."}`,
+      label: { confirm: "Reset", cancel: "Cancel" }
+    });
+    if (!ok) return;
+    const result = await call(
+      () => rpc.reset({
+        scope: draft.scope,
+        role: draft.role,
+        baseRevision: draft.revision
+      })
+    );
+    if (!result.ok) {
+      if (result.error.code === "TOOLS_CONFLICT")
+        await offerReload(draft, result.error);
+      else fail(result.error);
+      return;
+    }
+    state = result.value;
+    reopen(draft);
+    toast(`Reset ${draft.role} (${draft.scope}) to defaults.`, "success");
+  }
+  async function pickScope(role) {
+    const view = roleOf(state, role);
+    const describe = (scope) => {
+      const entries = view[scope].overrides.length;
+      return `${entries} override${entries === 1 ? "" : "s"}${view.effectiveScope === scope ? " \xB7 in effect" : scope === "global" && view.project.present ? " \xB7 inactive (project replaces global)" : ""}`;
+    };
+    return ui.select({
+      title: `Edit ${role} \u2014 project replaces global for this role`,
+      current: defaultScope(view),
+      options: ["global", "project"].map((scope) => ({
+        title: scope,
+        value: scope,
+        description: describe(scope)
+      }))
+    });
+  }
+  async function pickEffect(title, current, extra) {
+    return ui.select({
+      title,
+      current,
+      options: [
+        {
+          title: extra === "inherit" ? "Inherit" : "Remove entry",
+          value: extra,
+          description: extra === "inherit" ? "drop exact entries for this action; the default applies" : "delete this override"
+        },
+        ...EFFECTS.map((effect) => ({
+          title: effect,
+          value: effect
+        }))
+      ]
+    });
+  }
+  async function addPattern(draft) {
+    let value;
+    for (; ; ) {
+      const raw = await ui.prompt({
+        title: "Add pattern",
+        description: "Tool action or wildcard (* and ?), e.g. github_* \u2014 last match wins",
+        placeholder: "e.g. webfetch or github_*",
+        value
+      });
+      if (raw === void 0) return;
+      const problem = validatePattern(raw);
+      if (problem) {
+        toast(problem, "warning");
+        value = raw;
+        continue;
+      }
+      const pattern = raw.trim();
+      const count = countMatches(state, pattern);
+      const picked = await ui.select({
+        title: `${pattern} matches ${count} action${count === 1 ? "" : "s"}${count === 0 ? " (none registered yet)" : ""} \u2014 effect?`,
+        options: [
+          ...EFFECTS.map((effect) => ({ title: effect, value: effect })),
+          {
+            title: "Edit pattern\u2026",
+            value: "edit",
+            description: "go back to the prompt"
+          }
+        ]
+      });
+      if (picked === void 0) return;
+      if (picked === "edit") {
+        value = raw;
+        continue;
+      }
+      applyOverrides(
+        draft,
+        setOverride(draft.overrides, { action: pattern, effect: picked })
+      );
+      return;
+    }
+  }
+  async function settle(draft) {
+    if (!isDirty2(draft)) return true;
+    const choice = await ui.select({
+      title: `Unsaved changes in ${draft.role} (${draft.scope})`,
+      options: [
+        { title: "Save", value: "save" },
+        { title: "Discard", value: "discard" },
+        { title: "Keep editing", value: "keep" }
+      ]
+    });
+    if (!choice || choice === "keep") return false;
+    return choice === "discard" || await persist(draft);
+  }
+  async function roleView(draft) {
+    for (; ; ) {
+      const rows = previewRows(state, draft);
+      const manual = manualEntries(state, draft);
+      const dirty = isDirty2(draft);
+      const options = [
+        ...rows.map((row) => ({
+          title: rowTitle(row),
+          value: { t: "action", action: row.action },
+          description: rowDescription(row),
+          category: "Actions"
+        })),
+        ...manual.map((entry) => ({
+          title: `${entry.effect.padEnd(5)} ${entry.action}`,
+          value: {
+            t: "entry",
+            index: draft.overrides.findIndex(
+              (o) => o.action === entry.action && o.effect === entry.effect
+            )
+          },
+          description: entryDescription(entry),
+          category: "Manual entries"
+        })),
+        {
+          title: "Add pattern\u2026",
+          value: { t: "add" },
+          description: "allow, ask or deny an action or wildcard",
+          category: "Manual entries"
+        },
+        ...dirty ? [
+          {
+            title: "Save changes",
+            value: { t: "save" },
+            category: "Edit"
+          },
+          {
+            title: "Discard edits",
+            value: { t: "discard" },
+            category: "Edit"
+          }
+        ] : [],
+        ...draft.scope === "project" && !draft.present ? [
+          {
+            title: "Mask global overrides for this project (save empty list)",
+            value: { t: "mask" },
+            description: "a present empty project entry replaces global",
+            category: "Manage"
+          }
+        ] : [],
+        ...draft.scope === "project" && draft.basePresent && !draft.overrides.length ? [
+          {
+            title: "Remove project entry (use global)",
+            value: { t: "reset" },
+            description: "global overrides are masked until removed",
+            category: "Manage"
+          }
+        ] : [],
+        {
+          title: "Reset to defaults",
+          value: { t: "reset" },
+          description: `remove all ${draft.scope} overrides`,
+          category: "Manage"
+        },
+        {
+          title: "Switch scope",
+          value: { t: "scope" },
+          description: `editing ${draft.scope}`,
+          category: "Manage"
+        },
+        { title: "Back", value: { t: "back" }, category: "Manage" }
+      ];
+      const pick = await ui.select({
+        title: `${draft.role} (${draft.scope})${dirty ? " *" : ""} \u2014 ${scopeStatus(state, draft)} \u2014 ${ROLE_LEGEND}`,
+        placeholder: "Search actions and tools",
+        options,
+        search: searchOptions2
+      });
+      if (!pick || pick.t === "back") {
+        if (await settle(draft)) return void 0;
+        continue;
+      }
+      if (pick.t === "action") {
+        const row = rows.find((item) => item.action === pick.action);
+        if (!row) continue;
+        if (row.locked) {
+          toast(LOCKED_MESSAGE, "info");
+          continue;
+        }
+        const exact = draft.overrides.findLast(
+          (entry) => entry.action === row.action
+        );
+        const picked = await pickEffect(
+          `${row.action} \u2014 ${row.effect}`,
+          exact?.effect ?? "inherit",
+          "inherit"
+        );
+        if (!picked) continue;
+        if (picked === "inherit" || picked === "remove") {
+          applyOverrides(draft, removeOverride(draft.overrides, row.action));
+          if (!exact && row.source === "pattern")
+            toast(`${row.via} still applies; edit it under Manual entries.`);
+        } else
+          applyOverrides(
+            draft,
+            setOverride(draft.overrides, {
+              action: row.action,
+              effect: picked
+            })
+          );
+      } else if (pick.t === "entry") {
+        const entry = draft.overrides[pick.index];
+        if (!entry) continue;
+        const picked = await pickEffect(
+          `${entry.action} \u2014 ${entry.effect}`,
+          entry.effect,
+          "remove"
+        );
+        if (!picked) continue;
+        applyOverrides(
+          draft,
+          picked === "remove" || picked === "inherit" ? removeOverride(draft.overrides, entry.action) : setOverride(draft.overrides, {
+            action: entry.action,
+            effect: picked
+          })
+        );
+      } else if (pick.t === "add") await addPattern(draft);
+      else if (pick.t === "mask") maskGlobal(draft);
+      else if (pick.t === "save") await persist(draft);
+      else if (pick.t === "discard") {
+        const ok = await ui.confirm({
+          title: "Discard changes",
+          message: `Discard unsaved changes to ${draft.role} (${draft.scope})?`,
+          label: { confirm: "Discard", cancel: "Keep editing" }
+        });
+        if (ok) reopen(draft);
+      } else if (pick.t === "reset") await resetRole(draft);
+      else if (pick.t === "scope") {
+        if (dirty) {
+          toast(
+            "Save or discard your edits before switching scope.",
+            "warning"
+          );
+          continue;
+        }
+        return "scope";
+      }
+    }
+  }
+  async function editRole(role) {
+    for (; ; ) {
+      const scope = await pickScope(role);
+      if (!scope) return;
+      const draft = openDraft2(state, role, scope);
+      if (await roleView(draft) !== "scope") return;
+    }
+  }
+  let last;
+  for (; ; ) {
+    const roles = state.specialists.map((role) => roleOf(state, role));
+    const pick = await ui.select({
+      title: TITLE2,
+      placeholder: `Search roles \xB7 ${OVERVIEW_LEGEND}`,
+      current: last,
+      options: [
+        ...roles.map((role) => ({
+          title: overviewTitle(role),
+          value: role.role,
+          description: roleSummary(role),
+          category: "Specialists"
+        })),
+        ...state.warnings.length ? [
+          {
+            title: `Warnings (${state.warnings.length})`,
+            value: "warnings",
+            description: state.warnings[0],
+            category: "Actions"
+          }
+        ] : []
+      ],
+      search: searchOptions2
+    });
+    if (!pick) return;
+    if (pick === "warnings")
+      await ui.alert({
+        title: "Tool permission warnings",
+        message: state.warnings.join("\n")
+      });
+    else {
+      last = pick;
+      await editRole(pick);
+    }
+  }
+}
+
+// src/tui/index.ts
+var SLASH = "subagents-model";
+var TOOLS_SLASH = "subagents-tools";
+var plugin = {
+  id: "thoth-agents.model-profiles",
+  setup(context) {
+    const rpc = context.client.rpc(profileRpc);
+    const toolsRpc = context.client.rpc(toolRpc);
+    const sessionID = () => {
+      const route = context.ui.router.current();
+      return route.type === "session" ? route.sessionID : void 0;
+    };
+    const { dialog, toast } = context.ui;
+    const ui = {
+      select: (options) => dialog.select(options),
+      prompt: (options) => dialog.prompt(options),
+      confirm: (options) => dialog.confirm(options),
+      alert: (options) => dialog.alert(options),
+      toast: { show: (options) => toast.show(options) }
+    };
+    let running = false;
+    const exclusive = async (run) => {
+      if (running) return;
+      running = true;
+      try {
+        await run();
+      } finally {
+        running = false;
+      }
+    };
+    context.keymap.layer(() => ({
+      mode: "global",
+      commands: [
+        {
+          id: "thoth-agents.subagents-model",
+          title: "Subagent model profiles",
+          description: "View, edit and activate subagent model profiles",
+          palette: true,
+          slash: { name: SLASH },
+          run: () => exclusive(() => runModelProfilesFlow({ ui, rpc, sessionID }))
+        },
+        {
+          id: "thoth-agents.subagents-tools",
+          title: "Subagent tool permissions",
+          description: "View and edit per-role allow/ask/deny tool overrides",
+          palette: true,
+          slash: { name: TOOLS_SLASH },
+          run: () => exclusive(() => runToolsFlow({ ui, rpc: toolsRpc }))
+        }
+      ]
+    }));
+  }
+};
+var tui_default = plugin;
+export {
+  tui_default as default
+};