thoth-agents 0.12.0 → 0.13.0

package/dist/tui/model.d.ts

@@ -0,0 +1,84 @@
+/** Pure view-model for the `/subagents-model` panel: no dialogs, no RPC. */
+import type { ProfileRpcInput, ProfileState } from '../opencode/profile-rpc';
+export declare const DEFAULT_PROFILE = "default";
+export type Profile = ProfileRpcInput<'create'>['profile'];
+export type RoleModel = Profile['agents'][keyof Profile['agents'] & string];
+export type Role = ProfileState['roles'][number];
+export type Scope = 'global' | 'project';
+export type SelectionScope = 'session' | 'project' | 'global';
+export type ProfileKey = 'default' | `${Scope}:${string}`;
+export interface ProfileRow {
+    key: ProfileKey;
+    name: string;
+    /** Undefined for the virtual `default`. */
+    scope?: Scope;
+    shadowed: boolean;
+    profile: Profile;
+    revision?: string;
+}
+export interface Markers {
+    effective: boolean;
+    session: boolean;
+    project: boolean;
+    global: boolean;
+}
+export declare const profileKey: (name: string, scope?: Scope) => ProfileKey;
+export declare function profileRows(state: ProfileState): ProfileRow[];
+export declare function markersFor(state: ProfileState, row: ProfileRow): Markers;
+export declare const markerLetters: (markers: Markers) => string;
+/** `● SPG name` — ● marks the profile runs currently use. */
+export declare function profileTitle(row: ProfileRow, markers: Markers): string;
+export declare function profileDescription(row: ProfileRow): string;
+export declare const PROFILE_LEGEND = "\u25CF effective \u00B7 S session \u00B7 P project pin \u00B7 G global \u00B7 ~ shadowed";
+export interface RoleView {
+    role: Role;
+    /** True when the row has no own model and shows a fallback. */
+    inherited: boolean;
+    model?: string;
+    variant?: string;
+    /** Where an inherited value comes from. */
+    inheritedFrom?: 'default' | 'session';
+    /** False when an own variant-only entry overrides the inherited variant. */
+    variantInherited?: boolean;
+}
+/** model + variant are a pair: an entry with a model owns its variant. */
+export declare function roleViews(state: ProfileState, profile: Profile, isDefault: boolean): RoleView[];
+export declare function roleLabel(view: RoleView): string;
+export declare function roleDescription(view: RoleView): string;
+export interface ModelChoice {
+    id: string;
+    name: string;
+    variants: string[];
+}
+export declare function providerModels(state: ProfileState, providerID: string): {
+    id: string;
+    name: string;
+    models: ModelChoice[];
+} | undefined;
+export declare function variantsOf(state: ProfileState, modelId: string): string[];
+/** Case-insensitive search over title, id and description. */
+export declare function searchOptions<T extends {
+    title: string;
+    description?: string;
+    value: unknown;
+}>(query: string, options: readonly T[]): T[];
+export declare function validateProfileName(raw: string, scope: Scope, state: ProfileState): string | undefined;
+/** Draft-until-save working copy of one persisted or new profile. */
+export interface Draft {
+    scope: Scope;
+    name: string;
+    isNew: boolean;
+    /** Last persisted profile, for dirty detection. */
+    base: Profile;
+    /** Opaque token from the server; undefined until a new draft is created. */
+    revision?: string;
+    profile: Profile;
+}
+export declare const isDirty: (draft: Draft) => boolean;
+export declare function withRole(profile: Profile, role: Role, value: RoleModel | undefined): Profile;
+export declare function cloneProfile(profile: Profile): Profile;
+export declare function openDraft(row: ProfileRow): Draft | undefined;
+export declare function newDraft(scope: Scope, name: string, from: Profile): Draft;
+export declare function activationMessage(scope: SelectionScope, name: string, state: ProfileState): string;
+export declare function clearMessage(scope: SelectionScope, state: ProfileState): string;
+export declare function selectionClearable(state: ProfileState, sessionAvailable: boolean): SelectionScope[];

package/dist/tui/tools/fixtures.d.ts

@@ -0,0 +1,3 @@
+import type { ToolState } from '../../opencode/tool-rpc';
+/** explorer: global deny webfetch + ask github*; designer: project allow bash. */
+export declare function makeToolState(): ToolState;

package/dist/tui/tools/flow.d.ts

@@ -0,0 +1,11 @@
+/** `/subagents-tools` flow. Talks only to injected UI and RPC ports. */
+import type { ToolRpcInput, ToolRpcMethod, ToolRpcOutput } from '../../opencode/tool-rpc';
+import type { Ui } from '../flow';
+export type ToolsRpcPort = {
+    [M in ToolRpcMethod]: (input: ToolRpcInput<M>) => Promise<ToolRpcOutput<M>>;
+};
+export interface ToolsFlowPorts {
+    ui: Ui;
+    rpc: ToolsRpcPort;
+}
+export declare function runToolsFlow(ports: ToolsFlowPorts): Promise<void>;

package/dist/tui/tools/model.d.ts

@@ -0,0 +1,97 @@
+/** Pure view-model for the `/subagents-tools` panel: no dialogs, no RPC. */
+import type { ToolState } from '../../opencode/tool-rpc';
+export type ToolRole = ToolState['specialists'][number];
+export type RoleState = ToolState['roles'][number];
+export type Scope = 'global' | 'project';
+export type Effect = 'allow' | 'ask' | 'deny';
+export interface Override {
+    action: string;
+    effect: Effect;
+}
+export declare const LOCKED_ACTION = "subagent";
+export declare const LOCKED_MESSAGE = "subagent is locked: specialists can never delegate, so it cannot be changed.";
+/** Mirrors OpenCode wildcard semantics (`src/opencode/tool-overrides/wildcard.ts`) without pulling in fs code. */
+export declare function matchAction(input: string, pattern: string, platform?: string): boolean;
+/** Inherit removes every exact entry, leaving broader patterns intact. */
+export declare const removeOverride: (overrides: readonly Override[], action: string) => Override[];
+/** Explicit choices go last so broader patterns cannot supersede the edit. */
+export declare const setOverride: (overrides: readonly Override[], value: Override) => Override[];
+export declare const hasWildcard: (pattern: string) => boolean;
+export declare const roleOf: (state: ToolState, role: ToolRole) => RoleState;
+export interface ToolDraft {
+    role: ToolRole;
+    scope: Scope;
+    /** Overrides as last saved/loaded, for dirty detection. */
+    base: Override[];
+    overrides: Override[];
+    /** Whether the scope has an entry for the role (absent differs from an explicit empty list). */
+    present: boolean;
+    basePresent: boolean;
+    revision: string;
+}
+/** Overrides of the given scope; used when opening a draft. */
+export declare function openDraft(state: ToolState, role: ToolRole, scope: Scope): ToolDraft;
+export declare const isDirty: (draft: ToolDraft) => boolean;
+/** Replaces the draft overrides; a changed project list makes the project entry present. */
+export declare function applyOverrides(draft: ToolDraft, next: Override[]): void;
+/** Makes an absent project entry an explicit empty list that masks global overrides. */
+export declare function maskGlobal(draft: ToolDraft): void;
+export interface EffectiveLayer {
+    /** Scope whose overrides apply after saving the draft. */
+    scope: 'default' | Scope;
+    overrides: Override[];
+    /** False when the edited scope would be shadowed by a project entry. */
+    controls: boolean;
+}
+/** Layering: a present project entry (even empty) replaces global entirely. */
+export declare function effectiveLayer(state: ToolState, draft: ToolDraft): EffectiveLayer;
+/** True when the edited scope is shadowed by a present project entry. */
+export declare const isInactiveScope: (state: ToolState, draft: ToolDraft) => boolean;
+/** Status line for the role view title. */
+export declare function scopeStatus(state: ToolState, draft: ToolDraft): string;
+/** Scope to preselect: the role's effective scope, else global. */
+export declare const defaultScope: (role: RoleState) => Scope;
+/** `2 denied, 1 ask` over the overrides in force for a role. */
+export declare function roleSummary(role: RoleState): string;
+export declare const scopeMarker: (role: RoleState) => string;
+export declare function overviewTitle(role: RoleState): string;
+export declare const OVERVIEW_LEGEND = "G global \u00B7 P project \u00B7 project replaces global";
+export interface ActionRow {
+    action: string;
+    tools: string[];
+    locked: boolean;
+    effect: Effect;
+    /** `default` for untouched values, `entry` for exact entries, `pattern` for wildcard matches. */
+    source: 'default' | 'entry' | 'pattern';
+    via?: string;
+    /** Scope that supplies the shown effect after save. */
+    origin: 'default' | Scope;
+    /** Scope being edited. */
+    editScope: Scope;
+    /** True when a project entry shadows the edited global scope. */
+    inactive: boolean;
+    /** Effect the edited scope would give on its own while it is inactive. */
+    scopeEffect?: Effect;
+    /** True when the value differs from what state reports as saved. */
+    changed: boolean;
+}
+/** Preview the effective layer after save, over shipped effects, last-match-wins. */
+export declare function previewRows(state: ToolState, draft: ToolDraft): ActionRow[];
+export declare function rowTitle(row: ActionRow): string;
+export declare function rowDescription(row: ActionRow): string;
+export declare const ROLE_LEGEND = "\u25CF override \u00B7 \u25CB via pattern \u00B7 \u00B7 default \u00B7 \uD83D\uDD12 locked";
+export interface ManualEntry extends Override {
+    matchCount: number;
+}
+/** Number of inventory actions an entry matches. */
+export declare const countMatches: (state: ToolState, pattern: string) => number;
+/** Entries that are wildcards or name no registered action (e.g. disconnected MCP servers). */
+export declare function manualEntries(state: ToolState, draft: ToolDraft): ManualEntry[];
+export declare const entryDescription: (entry: ManualEntry) => string;
+export declare function validatePattern(raw: string): string | undefined;
+/** Case-insensitive search over title and description. */
+export declare function searchOptions<T extends {
+    title: string;
+    description?: string;
+    value: unknown;
+}>(query: string, options: readonly T[]): T[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thoth-agents",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Adaptive multi-harness orchestration with six roles, runtime-autonomous AI-first execution routes, and external provider boundaries.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -9,6 +9,10 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
+    "./tui": {
+      "types": "./dist/tui/index.d.ts",
+      "default": "./dist/tui/index.js"
+    },
     "./package.json": "./package.json",
     "./dist/*": "./dist/*",
     "./skills/*": "./skills/*",

package/plugin/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "thoth-agents",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Adaptive multi-harness agent pack with six roles and proportional SDD governance for Claude Code.",
   "author": {
     "name": "thoth-agents"

package/plugin/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "thoth-agents",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Bundled AI-first work skills and MCP configuration; the six-role global Codex layer requires thoth-agents CLI setup.",
   "skills": "./skills/",
   "mcpServers": "./codex.mcp.json",

package/thoth-agents.schema.json

@@ -5,9 +5,6 @@
     "$schema": {
       "type": "string"
     },
-    "preset": {
-      "type": "string"
-    },
     "setDefaultAgent": {
       "type": "boolean"
     },
@@ -164,73 +161,6 @@
       ],
       "additionalProperties": false
     },
-    "presets": {
-      "type": "object",
-      "propertyNames": {
-        "type": "string"
-      },
-      "additionalProperties": {
-        "type": "object",
-        "propertyNames": {
-          "type": "string",
-          "pattern": "^(?!quick$|deep$).+$"
-        },
-        "additionalProperties": {
-          "type": "object",
-          "properties": {
-            "model": {
-              "anyOf": [
-                {
-                  "type": "string"
-                },
-                {
-                  "type": "array",
-                  "items": {
-                    "anyOf": [
-                      {
-                        "type": "string"
-                      },
-                      {
-                        "type": "object",
-                        "properties": {
-                          "id": {
-                            "type": "string"
-                          },
-                          "variant": {
-                            "type": "string"
-                          }
-                        },
-                        "required": ["id"]
-                      }
-                    ]
-                  }
-                }
-              ]
-            },
-            "skills": {
-              "type": "array",
-              "items": {
-                "type": "string",
-                "minLength": 1
-              }
-            },
-            "temperature": {
-              "type": "number",
-              "minimum": 0,
-              "maximum": 2
-            },
-            "steps": {
-              "type": "integer",
-              "minimum": 1,
-              "maximum": 9007199254740991
-            },
-            "variant": {
-              "type": "string"
-            }
-          }
-        }
-      }
-    },
     "agents": {
       "type": "object",
       "propertyNames": {