@tt-a1i/openpi 0.1.1 → 0.3.0

package/extensions/shared/child-session.ts

@@ -1,11 +1,11 @@
 import * as path from "node:path";
 import {
+  type AgentSession,
   DefaultResourceLoader,
   getAgentDir,
   ProjectTrustStore,
-  SettingsManager,
-  type AgentSession,
   type SessionShutdownEvent,
+  SettingsManager,
 } from "@earendil-works/pi-coding-agent";
 
 export const CHILD_SHUTDOWN_TIMEOUT_MS = 5_000;
@@ -51,6 +51,8 @@ function isPiIntercomNpmResource(resource: {
  * drift test in child-session.test.ts).
  */
 export const CHILD_EXCLUDED_TOOL_NAMES = [
+  // capability discovery mutates the parent model-facing tool surface
+  "openpi_load_tools",
   // subagents — children cannot spawn/observe more agents
   "subagent_spawn",
   "subagent_wait",
@@ -185,7 +187,9 @@ export function resolveStandaloneChildProjectTrust(options: {
 
 interface ChildSessionStartup {
   bindExtensions(bindings: { mode: "print" }): Promise<void>;
-  getActiveToolNames(): string[];
+  getActiveToolNames?(): string[];
+  getAllTools?(): { name: string }[];
+  setActiveToolsByName?(toolNames: string[]): void;
 }
 
 function boundedToolNames(names: readonly string[]) {
@@ -208,9 +212,41 @@ export async function bindChildSessionExtensions(
 ) {
   await session.bindExtensions({ mode: "print" });
   const requested = effectiveChildToolAllowlist(requestedTools);
+  let active: Set<string> | undefined;
+  if (
+    session.getActiveToolNames &&
+    session.getAllTools &&
+    session.setActiveToolsByName
+  ) {
+    const requestedSet = requested ? new Set(requested) : undefined;
+    const available = new Set(session.getAllTools().map(({ name }) => name));
+    const activeNames = session.getActiveToolNames();
+    active = new Set(activeNames);
+    for (const name of CHILD_SAFE_PACKAGE_TOOL_NAMES) {
+      if (
+        available.has(name) &&
+        !active.has(name) &&
+        (requestedSet === undefined || requestedSet.has(name))
+      ) {
+        activeNames.push(name);
+        active.add(name);
+      }
+    }
+    if (activeNames.length !== session.getActiveToolNames().length) {
+      session.setActiveToolsByName(activeNames);
+    }
+  }
   if (!requested) return;
 
-  const active = new Set(session.getActiveToolNames());
+  if (!active && session.getActiveToolNames) {
+    active = new Set(session.getActiveToolNames());
+  }
+  if (!active) {
+    throw new Error(
+      "Child tool preflight failed: the bound child session does not expose active-tool introspection.",
+    );
+  }
+
   const missing = [...new Set(requested)].filter((name) => !active.has(name));
   if (missing.length === 0) return;
 

package/extensions/shared/editor-layers.ts

@@ -0,0 +1,150 @@
+import {
+  CustomEditor,
+  type ExtensionAPI,
+  type ExtensionContext,
+  type KeybindingsManager,
+} from "@earendil-works/pi-coding-agent";
+import type { EditorComponent, EditorTheme, TUI } from "@earendil-works/pi-tui";
+
+const CLAIM_CHANNEL = "openpi:editor-layers:claim";
+const REGISTER_CHANNEL = "openpi:editor-layers:register";
+const REMOVE_CHANNEL = "openpi:editor-layers:remove";
+
+type EditorFactory = NonNullable<
+  ReturnType<ExtensionContext["ui"]["getEditorComponent"]>
+>;
+
+export interface EditorLayer {
+  readonly id: string;
+  readonly order: number;
+  readonly wrap: (
+    base: EditorComponent,
+    tui: TUI,
+    theme: EditorTheme,
+    keybindings: KeybindingsManager,
+  ) => EditorComponent;
+}
+
+interface EditorLayerRegistration {
+  readonly ctx: ExtensionContext;
+  readonly layer: EditorLayer;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function readRegistration(value: unknown) {
+  if (!isRecord(value) || !isRecord(value.layer)) return undefined;
+  const { ctx, layer } = value;
+  if (
+    !isRecord(ctx) ||
+    typeof layer.id !== "string" ||
+    typeof layer.order !== "number" ||
+    typeof layer.wrap !== "function"
+  ) {
+    return undefined;
+  }
+  return {
+    ctx: ctx as unknown as ExtensionContext,
+    layer: layer as unknown as EditorLayer,
+  } satisfies EditorLayerRegistration;
+}
+
+function readLayerId(value: unknown) {
+  if (!isRecord(value) || typeof value.id !== "string") return undefined;
+  return value.id;
+}
+
+function composeEditorFactory(
+  previous: EditorFactory | undefined,
+  layers: readonly EditorLayer[],
+) {
+  return ((tui, theme, keybindings) => {
+    let editor =
+      previous?.(tui, theme, keybindings) ??
+      new CustomEditor(tui, theme, keybindings);
+    for (const layer of layers) {
+      editor = layer.wrap(editor, tui, theme, keybindings);
+    }
+    return editor;
+  }) satisfies EditorFactory;
+}
+
+/**
+ * Each extension is evaluated in its own jiti module graph, so ordinary module
+ * singletons are not shared. The first OpenPI editor contributor claims the
+ * runtime EventBus and coordinates the rest through that host-owned boundary.
+ */
+function ensureCoordinator(pi: ExtensionAPI) {
+  const claim = { claimed: false };
+  pi.events.emit(CLAIM_CHANNEL, claim);
+  if (claim.claimed) return;
+
+  let ctx: ExtensionContext | undefined;
+  let installTimer: ReturnType<typeof setTimeout> | undefined;
+  const layers = new Map<string, EditorLayer>();
+
+  const cancelInstall = () => {
+    if (installTimer) clearTimeout(installTimer);
+    installTimer = undefined;
+  };
+
+  const install = () => {
+    installTimer = undefined;
+    const current = ctx;
+    if (!current || current.mode !== "tui" || layers.size === 0) return;
+    const ordered = [...layers.values()].sort(
+      (left, right) =>
+        left.order - right.order || left.id.localeCompare(right.id),
+    );
+    current.ui.setEditorComponent(
+      composeEditorFactory(current.ui.getEditorComponent(), ordered),
+    );
+  };
+
+  const scheduleInstall = () => {
+    if (installTimer) return;
+    installTimer = setTimeout(install, 0);
+  };
+
+  pi.events.on(CLAIM_CHANNEL, (value) => {
+    if (isRecord(value) && value.claimed === false) value.claimed = true;
+  });
+  pi.events.on(REGISTER_CHANNEL, (value) => {
+    const registration = readRegistration(value);
+    if (!registration || registration.ctx.mode !== "tui") return;
+    if (ctx !== registration.ctx) {
+      cancelInstall();
+      layers.clear();
+      ctx = registration.ctx;
+    }
+    layers.set(registration.layer.id, registration.layer);
+    scheduleInstall();
+  });
+  pi.events.on(REMOVE_CHANNEL, (value) => {
+    const id = readLayerId(value);
+    if (!id) return;
+    layers.delete(id);
+    if (layers.size > 0) return;
+    cancelInstall();
+    ctx = undefined;
+  });
+}
+
+export function registerEditorLayer(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  layer: EditorLayer,
+) {
+  if (ctx.mode !== "tui") return;
+  ensureCoordinator(pi);
+  pi.events.emit(REGISTER_CHANNEL, {
+    ctx,
+    layer,
+  } satisfies EditorLayerRegistration);
+}
+
+export function removeEditorLayer(pi: ExtensionAPI, id: string) {
+  pi.events.emit(REMOVE_CHANNEL, { id });
+}

package/extensions/shared/setup-config.ts

@@ -63,23 +63,16 @@ export type FooterLines = readonly (readonly FooterLayoutItem[])[];
 export const DETAIL_DISPLAYS = ["full", "compact"] as const;
 export type DetailDisplay = (typeof DETAIL_DISPLAYS)[number];
 
-/** Canonical default layout: one-line Powerline dashboard with flex alignment. */
+export const CAPABILITY_DISCOVERY_MODES = ["explicit", "adaptive"] as const;
+export type CapabilityDiscoveryMode =
+  (typeof CAPABILITY_DISCOVERY_MODES)[number];
+
+/** Canonical default layout: one-line plain footer with flex alignment. */
 export const DEFAULT_FOOTER_LINES: FooterLines = [
-  [
-    "cwd",
-    "model",
-    "thinking",
-    "context",
-    "cache",
-    "cost",
-    "throughput",
-    "flex",
-    "git",
-    "pr",
-  ],
+  ["cwd", "git", "pr", "flex", "model", "context", "cost"],
 ];
 
-export const DEFAULT_FOOTER_STYLE: FooterStyle = "powerline";
+export const DEFAULT_FOOTER_STYLE: FooterStyle = "plain";
 
 export const DEFAULT_FOOTER_ITEMS: readonly FooterItem[] =
   flattenFooterItems(DEFAULT_FOOTER_LINES);
@@ -123,6 +116,9 @@ export const POST_EDIT_COMMAND_MAX_CHARS = 500;
 export const SETUP_CONFIG_CHANGED_CHANNEL = "my-pi-setup:config-changed";
 
 export interface MyPiSetupConfig {
+  readonly capabilities: {
+    readonly discovery: CapabilityDiscoveryMode;
+  };
   readonly suggestions: {
     readonly enabled: boolean;
     readonly model?: SuggestionModelConfig;
@@ -157,6 +153,7 @@ export interface MyPiSetupConfig {
 }
 
 export const DEFAULT_SETUP_CONFIG: MyPiSetupConfig = {
+  capabilities: { discovery: "explicit" },
   suggestions: { enabled: false },
   workflows: {
     concurrency: DEFAULT_WORKFLOW_CONCURRENCY,
@@ -205,6 +202,12 @@ const isFooterStyle = (value: unknown): value is FooterStyle =>
 const isFooterPreset = (value: unknown): value is FooterPreset =>
   typeof value === "string" && FOOTER_PRESETS.includes(value as FooterPreset);
 
+const isCapabilityDiscoveryMode = (
+  value: unknown,
+): value is CapabilityDiscoveryMode =>
+  typeof value === "string" &&
+  CAPABILITY_DISCOVERY_MODES.includes(value as CapabilityDiscoveryMode);
+
 export function flattenFooterItems(lines: FooterLines): readonly FooterItem[] {
   const items: FooterItem[] = [];
   const seen = new Set<FooterItem>();
@@ -401,6 +404,8 @@ function boundedInteger(value: unknown, fallback: number, maximum: number) {
 export function parseSetupConfig(value: unknown): MyPiSetupConfig {
   if (!isRecord(value)) return DEFAULT_SETUP_CONFIG;
 
+  const capabilities = isRecord(value.capabilities) ? value.capabilities : {};
+
   // `summaries` is the pre-suggestion config key. Read it once as a migration
   // source; every subsequent save writes only the canonical `suggestions` key.
   const suggestions = isRecord(value.suggestions)
@@ -430,6 +435,11 @@ export function parseSetupConfig(value: unknown): MyPiSetupConfig {
   const subagents = isRecord(value.subagents) ? value.subagents : {};
   const footer = parseUiFooter(ui);
   return {
+    capabilities: {
+      discovery: isCapabilityDiscoveryMode(capabilities.discovery)
+        ? capabilities.discovery
+        : "explicit",
+    },
     suggestions: {
       enabled: requestedEnabled && Boolean(model),
       ...(model ? { model } : {}),
@@ -942,10 +952,11 @@ export function formatSetupConfig(
     ? `on · ${config.ui.footerStyle} · ${formatFooterLines(config.ui.footerLines)}`
     : "off";
   return [
+    `Capability discovery: ${config.capabilities.discovery}`,
     suggestions,
     `Workflows: ${config.workflows.concurrency} concurrent agents · ${config.workflows.maxAgentCalls} total calls`,
     `UI: large header ${config.ui.showHeader ? "on" : "off"} · custom footer ${footer}`,
-    `Subagent results: ${config.ui.subagentResultDisplay === "full" ? "full by default" : "compact preview (expand for full output)"}`,
+    `Subagent results: ${config.ui.subagentResultDisplay === "full" ? "full by default" : "compact status summary (Ctrl+O expands full output)"}`,
     `Bash operations: ${config.ui.bashToolDisplay === "full" ? "expanded by default" : "folded preview (Ctrl+O expands all)"}`,
     `Write/Edit operations: ${config.ui.fileMutationDisplay === "full" ? "expanded by default" : "folded preview (Ctrl+O expands all)"}`,
     `Post-edit command: ${config.postEdit.command ? config.postEdit.command : "off"}`,

package/extensions/shared/setup-episode-state.ts

@@ -0,0 +1,7 @@
+/** Broadcast whenever the package-owned setup episode becomes usable or ends. */
+export const OPENPI_SETUP_EPISODE_CHANNEL = "openpi:setup-episode";
+
+export interface OpenPiSetupEpisodeState {
+  /** True for both armed and actively running setup episodes. */
+  readonly active: boolean;
+}