@ian-pascoe/pi-minimal-subagents 0.6.4 → 0.6.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ian-pascoe/pi-minimal-subagents",
-  "version": "0.6.4",
+  "version": "0.6.6",
   "private": false,
   "description": "Persistent nested subagents with bounded delegation for Pi",
   "keywords": [

package/src/minimal-subagents-config.ts

@@ -1,4 +1,3 @@
-import type { JsonValue } from "@earendil-works/pi-ai";
 import type { SettingsManager } from "@earendil-works/pi-coding-agent";
 import { type Static, Type } from "typebox";
 import { Value } from "typebox/value";
@@ -7,16 +6,18 @@ import { DEFAULT_MAX_SUBAGENT_DEPTH, THINKING_LEVELS } from "./minimal-subagents
 const MODEL_ROLE_NAME_MAX_LENGTH = 64;
 const MODEL_ROLE_HINT_MAX_LENGTH = 500;
 
-const JsonValueSchema = Type.Unsafe<JsonValue>({});
 const SettingsDocumentSchema = Type.Object({
-  minimalSubagents: Type.Optional(JsonValueSchema),
+  minimalSubagents: Type.Optional(Type.Unknown()),
 });
 const MinimalSubagentsSettingsSchema = Type.Object({
-  enabled: Type.Optional(JsonValueSchema),
-  maxSubagentDepth: Type.Optional(JsonValueSchema),
-  modelRoles: Type.Optional(JsonValueSchema),
+  enabled: Type.Optional(Type.Unknown()),
+  maxSubagentDepth: Type.Optional(Type.Unknown()),
+  modelRoles: Type.Optional(Type.Unknown()),
+});
+const ModelRoleObjectSchema = Type.Object({
+  model: Type.Optional(Type.Unknown()),
+  hint: Type.Optional(Type.Unknown()),
 });
-const JsonObjectSchema = Type.Record(Type.String(), JsonValueSchema);
 const EnabledSettingSchema = Type.Boolean();
 const PositiveSafeIntegerSchema = Type.Integer({ minimum: 1, maximum: Number.MAX_SAFE_INTEGER });
 const MaxSubagentDepthSettingSchema = Type.Union([PositiveSafeIntegerSchema, Type.Null()]);
@@ -28,7 +29,7 @@ const ExpandedModelRoleSchema = Type.Object(
   },
   { additionalProperties: false },
 );
-const ModelRoleEntriesSchema = Type.Record(Type.String(), JsonValueSchema);
+const ModelRoleEntriesSchema = Type.Record(Type.String(), Type.Unknown());
 const ModelRolesSettingSchema = Type.Union([ModelRoleEntriesSchema, Type.Null()]);
 
 type ModelRoleThinkingLevel = (typeof THINKING_LEVELS)[number];
@@ -61,7 +62,7 @@ export interface ResolvedMinimalSubagentsConfig {
 }
 
 interface MinimalSubagentsSettingsDocument {
-  minimalSubagents?: JsonValue;
+  minimalSubagents?: unknown;
 }
 
 interface MinimalSubagentsConfigInput {
@@ -102,7 +103,7 @@ type ModelRoleWireValue =
   | { kind: "delete" }
   | { kind: "shorthand"; model: string }
   | { kind: "expanded"; fields: Static<typeof ExpandedModelRoleSchema> }
-  | { kind: "malformed-expanded"; fields: Record<string, JsonValue> }
+  | { kind: "malformed-expanded"; fields: Static<typeof ModelRoleObjectSchema> }
   | { kind: "invalid" };
 
 type ModelRolesWireValue =
@@ -110,15 +111,17 @@ type ModelRolesWireValue =
   | { kind: "entries"; entries: ReadonlyMap<string, ModelRoleWireValue> }
   | { kind: "invalid" };
 
-function parseMaxSubagentDepthWireValue(value: JsonValue): MaxSubagentDepthWireValue {
+// oxlint-disable-next-line anti-slop/no-unknown-parameters -- Authored settings remain unparsed until the depth schema below validates their value.
+function parseMaxSubagentDepthWireValue(value: unknown): MaxSubagentDepthWireValue {
   if (!Value.Check(MaxSubagentDepthSettingSchema, value)) return { kind: "invalid" };
   return value === null ? { kind: "reset" } : { kind: "depth", value };
 }
 
-function parseModelRoleWireValue(value: JsonValue): ModelRoleWireValue {
+// oxlint-disable-next-line anti-slop/no-unknown-parameters -- Role entries may contain arbitrary settings data; schemas classify them before model/hint validation.
+function parseModelRoleWireValue(value: unknown): ModelRoleWireValue {
   if (value === null) return { kind: "delete" };
   if (Value.Check(ShorthandModelRoleSchema, value)) return { kind: "shorthand", model: value };
-  if (Value.Check(JsonObjectSchema, value)) {
+  if (Value.Check(ModelRoleObjectSchema, value)) {
     return Value.Check(ExpandedModelRoleSchema, value)
       ? { kind: "expanded", fields: value }
       : { kind: "malformed-expanded", fields: value };
@@ -132,7 +135,8 @@ function isExpandedModelRoleWireValue(
   return value.kind === "expanded" || value.kind === "malformed-expanded";
 }
 
-function parseModelRolesWireValue(value: JsonValue): ModelRolesWireValue {
+// oxlint-disable-next-line anti-slop/no-unknown-parameters -- Validate the authored role collection before parsing each untrusted entry.
+function parseModelRolesWireValue(value: unknown): ModelRolesWireValue {
   if (!Value.Check(ModelRolesSettingSchema, value)) return { kind: "invalid" };
   if (value === null) return { kind: "reset" };
   return {

package/src/minimal-subagents-extension.ts

@@ -65,7 +65,10 @@ import {
   MinimalSubagentsStatusPanelController,
   type MinimalSubagentsStatusAccess,
 } from "./minimal-subagents-status-panel.js";
-import { createCoordinatorToolDefinitions } from "./minimal-subagents-tools.js";
+import {
+  createCoordinatorToolDefinitions,
+  type CoordinatorToolOperations,
+} from "./minimal-subagents-tools.js";
 import {
   renderMinimalSubagentsMessage,
   renderMinimalSubagentsResult,
@@ -393,6 +396,15 @@ const productionLifecycleEffects: MinimalSubagentsLifecycleEffects = {
 /** Own coordinator, UI, and prepared-fork state for one root Pi session lifecycle. */
 export class MinimalSubagentsLifecycleController {
   private coordinator: MinimalSubagentsCoordinator | undefined;
+  private readonly coordinatorOperations: CoordinatorToolOperations = {
+    spawn: (...args) => this.requireCoordinator().spawn(...args),
+    inspectStatus: (...args) => this.requireCoordinator().inspectStatus(...args),
+    sendAgentMessage: (...args) => this.requireCoordinator().sendAgentMessage(...args),
+    wait: (...args) => this.requireCoordinator().wait(...args),
+    status: (...args) => this.requireCoordinator().status(...args),
+    cancel: (...args) => this.requireCoordinator().cancel(...args),
+    delete: (...args) => this.requireCoordinator().delete(...args),
+  };
   private uiController: MinimalSubagentsUiController | undefined;
   private statusPanelController: MinimalSubagentsStatusPanelController | undefined;
   private accessSession: ActiveSubagentAccessSession | undefined;
@@ -406,8 +418,18 @@ export class MinimalSubagentsLifecycleController {
     private readonly effects: MinimalSubagentsLifecycleEffects,
   ) {}
 
-  /** Register renderers and the six Pi lifecycle event handlers owned by Minimal Subagents. */
+  /** Register stable tools, renderers, and the six Pi lifecycle event handlers. */
   register(): void {
+    const rootTools = createCoordinatorToolDefinitions({
+      coordinator: this.coordinatorOperations,
+      callerId: "root",
+      allowFanoutTools: true,
+      schemas: createCoordinatorToolSchemas([]),
+      captureCaller: (context) => rootCallerSnapshot(this.pi, context),
+      onActivity: () => this.uiController?.refresh(),
+      onAttention: (message) => this.accessSession?.context.ui.notify(message, "error"),
+    });
+    for (const tool of rootTools) this.pi.registerTool(tool);
     this.pi.registerMessageRenderer("minimal-subagents.message", renderMinimalSubagentsMessage);
     this.pi.registerMessageRenderer("minimal-subagents.result", renderMinimalSubagentsResult);
     this.pi.registerCommand("subagents", {
@@ -573,7 +595,7 @@ export class MinimalSubagentsLifecycleController {
     this.uiController.refresh();
 
     const rootTools = createCoordinatorToolDefinitions({
-      coordinator: activeCoordinator,
+      coordinator: this.coordinatorOperations,
       callerId: "root",
       allowFanoutTools: true,
       modelRoles: minimalSubagentsConfig.modelRoles,
@@ -605,6 +627,13 @@ export class MinimalSubagentsLifecycleController {
     }
   }
 
+  private requireCoordinator(): MinimalSubagentsCoordinator {
+    if (!this.coordinator) {
+      throw new Error("Minimal subagents lifecycle: coordinator is not initialized");
+    }
+    return this.coordinator;
+  }
+
   private async prepareSessionFork(
     event: SessionBeforeForkEvent,
     context: ExtensionContext,

package/src/minimal-subagents-fork-lifecycle.ts

@@ -2,7 +2,7 @@ import type { ForkSnapshot } from "./minimal-subagents-types.js";
 import { canonicalPath } from "./minimal-subagents-paths.js";
 
 declare global {
-  // eslint-disable-next-line no-var -- A process-global handoff must be visible to replacement extension instances.
+  // A process-global handoff must be visible to replacement extension instances.
   var minimalSubagentsForkSnapshots: Map<string, ForkSnapshot> | undefined;
 }
 

package/src/minimal-subagents-registry-wire.ts

@@ -1,9 +1,5 @@
-import type { JsonValue } from "@earendil-works/pi-ai";
 import { Type, type Static } from "typebox";
 
-/** Establishes Pi's recursive JSON owner type before Registry envelope parsing. */
-export const RegistryJsonValueWireSchema = Type.Unsafe<JsonValue>({});
-
 const NonnegativeNumberSchema = Type.Number({ minimum: 0 });
 const NonEmptyStringSchema = Type.String({ minLength: 1 });
 const TurnStatusSchema = Type.Union([

package/src/minimal-subagents-registry.ts

@@ -28,7 +28,6 @@ import {
   RegistryDeliveryTurnEventWireSchema,
   RegistryEnvelopeWireSchema,
   RegistryEventDiscriminantWireSchema,
-  RegistryJsonValueWireSchema,
   RegistryLooseEnvelopeWireSchema,
   RegistryMessageRecordedEventWireSchema,
   RegistryRootProbeWireSchema,
@@ -846,7 +845,8 @@ function validParsedEvent(event: RegistryEventV2): ParsedRegistryEvent {
 type RegistryParseInput = JsonValue | RegistryEventV2;
 
 function parseRegistryEventRecord(
-  value: RegistryParseInput,
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Registry entry data is unparsed; ownership is checked first, then envelope and event schemas validate every consumed field.
+  value: unknown,
   rootSessionId: string,
 ): ParsedRegistryEvent {
   if (Value.Check(RegistryRootProbeWireSchema, value) && value.root_session_id !== rootSessionId) {
@@ -1191,10 +1191,6 @@ export function replayRegistryEntries(
   const diagnostics: RegistryReplayDiagnostic[] = [];
   entries.forEach((entry, entryIndex) => {
     if (entry.type !== "custom" || entry.customType !== REGISTRY_ENTRY_TYPE) return;
-    if (!Value.Check(RegistryJsonValueWireSchema, entry.data)) {
-      reportDiagnostic(diagnostics, entryIndex, "invalid-envelope", "record must be JSON");
-      return;
-    }
     const parsed = parseRegistryEventRecord(entry.data, rootSessionId);
     if (parsed.kind === "foreign-root") return;
     if (parsed.kind === "event") {

package/src/minimal-subagents-render-contract.ts

@@ -1,8 +1,4 @@
-import type {
-  AgentToolResult,
-  MessageRenderer,
-  ToolDefinition,
-} from "@earendil-works/pi-coding-agent";
+import type { ToolDefinition } from "@earendil-works/pi-coding-agent";
 import { Type, type Static } from "typebox";
 import { Value } from "typebox/value";
 import { COORDINATOR_TOOL_NAMES } from "./minimal-subagents-capabilities.js";
@@ -339,8 +335,6 @@ export type RenderStatusAgent = Static<typeof RenderStatusAgentSchema>;
 /** Raw tool arguments supplied by Pi's tool-rendering interface. */
 export type CoordinatorToolCallInput = Parameters<NonNullable<ToolDefinition["renderCall"]>>[0];
 
-type CoordinatorMessageInput = Parameters<MessageRenderer>[0];
-
 /** Parsed tool-call arguments tagged by their coordinator tool name. */
 export type ParsedCoordinatorToolCall =
   | { toolName: "subagent"; args: SpawnCallArguments }
@@ -383,7 +377,8 @@ export function parseCoordinatorToolCall(
 /** Parse one historical tool result exactly once at the transcript rendering boundary. */
 export function parseCoordinatorToolResult(
   toolName: CoordinatorToolName,
-  details: AgentToolResult<unknown>["details"],
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Historical tool details are unparsed until the selected per-tool schema checks them below.
+  details: unknown,
 ): ParsedCoordinatorToolResult | undefined {
   switch (toolName) {
     case "subagent":
@@ -417,7 +412,8 @@ export type CoordinatorMessageRenderDetails = Static<typeof CoordinatorMessageRe
 
 /** Parse optional custom-message details while tolerating legacy field names. */
 export function parseCoordinatorMessageDetails(
-  details: CoordinatorMessageInput["details"],
+  // oxlint-disable-next-line anti-slop/no-unknown-parameters -- Historical custom-message metadata is validated by its owning schema below.
+  details: unknown,
 ): CoordinatorMessageRenderDetails | undefined {
   return Value.Check(CoordinatorMessageRenderDetailsSchema, details) ? details : undefined;
 }

package/src/minimal-subagents-settings-writer.ts

@@ -4,8 +4,6 @@ import { randomUUID } from "node:crypto";
 import { mkdir, open, readFile, rename, rm, stat } from "node:fs/promises";
 import { basename, dirname, join, resolve } from "node:path";
 import lockfile from "proper-lockfile";
-import { Type } from "typebox";
-import { Value } from "typebox/value";
 
 /** Identifies the standard Pi settings file changed by a Subagent Access command. */
 export type MinimalSubagentsSettingsScope = "global" | "project";
@@ -64,8 +62,10 @@ interface ExistingSettingsDocument {
   readonly mode: number;
 }
 
-const JsonValueSchema = Type.Unsafe<JsonValue>({});
-const SettingsJsonObjectSchema = Type.Record(Type.String(), JsonValueSchema);
+function isSettingsJsonObject(value: JsonValue | undefined): value is SettingsJsonObject {
+  // oxlint-disable-next-line anti-slop/no-runtime-typeof -- JSON.parse already established JSON data; distinguish object roots and settings blocks from primitives and arrays.
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
 const SETTINGS_LOCK_RETRY_DELAY_MS = 20;
 const SETTINGS_LOCK_RETRIES = 100;
 const NEW_SETTINGS_FILE_MODE = 0o600;
@@ -92,7 +92,8 @@ function parseSettingsDocument(
   scope: MinimalSubagentsSettingsScope,
   path: string,
 ): ParsedSettingsDocument {
-  let parsed: unknown;
+  // JSON.parse is the provenance for this JSON type; the object shape is checked below.
+  let parsed: JsonValue;
   try {
     parsed = JSON.parse(stripUtf8Bom(content));
   } catch (cause) {
@@ -109,11 +110,11 @@ function parseSettingsDocument(
     };
   }
 
-  if (!Value.Check(SettingsJsonObjectSchema, parsed)) {
+  if (!isSettingsJsonObject(parsed)) {
     return { ok: false, error: settingsContractError(scope, path, "expected an object root") };
   }
   const minimalSubagents = parsed.minimalSubagents;
-  if (minimalSubagents !== undefined && !Value.Check(SettingsJsonObjectSchema, minimalSubagents)) {
+  if (minimalSubagents !== undefined && !isSettingsJsonObject(minimalSubagents)) {
     return {
       ok: false,
       error: settingsContractError(
@@ -131,7 +132,7 @@ function mutateMinimalSubagentsEnabled(
   enabled: boolean | undefined,
 ): void {
   const currentMinimalSubagents = settings.minimalSubagents;
-  const minimalSubagents = Value.Check(SettingsJsonObjectSchema, currentMinimalSubagents)
+  const minimalSubagents = isSettingsJsonObject(currentMinimalSubagents)
     ? currentMinimalSubagents
     : {};