@ian-pascoe/pi-minimal-subagents 0.1.0 → 0.1.1

package/README.md

@@ -45,15 +45,15 @@ Project values override global values. Run `/reload` after editing either file.
 `minimalSubagents.modelRoles` gives the parent agent advisory names for
 eligible models. The extension defines no roles itself, performs no task
 classification, and does not route launches. The parent still passes the
-ordinary `model` argument and chooses `thinking_level` independently.
+ordinary `model` and `thinking_level` arguments separately.
 
 ```json
 {
   "minimalSubagents": {
     "modelRoles": {
-      "budget": "opencode-go/glm-5.2",
+      "budget": "opencode-go/glm-5.2:low",
       "design": {
-        "model": "opencode-go/kimi-k3",
+        "model": "opencode-go/kimi-k3:high",
         "hint": "UI design, visual critique, and frontend polish"
       }
     }
@@ -61,10 +61,18 @@ ordinary `model` argument and chooses `thinking_level` independently.
 }
 ```
 
+A recognized final suffix (`off`, `minimal`, `low`, `medium`, `high`, `xhigh`,
+or `max`) is a preferred `thinking_level`, not part of the canonical model
+passed to `subagent`. Unsuffixed roles leave thinking selection independent.
 Role names and hints are trimmed, single-line text. Names may be up to 64
 characters and hints up to 500 characters. Models use canonical
 `provider/model` IDs and must be available under the effective `enabledModels`
-scope. Thinking-level suffixes such as `:xhigh` are invalid here.
+scope. The resolver matches the complete authored model ID first, so real
+colon-bearing IDs—including IDs ending in `:high`—remain exact model IDs;
+only an otherwise-unmatched recognized final suffix is treated as a thinking
+preference. A thinking level pinned in `enabledModels` neither supplies nor
+constrains a role preference, and normal spawn-time model-capability clamping
+still applies.
 
 Global and project roles merge by name in settings order. Expanded role
 objects merge by field; a project string replaces the whole global entry. A
@@ -127,3 +135,10 @@ falls back to unlinking its session file. Each Child Agent has a persistent
 JSONL session. Append-only Root Agent Registry entries retain hierarchy and
 Delivery Evidence across reloads. Forking cancels and drains active work, then
 clones child session leaves so the fork receives an independent hierarchy.
+
+## Status and TUI
+
+Visible Child Agent rows show the canonical `provider/model:thinking` Runtime
+Profile. Status uses the live Runtime Profile while a runtime exists and falls
+back to the immutable Launch Contract otherwise. Live changes are observational:
+they do not rewrite persistence or change nested spawn defaults.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ian-pascoe/pi-minimal-subagents",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "private": false,
   "description": "Persistent nested subagents with bounded delegation for Pi",
   "keywords": [
@@ -29,10 +29,6 @@
     "access": "public",
     "provenance": true
   },
-  "scripts": {
-    "test": "vitest run --config ../../vitest.config.ts --root .",
-    "typecheck": "tsc --noEmit -p tsconfig.json"
-  },
   "peerDependencies": {
     "@earendil-works/pi-agent-core": "*",
     "@earendil-works/pi-ai": "*",
@@ -47,5 +43,9 @@
     "extensions": [
       "./src/index.ts"
     ]
+  },
+  "scripts": {
+    "test": "vitest run --config ../../vitest.config.ts --root .",
+    "typecheck": "tsc --noEmit -p tsconfig.json"
   }
-}
+}

package/src/minimal-subagents-capabilities.ts

@@ -16,8 +16,6 @@ export const COORDINATOR_TOOL_NAMES = [
 
 const READ_TOOL_BUNDLE = ["read", "grep", "find", "ls"];
 const MODIFY_TOOL_BUNDLE = [...READ_TOOL_BUNDLE, "bash", "edit", "write"];
-const THINKING_SUFFIX_PATTERN = /:(?:off|minimal|low|medium|high|xhigh|max)$/;
-
 interface ModelReference {
   provider: string;
   id: string;
@@ -28,11 +26,6 @@ interface ScopedModelReference {
   thinkingLevel?: string;
 }
 
-/** Remove a recognized Pi thinking suffix without changing model IDs containing other colons. */
-export function stripThinkingSuffix(modelPattern: string): string {
-  return modelPattern.replace(THINKING_SUFFIX_PATTERN, "");
-}
-
 /** Build the authenticated runtime model enum from Pi's already-resolved model scope. */
 export function buildEligibleModelIds(input: {
   availableModels: readonly ModelReference[];
@@ -47,7 +40,7 @@ export function buildEligibleModelIds(input: {
   const result: string[] = [];
 
   for (const model of source) {
-    const canonicalId = stripThinkingSuffix(`${model.provider}/${model.id}`);
+    const canonicalId = `${model.provider}/${model.id}`;
     if (!seen.has(canonicalId)) {
       seen.add(canonicalId);
       result.push(canonicalId);

package/src/minimal-subagents-config.ts

@@ -1,15 +1,15 @@
-import {
-  DEFAULT_MAX_SUBAGENT_DEPTH,
-  stripThinkingSuffix,
-} from "./minimal-subagents-capabilities.js";
+import { DEFAULT_MAX_SUBAGENT_DEPTH, THINKING_LEVELS } from "./minimal-subagents-capabilities.js";
 
 const MODEL_ROLE_NAME_MAX_LENGTH = 64;
 const MODEL_ROLE_HINT_MAX_LENGTH = 500;
 
+type ModelRoleThinkingLevel = (typeof THINKING_LEVELS)[number];
+
 /** Describes one user-authored advisory model role shown to subagent callers. */
 export interface MinimalSubagentsModelRole {
   name: string;
   model: string;
+  thinkingLevel?: ModelRoleThinkingLevel;
   hint?: string;
 }
 
@@ -89,6 +89,39 @@ function mergeModelRoleEntries(
   return entries;
 }
 
+interface ResolvedModelRoleReference {
+  model: string;
+  thinkingLevel?: ModelRoleThinkingLevel;
+}
+
+function resolveThinkingLevelSuffix(suffix: string): ModelRoleThinkingLevel | undefined {
+  return THINKING_LEVELS.find((thinkingLevel) => thinkingLevel === suffix);
+}
+
+function resolveModelRoleReference(
+  model: string,
+  eligibleModels: ReadonlySet<string>,
+  path: string,
+  warnings: string[],
+): ResolvedModelRoleReference | undefined {
+  if (eligibleModels.has(model)) return { model };
+
+  const separatorIndex = model.lastIndexOf(":");
+  if (separatorIndex >= 0) {
+    const prefix = model.slice(0, separatorIndex);
+    const suffix = model.slice(separatorIndex + 1);
+    if (eligibleModels.has(prefix)) {
+      const thinkingLevel = resolveThinkingLevelSuffix(suffix);
+      if (thinkingLevel !== undefined) return { model: prefix, thinkingLevel };
+      warnings.push(`${path}: unknown thinking level suffix: ${suffix}`);
+      return undefined;
+    }
+  }
+
+  warnings.push(`${path}: model is not eligible: ${model}`);
+  return undefined;
+}
+
 function parseModelRoles(
   entries: ReadonlyMap<string, ScopedSettingValue>,
   eligibleModelIds: readonly string[],
@@ -125,16 +158,8 @@ function parseModelRoles(
       warnings.push(`${path}: model must be a non-empty trimmed string`);
       continue;
     }
-    if (stripThinkingSuffix(model) !== model) {
-      warnings.push(
-        `${path}: thinking level suffixes are not allowed; choose thinking_level per spawn`,
-      );
-      continue;
-    }
-    if (!eligibleModels.has(model)) {
-      warnings.push(`${path}: model is not eligible: ${model}`);
-      continue;
-    }
+    const resolvedModel = resolveModelRoleReference(model, eligibleModels, path, warnings);
+    if (resolvedModel === undefined) continue;
 
     const hint = isRecord(value) ? value.hint : undefined;
     if (
@@ -148,7 +173,14 @@ function parseModelRoles(
       warnings.push(`${path}.hint: expected trimmed single-line text up to 500 characters`);
       continue;
     }
-    roles.push({ name, model, ...(hint === undefined ? {} : { hint }) });
+    roles.push({
+      name,
+      model: resolvedModel.model,
+      ...(resolvedModel.thinkingLevel === undefined
+        ? {}
+        : { thinkingLevel: resolvedModel.thinkingLevel }),
+      ...(hint === undefined ? {} : { hint }),
+    });
   }
   return roles;
 }

package/src/minimal-subagents-coordinator.ts

@@ -993,6 +993,10 @@ export class MinimalSubagentsCoordinator {
     const elapsed = agent.active_turn_started_at
       ? Math.max(0, this.now().getTime() - new Date(agent.active_turn_started_at).getTime())
       : undefined;
+    const runtimeProfile = this.runtimes.get(agent.agent_id)?.getRuntimeProfile() ?? {
+      model: agent.launch_contract.model,
+      thinking_level: agent.launch_contract.thinking_level,
+    };
     return {
       agent_id: agent.agent_id,
       parent_id: agent.parent_id,
@@ -1002,8 +1006,7 @@ export class MinimalSubagentsCoordinator {
       latest_turn: agent.latest_result
         ? { turn_id: agent.latest_result.turn_id, status: agent.latest_result.status }
         : undefined,
-      model: agent.launch_contract.model,
-      thinking_level: agent.launch_contract.thinking_level,
+      ...runtimeProfile,
       tools: [...agent.launch_contract.ordinary_tools],
       elapsed_ms: elapsed ?? agent.latest_result?.elapsed_ms,
       latest_activity_at: agent.latest_activity_at ?? agent.created_at,

package/src/minimal-subagents-sessions.ts

@@ -37,6 +37,7 @@ import type {
   PersistedSessionIdentity,
   ProjectContextMode,
   RuntimeCreationRequest,
+  RuntimeProfile,
   RuntimeTurnOutcome,
 } from "./minimal-subagents-types.js";
 
@@ -329,6 +330,15 @@ class PiChildAgentRuntime implements ChildAgentRuntime {
     this.session.dispose();
   }
 
+  getRuntimeProfile(): RuntimeProfile | undefined {
+    const model = this.session.model;
+    if (!model) return undefined;
+    return {
+      model: `${model.provider}/${model.id}`,
+      thinking_level: this.session.thinkingLevel,
+    };
+  }
+
   snapshotCommittedMessages(): AgentMessage[] {
     return snapshotCommittedContext(this.session.messages, this.session.isStreaming);
   }

package/src/minimal-subagents-tools.ts

@@ -40,12 +40,13 @@ function buildModelRolePromptGuidelines(
   modelRoles: readonly MinimalSubagentsModelRole[],
 ): string[] | undefined {
   if (modelRoles.length === 0) return undefined;
-  const roleLines = modelRoles.map(
-    (role) => `  - ${role.name} → ${role.model}${role.hint ? ` — ${role.hint}` : ""}`,
-  );
+  const roleLines = modelRoles.map((role) => {
+    const thinkingGuidance = role.thinkingLevel ? `, thinking_level=${role.thinkingLevel}` : "";
+    return `  - ${role.name} → model=${role.model}${thinkingGuidance}${role.hint ? ` — ${role.hint}` : ""}`;
+  });
   return [
     ["Configured model roles are guidance, not constraints:", ...roleLines].join("\n"),
-    "Choose a model based on the task. Choose thinking_level independently.",
+    "Choose a model based on the task. A listed thinking_level is a preference, not a constraint. Callers choose thinking_level independently for roles without one.",
   ];
 }
 

package/src/minimal-subagents-types.ts

@@ -22,6 +22,12 @@ export type AgentAvailability = "available" | "unavailable";
 /** Classifies active and terminal persistent subagent turn outcomes. */
 export type TurnStatus = "running" | "completed" | "failed" | "cancelled" | "interrupted";
 
+/** Describes the canonical model and resolved thinking level currently used by a Child Agent. */
+export interface RuntimeProfile {
+  model: string;
+  thinking_level: ThinkingLevel;
+}
+
 /** Defines the validated launch contract accepted by the subagent tool. */
 export interface SpawnParameters {
   task: string;
@@ -59,16 +65,14 @@ export interface AgentMessageResult {
   error?: string;
 }
 
-/** Provides bounded hierarchy and usage data for one persistent agent. */
-export interface AgentSummary {
+/** Provides bounded hierarchy, usage, and best-known Runtime Profile data for one persistent agent. */
+export interface AgentSummary extends RuntimeProfile {
   agent_id: string;
   parent_id: string;
   state: AgentState;
   availability: AgentAvailability;
   active_turn_id?: string;
   latest_turn?: Pick<TurnResult, "turn_id" | "status">;
-  model: string;
-  thinking_level: ThinkingLevel;
   tools: string[];
   elapsed_ms?: number;
   latest_activity?: string;
@@ -125,11 +129,9 @@ export interface DeleteResult {
 }
 
 /** Persists immutable context, model, thinking, and ordinary-tool launch choices. */
-export interface LaunchContract {
+export interface LaunchContract extends RuntimeProfile {
   session_context: SessionContextMode;
   project_context: ProjectContextMode;
-  model: string;
-  thinking_level: ThinkingLevel;
   tools: ToolSelection | undefined;
   ordinary_tools: string[];
   delegation?: DelegationMode;
@@ -184,6 +186,8 @@ export interface ChildAgentRuntime {
   steerCoordinatorMessage(message: CoordinatorMessage): Promise<void>;
   abort(): Promise<void>;
   dispose(): void;
+  /** Return the live Runtime Profile, or undefined when the SDK session has no model. */
+  getRuntimeProfile(): RuntimeProfile | undefined;
   snapshotCommittedMessages(): AgentMessage[];
   hasDeliveryEvidence(sourceAgentId: string, sourceTurnId: string): boolean;
   getUsage(): Usage | undefined;

package/src/minimal-subagents-ui.ts

@@ -1,13 +1,24 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
 import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { truncateToWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import {
+  sliceByColumn,
+  truncateToWidth,
+  visibleWidth,
+  type Component,
+  type TUI,
+} from "@earendil-works/pi-tui";
 import type { MinimalSubagentsCoordinator } from "./minimal-subagents-coordinator.js";
 import {
   formatSubagentDuration,
   renderSubagentStatusLabel,
   renderSubagentStatusSymbol,
 } from "./minimal-subagents-rendering.js";
-import type { AgentSummary, HierarchyStatusResult, TurnStatus } from "./minimal-subagents-types.js";
+import type {
+  AgentSummary,
+  HierarchyStatusResult,
+  RuntimeProfile,
+  TurnStatus,
+} from "./minimal-subagents-types.js";
 
 const MINIMAL_SUBAGENTS_UI_KEY = "minimal-subagents";
 const MINIMAL_SUBAGENTS_RECENT_LIMIT = 3;
@@ -20,6 +31,7 @@ export interface MinimalSubagentsWidgetRow {
   depth: number;
   status: TurnStatus | "idle" | "unavailable";
   elapsedMs?: number;
+  runtimeProfile: RuntimeProfile;
   task?: string;
   structural: boolean;
 }
@@ -122,6 +134,10 @@ export function buildMinimalSubagentsWidgetView(
         depth: item.depth,
         status: agentTerminalStatus(item.agent),
         elapsedMs: item.agent.elapsed_ms,
+        runtimeProfile: {
+          model: item.agent.model,
+          thinking_level: item.agent.thinking_level,
+        },
         task: structural ? undefined : item.agent.task,
         structural,
       };
@@ -135,6 +151,187 @@ export function buildMinimalSubagentsWidgetView(
   };
 }
 
+const MINIMAL_SUBAGENTS_WIDGET_SEPARATOR_TEXT = "  ·  ";
+const MINIMAL_SUBAGENTS_WIDGET_ELLIPSIS = "…";
+
+interface MinimalSubagentsWidgetRowParts {
+  identity: string;
+  status: string;
+  profile: string;
+  task?: string;
+}
+
+function joinMinimalSubagentsWidgetRow(
+  parts: MinimalSubagentsWidgetRowParts,
+  separator: string,
+): string {
+  return [parts.identity, parts.status, parts.profile, parts.task]
+    .filter((part): part is string => part !== undefined)
+    .join(separator);
+}
+
+function formatMinimalSubagentsRuntimeProfile(
+  profile: RuntimeProfile,
+  maxWidth?: number,
+): string | undefined {
+  const suffix = `:${profile.thinking_level}`;
+  const fullProfile = `${profile.model}${suffix}`;
+  if (maxWidth === undefined || visibleWidth(fullProfile) <= maxWidth) return fullProfile;
+
+  const shortestProfile = `${MINIMAL_SUBAGENTS_WIDGET_ELLIPSIS}${suffix}`;
+  if (maxWidth < visibleWidth(shortestProfile)) return undefined;
+  const modelWidth = maxWidth - visibleWidth(suffix);
+  const prefix = sliceByColumn(
+    profile.model,
+    0,
+    Math.max(0, modelWidth - visibleWidth(MINIMAL_SUBAGENTS_WIDGET_ELLIPSIS)),
+    true,
+  );
+  return `${prefix}${MINIMAL_SUBAGENTS_WIDGET_ELLIPSIS}${suffix}`;
+}
+
+function renderMinimalSubagentsWidgetRowParts(
+  row: MinimalSubagentsWidgetRow,
+  task: string | undefined,
+  duration: string | undefined,
+  profile: string,
+  theme: Theme,
+): MinimalSubagentsWidgetRowParts {
+  const branch = row.depth > 0 ? `${"  ".repeat(row.depth)}╰─ ` : "  ";
+  const styledBranch = theme.fg("borderMuted", branch);
+  const agentId = row.structural ? theme.fg("muted", row.agentId) : theme.bold(row.agentId);
+  const identity = `${styledBranch}${renderSubagentStatusSymbol(theme, row.status)} ${agentId}`;
+  const status = `${renderSubagentStatusLabel(theme, row.status)}${
+    duration ? ` ${theme.fg("muted", duration)}` : ""
+  }`;
+  return {
+    identity,
+    status,
+    profile: theme.fg("muted", profile),
+    task: task ? theme.fg("muted", task) : undefined,
+  };
+}
+
+function minimalSubagentsWidgetRowFits(
+  parts: MinimalSubagentsWidgetRowParts,
+  separator: string,
+  width: number,
+): boolean {
+  return visibleWidth(joinMinimalSubagentsWidgetRow(parts, separator)) <= width;
+}
+
+function minimalSubagentsWidgetProfileBudget(
+  row: MinimalSubagentsWidgetRow,
+  task: string | undefined,
+  duration: string | undefined,
+  separator: string,
+  theme: Theme,
+  width: number,
+): number {
+  const fixedParts = renderMinimalSubagentsWidgetRowParts(row, task, duration, "", theme);
+  return width - visibleWidth(joinMinimalSubagentsWidgetRow(fixedParts, separator));
+}
+
+function renderMinimalSubagentsWidgetRow(
+  row: MinimalSubagentsWidgetRow,
+  width: number,
+  theme: Theme,
+): string {
+  const separator = theme.fg("dim", MINIMAL_SUBAGENTS_WIDGET_SEPARATOR_TEXT);
+  const task = row.task?.replace(/\s+/g, " ").trim() || undefined;
+  const duration = row.status === "unavailable" ? undefined : formatSubagentDuration(row.elapsedMs);
+  const fullProfile = formatMinimalSubagentsRuntimeProfile(row.runtimeProfile);
+  if (!fullProfile) return "";
+
+  const completeParts = renderMinimalSubagentsWidgetRowParts(
+    row,
+    task,
+    duration,
+    fullProfile,
+    theme,
+  );
+  if (minimalSubagentsWidgetRowFits(completeParts, separator, width)) {
+    return joinMinimalSubagentsWidgetRow(completeParts, separator);
+  }
+
+  const partsWithoutTask = renderMinimalSubagentsWidgetRowParts(
+    row,
+    undefined,
+    duration,
+    fullProfile,
+    theme,
+  );
+  if (minimalSubagentsWidgetRowFits(partsWithoutTask, separator, width)) {
+    return joinMinimalSubagentsWidgetRow(partsWithoutTask, separator);
+  }
+
+  const profileBudget = minimalSubagentsWidgetProfileBudget(
+    row,
+    undefined,
+    duration,
+    separator,
+    theme,
+    width,
+  );
+  const shortenedProfile = formatMinimalSubagentsRuntimeProfile(row.runtimeProfile, profileBudget);
+  if (shortenedProfile) {
+    const shortenedParts = renderMinimalSubagentsWidgetRowParts(
+      row,
+      undefined,
+      duration,
+      shortenedProfile,
+      theme,
+    );
+    if (minimalSubagentsWidgetRowFits(shortenedParts, separator, width)) {
+      return joinMinimalSubagentsWidgetRow(shortenedParts, separator);
+    }
+  }
+
+  if (duration) {
+    const noDurationBudget = minimalSubagentsWidgetProfileBudget(
+      row,
+      undefined,
+      undefined,
+      separator,
+      theme,
+      width,
+    );
+    const noDurationProfile = formatMinimalSubagentsRuntimeProfile(
+      row.runtimeProfile,
+      noDurationBudget,
+    );
+    if (noDurationProfile) {
+      const noDurationParts = renderMinimalSubagentsWidgetRowParts(
+        row,
+        undefined,
+        undefined,
+        noDurationProfile,
+        theme,
+      );
+      if (minimalSubagentsWidgetRowFits(noDurationParts, separator, width)) {
+        return joinMinimalSubagentsWidgetRow(noDurationParts, separator);
+      }
+    }
+  }
+
+  const shortestProfile = formatMinimalSubagentsRuntimeProfile(
+    row.runtimeProfile,
+    visibleWidth(`${MINIMAL_SUBAGENTS_WIDGET_ELLIPSIS}:${row.runtimeProfile.thinking_level}`),
+  )!;
+  const lastResortParts = renderMinimalSubagentsWidgetRowParts(
+    row,
+    undefined,
+    undefined,
+    shortestProfile,
+    theme,
+  );
+  return truncateToWidth(
+    joinMinimalSubagentsWidgetRow(lastResortParts, separator),
+    width,
+    MINIMAL_SUBAGENTS_WIDGET_ELLIPSIS,
+  );
+}
+
 /** Render a responsive widget snapshot with ANSI-safe terminal-width truncation. */
 export function renderMinimalSubagentsWidgetLines(
   view: MinimalSubagentsWidgetView,
@@ -142,7 +339,7 @@ export function renderMinimalSubagentsWidgetLines(
   theme: Theme,
 ): string[] {
   if (width <= 0) return [];
-  const separator = theme.fg("dim", "  ·  ");
+  const separator = theme.fg("dim", MINIMAL_SUBAGENTS_WIDGET_SEPARATOR_TEXT);
   const activity =
     view.runningCount > 0
       ? theme.fg("accent", `${view.runningCount} running`)
@@ -159,27 +356,18 @@ export function renderMinimalSubagentsWidgetLines(
         .filter((part): part is string => Boolean(part))
         .join(separator),
       width,
-      "…",
+      MINIMAL_SUBAGENTS_WIDGET_ELLIPSIS,
     ),
   ];
-  for (const row of view.rows) {
-    const duration = formatSubagentDuration(row.elapsedMs);
-    const task = row.task?.replace(/\s+/g, " ").trim();
-    const branch =
-      row.depth > 0
-        ? theme.fg("borderMuted", `${"  ".repeat(row.depth)}╰─ `)
-        : theme.fg("borderMuted", "  ");
-    const agentId = row.structural ? theme.fg("muted", row.agentId) : theme.bold(row.agentId);
-    const parts = [
-      `${branch}${renderSubagentStatusSymbol(theme, row.status)} ${agentId}`,
-      row.structural ? undefined : renderSubagentStatusLabel(theme, row.status),
-      task ? theme.fg("muted", task) : undefined,
-      duration ? theme.fg("muted", duration) : undefined,
-    ].filter((part): part is string => Boolean(part));
-    lines.push(truncateToWidth(parts.join(separator), width, "…"));
-  }
+  for (const row of view.rows) lines.push(renderMinimalSubagentsWidgetRow(row, width, theme));
   if (view.overflowCount > 0) {
-    lines.push(truncateToWidth(theme.fg("dim", `  …  +${view.overflowCount} more`), width, "…"));
+    lines.push(
+      truncateToWidth(
+        theme.fg("dim", `  …  +${view.overflowCount} more`),
+        width,
+        MINIMAL_SUBAGENTS_WIDGET_ELLIPSIS,
+      ),
+    );
   }
   return lines;
 }