@tt-a1i/openpi 0.1.1 → 0.2.0

package/extensions/shared/tool-surface.ts

@@ -0,0 +1,435 @@
+import { fileURLToPath } from "node:url";
+
+/**
+ * OpenPI-owned model tools, grouped by the extension that owns their runtime
+ * state. Ordinary parent sessions add no resident OpenPI tool. Explicit user
+ * intent can reveal the capability gateway or load one capability group;
+ * capability-owned tools remain registered but are projected only after their
+ * group is loaded. Lifecycle tools add a second resource/mode-state gate inside
+ * that loaded group.
+ */
+export const OPENPI_TOOL_SURFACE = {
+  capabilities: {
+    entry: ["openpi_load_tools"],
+    deferred: [],
+  },
+  fileSearch: {
+    entry: ["fd", "rg"],
+    deferred: [],
+  },
+  subagents: {
+    entry: ["subagent_spawn"],
+    deferred: [
+      "subagent_wait",
+      "subagent_cancel",
+      "subagent_send",
+      "subagent_check",
+      "subagent_list",
+    ],
+  },
+  workflows: {
+    entry: ["workflow"],
+    deferred: ["workflow_stop", "workflow_status"],
+  },
+  background: {
+    entry: ["bg_start"],
+    deferred: ["bg_status", "bg_list", "bg_kill", "bg_watch"],
+  },
+  tasks: {
+    entry: ["tasks_add"],
+    deferred: ["tasks_update", "tasks_list"],
+  },
+  goal: {
+    entry: ["create_goal"],
+    deferred: ["get_goal", "update_goal"],
+  },
+  interaction: {
+    entry: [],
+    deferred: ["ask_user", "human_handoff"],
+  },
+  plan: {
+    entry: [],
+    deferred: ["plan_ready"],
+  },
+  setup: {
+    entry: [],
+    deferred: ["configure_my_pi_setup"],
+  },
+  context: {
+    entry: [],
+    deferred: ["context_pivot"],
+  },
+} as const;
+
+export type OpenPiToolOwner = keyof typeof OPENPI_TOOL_SURFACE;
+
+export const OPENPI_CAPABILITY_GROUPS = {
+  search: {
+    owners: ["fileSearch"],
+    summary: "Fast structured file and content search with fd and rg.",
+  },
+  delegate: {
+    owners: ["subagents"],
+    summary: "Spawn and manage isolated in-process Pi subagents.",
+  },
+  workflow: {
+    owners: ["workflows"],
+    summary: "Run replay-safe multi-stage workflows.",
+  },
+  background: {
+    owners: ["background"],
+    summary: "Start and manage long-running background terminals.",
+  },
+  session: {
+    owners: ["tasks", "goal"],
+    summary:
+      "Track explicit session tasks and persistent user-requested goals.",
+  },
+} as const satisfies Record<
+  string,
+  { owners: readonly OpenPiToolOwner[]; summary: string }
+>;
+
+export type OpenPiCapability = keyof typeof OPENPI_CAPABILITY_GROUPS;
+
+export const OPENPI_CAPABILITY_NAMES = Object.keys(
+  OPENPI_CAPABILITY_GROUPS,
+) as OpenPiCapability[];
+
+export const DEFAULT_OPENPI_ACTIVE_TOOL_NAMES: readonly string[] = [];
+
+export const OPENPI_TOOL_SURFACE_NAMES = Object.values(
+  OPENPI_TOOL_SURFACE,
+).flatMap(({ entry, deferred }) => [...entry, ...deferred]);
+
+interface ActiveToolSurface {
+  events?: {
+    emit(channel: string, data: unknown): void;
+    on(channel: string, handler: (data: unknown) => void): () => void;
+  };
+  getActiveTools(): string[];
+  getAllTools?(): {
+    name: string;
+    sourceInfo?: { path: string; source?: string };
+  }[];
+  setActiveTools(names: string[]): void;
+}
+
+interface OwnedToolPatch {
+  enable?: readonly string[];
+  disable?: readonly string[];
+}
+
+interface ToolSurfaceState {
+  loaded: Set<OpenPiCapability>;
+  desiredByOwner: Map<OpenPiToolOwner, Set<string>>;
+  sourceByOwner: Map<OpenPiToolOwner, string>;
+  managedOwners: Set<OpenPiToolOwner>;
+  knownAvailable: Set<string>;
+  subscribed: boolean;
+}
+
+const OWNER_SOURCE_PATHS = {
+  capabilities: fileURLToPath(
+    new URL("../capabilities/index.ts", import.meta.url),
+  ),
+  fileSearch: fileURLToPath(
+    new URL("../file-search/index.ts", import.meta.url),
+  ),
+  subagents: fileURLToPath(new URL("../subagents/index.ts", import.meta.url)),
+  workflows: fileURLToPath(new URL("../workflows/index.ts", import.meta.url)),
+  background: fileURLToPath(
+    new URL("../background-terminals/index.ts", import.meta.url),
+  ),
+  tasks: fileURLToPath(new URL("../tasks/index.ts", import.meta.url)),
+  goal: fileURLToPath(new URL("../goal/index.ts", import.meta.url)),
+  interaction: fileURLToPath(new URL("../ask-user/index.ts", import.meta.url)),
+  plan: fileURLToPath(new URL("../plan-mode/index.ts", import.meta.url)),
+  setup: fileURLToPath(new URL("../setup/index.ts", import.meta.url)),
+  context: fileURLToPath(new URL("../context-pivot/index.ts", import.meta.url)),
+} as const satisfies Record<OpenPiToolOwner, string>;
+
+const states = new WeakMap<object, ToolSurfaceState>();
+export const OPENPI_CAPABILITY_STATE_CHANNEL = "openpi:capability-state";
+
+function initialDesiredByOwner() {
+  return new Map<OpenPiToolOwner, Set<string>>(
+    (Object.keys(OPENPI_TOOL_SURFACE) as OpenPiToolOwner[]).map((owner) => [
+      owner,
+      new Set<string>(
+        owner === "capabilities" ? [] : OPENPI_TOOL_SURFACE[owner].entry,
+      ),
+    ]),
+  );
+}
+
+function newState(): ToolSurfaceState {
+  return {
+    loaded: new Set<OpenPiCapability>(),
+    desiredByOwner: initialDesiredByOwner(),
+    sourceByOwner: new Map<OpenPiToolOwner, string>(),
+    managedOwners: new Set<OpenPiToolOwner>(),
+    knownAvailable: new Set<string>(),
+    subscribed: false,
+  };
+}
+
+function capabilityStateFromEvent(data: unknown) {
+  if (typeof data !== "object" || data === null) return undefined;
+  const loaded = (data as { loaded?: unknown }).loaded;
+  if (!Array.isArray(loaded)) return undefined;
+  if (
+    loaded.some(
+      (name) =>
+        typeof name !== "string" ||
+        !OPENPI_CAPABILITY_NAMES.includes(name as OpenPiCapability),
+    )
+  ) {
+    return undefined;
+  }
+  return loaded as OpenPiCapability[];
+}
+
+function subscribeToCapabilityState(
+  pi: ActiveToolSurface,
+  state: ToolSurfaceState,
+) {
+  if (
+    state.subscribed ||
+    typeof pi.events?.on !== "function" ||
+    typeof pi.events?.emit !== "function"
+  ) {
+    return;
+  }
+  state.subscribed = true;
+  pi.events.on(OPENPI_CAPABILITY_STATE_CHANNEL, (data) => {
+    const loaded = capabilityStateFromEvent(data);
+    if (!loaded) return;
+    state.loaded = new Set(loaded);
+    reconcileManagedOwners(pi, state);
+  });
+}
+
+function stateFor(pi: ActiveToolSurface) {
+  let state = states.get(pi);
+  if (!state) {
+    state = newState();
+    if (
+      typeof pi.events?.on !== "function" ||
+      typeof pi.events?.emit !== "function"
+    ) {
+      state.loaded = new Set(OPENPI_CAPABILITY_NAMES);
+    }
+    states.set(pi, state);
+  }
+  return state;
+}
+
+function capabilityForOwner(owner: OpenPiToolOwner) {
+  return OPENPI_CAPABILITY_NAMES.find((capability) =>
+    OPENPI_CAPABILITY_GROUPS[capability].owners.includes(owner as never),
+  );
+}
+
+function ownerIsVisible(state: ToolSurfaceState, owner: OpenPiToolOwner) {
+  const capability = capabilityForOwner(owner);
+  return capability === undefined || state.loaded.has(capability);
+}
+
+function ownedToolNames(owner: OpenPiToolOwner) {
+  return [
+    ...OPENPI_TOOL_SURFACE[owner].entry,
+    ...OPENPI_TOOL_SURFACE[owner].deferred,
+  ] as readonly string[];
+}
+
+function availableOwnedToolNames(
+  pi: ActiveToolSurface,
+  state: ToolSurfaceState,
+  owner: OpenPiToolOwner,
+) {
+  for (const name of pi.getActiveTools()) state.knownAvailable.add(name);
+  const reportedTools = pi.getAllTools?.();
+  const owned = new Set<string>(ownedToolNames(owner));
+  if (!reportedTools || reportedTools.length === 0) {
+    return new Set([...state.knownAvailable].filter((name) => owned.has(name)));
+  }
+  if (reportedTools.every((tool) => tool.sourceInfo === undefined)) {
+    return new Set(
+      reportedTools.map(({ name }) => name).filter((name) => owned.has(name)),
+    );
+  }
+
+  const expectedSource =
+    state.sourceByOwner.get(owner) ?? OWNER_SOURCE_PATHS[owner];
+  return new Set(
+    reportedTools
+      .filter(
+        (tool) =>
+          owned.has(tool.name) && tool.sourceInfo?.path === expectedSource,
+      )
+      .map(({ name }) => name),
+  );
+}
+
+function projectedOwnerTools(
+  pi: ActiveToolSurface,
+  state: ToolSurfaceState,
+  owner: OpenPiToolOwner,
+) {
+  const available = availableOwnedToolNames(pi, state, owner);
+  const owned = ownedToolNames(owner);
+  const ownedAvailable = new Set(owned.filter((name) => available.has(name)));
+  const desired = state.desiredByOwner.get(owner)!;
+  const visible = ownerIsVisible(state, owner);
+  const next = pi
+    .getActiveTools()
+    .filter(
+      (name) => !ownedAvailable.has(name) || (visible && desired.has(name)),
+    );
+  const nextSet = new Set(next);
+
+  if (visible) {
+    for (const name of owned) {
+      if (desired.has(name) && !nextSet.has(name) && available.has(name)) {
+        next.push(name);
+        nextSet.add(name);
+      }
+    }
+  }
+
+  return next;
+}
+
+function applyActiveTools(pi: ActiveToolSurface, next: string[]) {
+  const active = pi.getActiveTools();
+  if (
+    active.length === next.length &&
+    active.every((name, index) => name === next[index])
+  ) {
+    return false;
+  }
+  pi.setActiveTools(next);
+  return true;
+}
+
+function reconcileOwner(
+  pi: ActiveToolSurface,
+  state: ToolSurfaceState,
+  owner: OpenPiToolOwner,
+) {
+  return applyActiveTools(pi, projectedOwnerTools(pi, state, owner));
+}
+
+function reconcileManagedOwners(
+  pi: ActiveToolSurface,
+  state: ToolSurfaceState,
+) {
+  let changed = false;
+  for (const owner of state.managedOwners) {
+    changed = reconcileOwner(pi, state, owner) || changed;
+  }
+  return changed;
+}
+
+/** Reset one bound Pi Session to the minimal parent surface. */
+export function resetOpenPiToolSurface(
+  pi: ActiveToolSurface,
+  sourceByOwner: Readonly<Partial<Record<OpenPiToolOwner, string>>> = {},
+) {
+  const state = newState();
+  for (const [owner, source] of Object.entries(sourceByOwner)) {
+    if (source) state.sourceByOwner.set(owner as OpenPiToolOwner, source);
+  }
+  states.set(pi, state);
+  state.managedOwners.add("capabilities");
+  const changed = reconcileOwner(pi, state, "capabilities");
+  pi.events?.emit(OPENPI_CAPABILITY_STATE_CHANNEL, { loaded: [] });
+  return changed;
+}
+
+export function getLoadedOpenPiCapabilities(pi: ActiveToolSurface) {
+  return OPENPI_CAPABILITY_NAMES.filter((capability) =>
+    stateFor(pi).loaded.has(capability),
+  );
+}
+
+/**
+ * Load capability groups monotonically for this Session. There is deliberately
+ * no unload operation: a stable surface is more cache-friendly and easier for
+ * the model to reason about than tools that repeatedly disappear and return.
+ */
+export function loadOpenPiCapabilities(
+  pi: ActiveToolSurface,
+  capabilities: readonly OpenPiCapability[],
+) {
+  const invalid = capabilities.filter(
+    (capability) => !OPENPI_CAPABILITY_NAMES.includes(capability),
+  );
+  if (invalid.length > 0) {
+    throw new Error(
+      `Unknown OpenPI ${invalid.length === 1 ? "capability" : "capabilities"}: ${invalid.map((name) => JSON.stringify(name)).join(", ")}.`,
+    );
+  }
+
+  const state = stateFor(pi);
+  const before = pi.getActiveTools();
+  const newlyLoaded: OpenPiCapability[] = [];
+  for (const capability of capabilities) {
+    if (!state.loaded.has(capability)) {
+      state.loaded.add(capability);
+      newlyLoaded.push(capability);
+    }
+  }
+  reconcileManagedOwners(pi, state);
+  pi.events?.emit(OPENPI_CAPABILITY_STATE_CHANNEL, {
+    loaded: getLoadedOpenPiCapabilities(pi),
+  });
+  const beforeSet = new Set(before);
+  return {
+    newlyLoaded,
+    loaded: getLoadedOpenPiCapabilities(pi),
+    activatedTools: pi.getActiveTools().filter((name) => !beforeSet.has(name)),
+  };
+}
+
+/**
+ * Record one owner's desired tools and reconcile them through both gates:
+ * capability loaded first, then the owner's authoritative resource/mode state.
+ * Foreign and Pi-native tools are always preserved from the latest active list.
+ */
+export function patchOwnedTools(
+  pi: ActiveToolSurface,
+  owner: OpenPiToolOwner,
+  patch: OwnedToolPatch,
+) {
+  const owned = [
+    ...OPENPI_TOOL_SURFACE[owner].entry,
+    ...OPENPI_TOOL_SURFACE[owner].deferred,
+  ] as readonly string[];
+  const ownedSet = new Set(owned);
+  const enable = new Set(patch.enable ?? []);
+  const disable = new Set(patch.disable ?? []);
+
+  for (const name of [...enable, ...disable]) {
+    if (!ownedSet.has(name)) {
+      throw new Error(`${owner} does not own tool ${JSON.stringify(name)}.`);
+    }
+  }
+  for (const name of enable) {
+    if (disable.has(name)) {
+      throw new Error(
+        `${owner} cannot enable and disable tool ${JSON.stringify(name)} in one patch.`,
+      );
+    }
+  }
+
+  const state = stateFor(pi);
+  state.managedOwners.add(owner);
+  if (capabilityForOwner(owner)) subscribeToCapabilityState(pi, state);
+  const desired = state.desiredByOwner.get(owner)!;
+  for (const name of enable) state.knownAvailable.add(name);
+  for (const name of disable) desired.delete(name);
+  for (const name of enable) desired.add(name);
+  return reconcileOwner(pi, state, owner);
+}

package/extensions/subagents/index.ts

@@ -65,6 +65,10 @@ import {
   hasActivity,
   unreadActivityCounts,
 } from "../shared/activity-status.ts";
+import {
+  OPENPI_TOOL_SURFACE,
+  patchOwnedTools,
+} from "../shared/tool-surface.ts";
 import { formatContextUtilization } from "./src/format.ts";
 import { SubagentManager, type SubagentManagerShape } from "./src/manager.ts";
 import {
@@ -198,6 +202,14 @@ export default function (pi: ExtensionAPI) {
   let requestWidgetRender: (() => void) | undefined;
   let dashboardOpen = false;
   const resultDelivery = createDeferredResultDelivery<SubagentSnapshot>();
+  const hideLifecycleTools = () =>
+    patchOwnedTools(pi, "subagents", {
+      disable: OPENPI_TOOL_SURFACE.subagents.deferred,
+    });
+  const showLifecycleTools = () =>
+    patchOwnedTools(pi, "subagents", {
+      enable: OPENPI_TOOL_SURFACE.subagents.deferred,
+    });
 
   const getRuntime = () => (runtime ??= createSubagentRuntime());
 
@@ -408,6 +420,7 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("session_start", (_event, ctx) => {
     refreshAgentTypes(ctx.cwd, ctx.isProjectTrusted());
+    hideLifecycleTools();
     sessionContext = ctx;
     settledAcknowledgedAt = 0;
     if (ctx.hasUI) ui = ctx.ui;
@@ -681,6 +694,8 @@ export default function (pi: ExtensionAPI) {
         throw error;
       }
 
+      showLifecycleTools();
+
       return {
         content: [
           {

package/extensions/subagents/src/manager.ts

@@ -205,7 +205,8 @@ const makeManager = Effect.gen(function* () {
   let reservedBtw = 0;
   let disposed = false;
   let onSettled:
-    ((snap: SubagentSnapshot, consumed: boolean) => void) | undefined;
+    | ((snap: SubagentSnapshot, consumed: boolean) => void)
+    | undefined;
 
   const notify = (id?: string) => {
     const waiters = changeWaiters;
@@ -636,16 +637,17 @@ const makeManager = Effect.gen(function* () {
             pruneSettled();
           }),
         ),
-        Effect.map((): ReadonlyArray<CancelResult> =>
-          unique.map((id) => {
-            const snapshot = entries.get(id)?.snapshot;
-            return {
-              id,
-              title: snapshot?.title ?? "?",
-              status: snapshot?.status ?? "error",
-              cancelled: runningIds.includes(id),
-            };
-          }),
+        Effect.map(
+          (): ReadonlyArray<CancelResult> =>
+            unique.map((id) => {
+              const snapshot = entries.get(id)?.snapshot;
+              return {
+                id,
+                title: snapshot?.title ?? "?",
+                status: snapshot?.status ?? "error",
+                cancelled: runningIds.includes(id),
+              };
+            }),
         ),
       );
     });

package/extensions/subagents/src/prompt.ts

@@ -75,7 +75,7 @@ export const SUBAGENT_SPAWN_PARAMETER_DESCRIPTIONS = {
   workingDir:
     "Trusted working directory for the autonomous child (default: current working directory)",
   isolation:
-    'Set to "worktree" to run this child in its own git worktree on its own branch, branched from HEAD. Use it whenever children may edit the same files or stage changes concurrently — without it, parallel children share one checkout and one git index, so their edits and `git add`s overwrite each other. The child should COMMIT its work. A direct child can receive later subagent_send turns, so its checkout lives with that child Session. On retirement it is reclaimed only when a bounded inspection proves it empty; commits, dirty/untracked/ignored files, detached HEAD, timeout, or Git failure preserve it. Requires a git repository, and the checkout starts clean, so anything gitignored (build output, .env) will not be there.',
+    'Set to "worktree" for concurrent writers and tell the child to commit. Requires Git and a clean checkout. Read the subagents Skill for lifecycle, merge location, and costs.',
   model:
     'Optional model override, as "provider/model-id" or a bare id resolved against the current provider. Precedence: explicit spawn model > selected type file model > configured built-in role model > parent model. Never guess a model name.',
   reasoningEffort:

package/extensions/tasks/index.ts

@@ -6,6 +6,10 @@ import type {
 } from "@earendil-works/pi-coding-agent";
 import { Key, Text } from "@earendil-works/pi-tui";
 import { Type } from "typebox";
+import {
+  OPENPI_TOOL_SURFACE,
+  patchOwnedTools,
+} from "../shared/tool-surface.ts";
 import {
   TASKS_ENTRY_TYPE,
   TASKS_LIMITS,
@@ -97,6 +101,14 @@ export default function sessionTasks(pi: ExtensionAPI) {
   let taskWidgetExpanded = false;
   let ui: ExtensionContext["ui"] | undefined;
   let uiMode: ExtensionContext["mode"] | undefined;
+  const hideLifecycleTools = () =>
+    patchOwnedTools(pi, "tasks", {
+      disable: OPENPI_TOOL_SURFACE.tasks.deferred,
+    });
+  const showLifecycleTools = () =>
+    patchOwnedTools(pi, "tasks", {
+      enable: OPENPI_TOOL_SURFACE.tasks.deferred,
+    });
 
   const snapshot = () => tasks.snapshot();
 
@@ -199,13 +211,15 @@ export default function sessionTasks(pi: ExtensionAPI) {
     items,
     total: snapshot().items.length,
     revision: snapshot().revision,
-    // From the live snapshot, not `items`: a tools_update carries only the one
-    // row it touched, and a header counted from that would claim the batch is
-    // a single task.
     counts: taskCounts(snapshot().items),
     ...(batchClosed ? { batchClosed: true } : {}),
   });
 
+  const mutationResultText = (summary: string) => {
+    const current = snapshot();
+    return `${summary}\nCurrent task snapshot (${current.items.length} ${current.items.length === 1 ? "item" : "items"}):\n${tasks.render()}`;
+  };
+
   const registerTools = () => {
     if (toolsRegistered || conflict) return;
     toolsRegistered = true;
@@ -218,6 +232,7 @@ export default function sessionTasks(pi: ExtensionAPI) {
         "Add stable work-intent items to the current session tasks",
       promptGuidelines: [
         "Use tasks_add only for work spanning multiple agent runs or user turns, or when the user explicitly provides a task list; do not use it as a per-step scratchpad within one run.",
+        "Before starting each tracked item, call tasks_update to mark it in_progress; concurrent work may have multiple in_progress items.",
         "Task tools record advisory intent only; Subagents and Workflows execute work, while files, git, tests, tool results, artifacts, and user confirmation remain truth.",
       ],
       parameters: Type.Object({
@@ -239,14 +254,17 @@ export default function sessionTasks(pi: ExtensionAPI) {
         assertAvailable();
         const mutation = applyTaskAdd(snapshot(), params.items);
         persistThenCommit(mutation.snapshot);
+        showLifecycleTools();
         return Promise.resolve({
           content: [
             {
               type: "text" as const,
-              text: `Added ${mutation.items.map((item) => `T${item.id}`).join(", ")}.`,
+              text: mutationResultText(
+                `Added ${mutation.items.map((item) => `T${item.id}`).join(", ")}.`,
+              ),
             },
           ],
-          details: toolDetails("add", mutation.items),
+          details: toolDetails("add", snapshot().items),
         });
       },
       renderCall(args, theme) {
@@ -273,7 +291,9 @@ export default function sessionTasks(pi: ExtensionAPI) {
       description: `${TOOL_PURPOSE} Patch one task item by numeric ID. blocked, done, and dropped status changes require a fresh note explaining the blocker, observable evidence, or drop reason.`,
       promptSnippet: "Update one session task item by stable ID",
       promptGuidelines: [
-        "Keep tasks_update status current when tracked work materially changes, but avoid ceremonial status churn.",
+        "Immediately after each tracked item reaches a real outcome, call tasks_update to set done, blocked, or dropped before moving to the next tracked item.",
+        "Before sending a final answer, reconcile every task touched in the current request; do not leave completed work pending or in_progress.",
+        "A commit, passing test, or authorization is task-scoped evidence only; it does not by itself prove a task is done or identify which task to update.",
         "Before setting a task item to done, include a note citing an observable check, artifact, commit, tool result, or user confirmation; Tasks record this claim but do not verify it.",
       ],
       parameters: Type.Object({
@@ -305,18 +325,21 @@ export default function sessionTasks(pi: ExtensionAPI) {
         );
         const mutation = applyTaskUpdate(before, params);
         const changed = persistThenCommit(mutation.snapshot);
+        if (changed && closesBatch) hideLifecycleTools();
         return Promise.resolve({
           content: [
             {
               type: "text" as const,
-              text: changed
-                ? closesBatch
-                  ? `${params.status === "dropped" ? "Dropped" : "Completed"} T${params.id}. Task batch closed; the next tasks_add starts again at T1.`
-                  : `Updated T${params.id}.`
-                : `T${params.id} already has that state; no update recorded.`,
+              text: mutationResultText(
+                changed
+                  ? closesBatch
+                    ? `${params.status === "dropped" ? "Dropped" : "Completed"} T${params.id}. Task batch closed; the next tasks_add starts again at T1.`
+                    : `Updated T${params.id}.`
+                  : `T${params.id} already has that state; no update recorded.`,
+              ),
             },
           ],
-          details: toolDetails("update", mutation.items, closesBatch),
+          details: toolDetails("update", snapshot().items, closesBatch),
         });
       },
       renderCall(args, theme) {
@@ -448,12 +471,16 @@ export default function sessionTasks(pi: ExtensionAPI) {
     taskWidgetVisible = true;
     taskWidgetExpanded = false;
     registerTools();
+    if (hasActionableTasks()) showLifecycleTools();
+    else hideLifecycleTools();
     notifyProblem(ctx);
     updateTaskWidget(ctx);
   });
 
   pi.on("session_tree", (_event, ctx) => {
     restore(ctx);
+    if (hasActionableTasks()) showLifecycleTools();
+    else hideLifecycleTools();
     taskWidgetExpanded = false;
     coldRun = true;
     activeRun = false;

package/extensions/ui-customization/footer.ts

@@ -72,7 +72,12 @@ const MONO_COLORS: readonly PowerlineColors[] = [
 ];
 
 export type SegmentTone =
-  "text" | "muted" | "dim" | "warning" | "error" | "accent";
+  | "text"
+  | "muted"
+  | "dim"
+  | "warning"
+  | "error"
+  | "accent";
 
 export interface FooterSegment {
   readonly id: FooterItem;

package/extensions/workflows/graph-projection.ts

@@ -140,10 +140,12 @@ function findCycles(
     if (!indexes.has(node.callId)) visit(node.callId);
   }
   cycles.sort((left, right) => order.get(left[0]!)! - order.get(right[0]!)!);
-  return cycles.map((callIds): WorkflowGraphDiagnostic => ({
-    code: "cycle",
-    callIds,
-  }));
+  return cycles.map(
+    (callIds): WorkflowGraphDiagnostic => ({
+      code: "cycle",
+      callIds,
+    }),
+  );
 }
 
 export function projectWorkflowGraph<Record extends WorkflowGraphRecord>(