@selesai/code 0.1.19 → 0.2.1

package/dist/extensions/workflow/adapter.ts

@@ -0,0 +1,588 @@
+// ponytail: pi adapter over the pure WorkflowStateMachine. Owns all fs/pi
+// wiring: tool/command/event registration, node:fs predicates, the git skip
+// check, footer rendering, agent continuation, tool-result shaping. Every
+// call site is one sm method + one applyEffect switch over domain effects.
+
+import type {
+  ExtensionAPI,
+  ExtensionCommandContext,
+  ExtensionContext,
+  ToolDefinition,
+} from "@earendil-works/pi-coding-agent";
+import { Text } from "@earendil-works/pi-tui";
+import { Type } from "typebox";
+import { access, mkdir, writeFile } from "node:fs/promises";
+import { isAbsolute, resolve } from "node:path";
+
+import {
+  WorkflowStateMachine,
+  type WorkflowConfig,
+  type WorkflowDeps,
+  type WorkflowEffect,
+  type WorkflowEntry,
+  type FooterState,
+  type Phase,
+} from "./state-machine.ts";
+
+function slugify(s: string): string {
+  const slug = s
+    .toLowerCase()
+    // ponytail: u-flag so Unicode chars (Chinese, emoji, etc.) are also
+    // treated as non-alphanumeric and replaced with dashes — without /u,
+    // JS’s \W shorthand only matches ASCII, leaving Unicode in paths
+    // which confuses agents and tools.
+    .replace(/[^a-z0-9]+/ug, "-")
+    .replace(/^-+|-+$/g, "")
+    .slice(0, 40);
+  return slug || "workflow";
+}
+
+function timestamp(): string {
+  const d = new Date();
+  const p = (n: number) => String(n).padStart(2, "0");
+  return `${d.getFullYear()}${p(d.getMonth() + 1)}${p(d.getDate())}-${p(d.getHours())}${p(d.getMinutes())}${p(d.getSeconds())}`;
+}
+
+function defaultArtifactPathFor(goal: string, base: string): string {
+  return `${base}/${timestamp()}-${slugify(goal)}`;
+}
+
+async function realFileExists(path: string): Promise<boolean> {
+  try {
+    await access(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// ponytail: phases where one spawned subagent owns the phase artifact. Force
+// the child `output` path; child processes do not share the parent's workflow
+// state, so the parent-scoped write_workflow_artifact tool cannot help there.
+const FORCE_OUTPUT_PHASES = new Set<Phase>(["plan", "reuse", "handoff", "audit"]);
+
+// ponytail: phases where the parent can save subagent text as the artifact
+// when the child did not write the file itself (dumb/local models).
+const SUBAGENT_FALLBACK_PHASES = new Set<Phase>(["plan", "reuse", "handoff", "audit"]);
+
+function textFromToolResultContent(content: unknown): string | undefined {
+  if (!Array.isArray(content)) return undefined;
+  const parts: string[] = [];
+  for (const part of content) {
+    if (part && typeof part === "object" && (part as any).type === "text" && typeof (part as any).text === "string") {
+      parts.push((part as any).text);
+    }
+  }
+  const joined = parts.join("\n\n").trim();
+  return joined || undefined;
+}
+
+// ponytail: rewrite the subagent tool input so the child writes its output
+// directly to ${artifactDir}/${file} as an absolute path. Absolute paths pass
+// through resolveSingleOutputPath verbatim, so injectOutputPathSystemPrompt
+// then forces the child to the correct location instead of repo root.
+// Mutates `input` in place (tool_call handlers can patch event.input).
+// No-op unless the workflow is active, in a force-output phase, and the call
+// targets the `subagent` tool. Respects an explicit absolute caller output.
+function forceSubagentOutputToArtifactDir(
+  input: Record<string, unknown>,
+  artifactDir: string,
+  file: string,
+  onlyAgents?: Set<string>,
+): void {
+  const dest = resolve(artifactDir, file);
+  const shouldForce = (agent: string) => !onlyAgents || onlyAgents.has(agent);
+  // Single-agent call: { agent, task, output?, ... }
+  if (typeof input.agent === "string") {
+    if (!shouldForce(input.agent)) return;
+    const existing = input.output;
+    if (typeof existing === "string" && isAbsolute(existing)) return; // caller pinned it
+    input.output = dest;
+    return;
+  }
+  // Top-level parallel: { tasks: [{ agent, output? }, ...] }
+  if (Array.isArray(input.tasks)) {
+    for (const task of input.tasks) {
+      if (task && typeof task === "object" && typeof task.agent === "string" && shouldForce(task.agent)) {
+        const ex = task.output;
+        if (typeof ex === "string" && isAbsolute(ex)) continue;
+        task.output = dest;
+      }
+    }
+    return;
+  }
+  // Chain: { chain: [{ agent, output?, parallel: [{ agent, output? }] }] }
+  if (Array.isArray(input.chain)) {
+    for (const step of input.chain) {
+      if (!step || typeof step !== "object") continue;
+      if (typeof step.agent === "string" && shouldForce(step.agent)) {
+        const ex = step.output;
+        if (!(typeof ex === "string" && isAbsolute(ex))) step.output = dest;
+      }
+      if (Array.isArray(step.parallel)) {
+        for (const task of step.parallel) {
+          if (task && typeof task === "object" && typeof task.agent === "string" && shouldForce(task.agent)) {
+            const ex = task.output;
+            if (!(typeof ex === "string" && isAbsolute(ex))) task.output = dest;
+          }
+        }
+      }
+    }
+  }
+}
+
+export interface WorkflowAdapterOptions {
+  toolNames: { start: string; end: string };
+  toolLabels: { start: string; end: string };
+  commandName: string;
+  commandDescription: string;
+}
+
+interface WorkflowController {
+  pi: ExtensionAPI;
+  config: WorkflowConfig;
+  sm: WorkflowStateMachine;
+  deps: WorkflowDeps;
+}
+
+const WORKFLOW_ARTIFACT_TOOL = "write_workflow_artifact";
+// ponytail: shared across all module copies so prototype + quick registration
+// can race. Module-level state alone is not enough when the loader runs each
+// extension in its own module record.
+const WORKFLOW_GLOBAL = Symbol.for("selesai.workflow.registry.v1");
+type WorkflowRegistry = { controllers: WorkflowController[]; writerRegisteredFor: WeakSet<object> };
+const registry: WorkflowRegistry = ((globalThis as any)[WORKFLOW_GLOBAL] ??= {
+  controllers: [],
+  writerRegisteredFor: new WeakSet(),
+});
+
+// ponytail: tests call this between cases to drop pi references and reset
+// writer-registration state. Production code never calls it.
+export function __resetWorkflowRegistryForTests(): void {
+  registry.controllers.length = 0;
+  (registry.writerRegisteredFor as WeakSet<object>) = new WeakSet();
+}
+
+function activeControllersFor(pi: ExtensionAPI): WorkflowController[] {
+  return registry.controllers.filter((c) => c.pi === pi && c.sm.snapshot.active);
+}
+
+// ponytail: builds the deps bundle the adapter injects into the state machine.
+// The skip predicate wraps pi.exec("git"...) — the only true-external seam.
+function makeDeps(pi: ExtensionAPI, config: WorkflowConfig): WorkflowDeps {
+  return {
+    async artifactExists(phase, dir) {
+      const file = config.phaseArtifacts[phase];
+      if (!file) return true;
+      return realFileExists(`${dir}/${file}`);
+    },
+    async fileExists(path) {
+      return realFileExists(path);
+    },
+    async mkdirArtifactDir(path) {
+      await mkdir(path, { recursive: true });
+    },
+    artifactPathFor: defaultArtifactPathFor,
+  };
+}
+
+// ponytail: the git-based skip predicate shared by both modes today.
+// A mode that wants a different skip rule supplies its own SkipRule.
+async function isEmptyProject(pi: ExtensionAPI): Promise<boolean> {
+  try {
+    const result = await pi.exec("git", ["log", "--oneline", "-1"]);
+    return result.code !== 0 || !result.stdout.trim();
+  } catch {
+    return false;
+  }
+}
+
+function footerText(footer: FooterState, ctx: ExtensionContext): string | undefined {
+  if (!footer.visible) return undefined;
+  return ctx.ui.theme.fg("warning", footer.text);
+}
+
+function applyEntry(pi: ExtensionAPI, config: WorkflowConfig, entry: WorkflowEntry): void {
+  pi.appendEntry(config.entryType, entry);
+}
+
+function applyFooter(ctx: ExtensionContext, footer: FooterState): void {
+  ctx.ui.setStatus(footer.statusKey, footerText(footer, ctx));
+}
+
+function continueAgent(pi: ExtensionAPI, ctx: ExtensionContext, prompt: string): void {
+  // ponytail: agent is mid-turn (streaming) when tool_result fires, so a bare
+  // sendUserMessage() throws "Agent is already processing". deliverAs:"followUp"
+  // is the framework-native continuation. In idle state (e.g. session resume)
+  // it sends a direct turn.
+  if (ctx.isIdle()) {
+    pi.sendUserMessage(prompt);
+  } else {
+    pi.sendUserMessage(prompt, { deliverAs: "followUp" });
+  }
+}
+
+// ponytail: apply side effects for effects that carry entry/footer/prompt.
+// Terminal/blocked/idle/noOp/alreadyActive carry none — the adapter's call
+// site formats the tool result from the effect's domain fields + config.
+function applyEffect(
+  pi: ExtensionAPI,
+  ctx: ExtensionContext,
+  config: WorkflowConfig,
+  eff: WorkflowEffect,
+): void {
+  switch (eff.kind) {
+    case "started":
+    case "advanced":
+      if ("entry" in eff) applyEntry(pi, config, eff.entry);
+      if ("footer" in eff) applyFooter(ctx, eff.footer);
+      if (eff.prompt) continueAgent(pi, ctx, eff.prompt);
+      return;
+    case "closed":
+      if ("entry" in eff) applyEntry(pi, config, eff.entry);
+      if ("footer" in eff) applyFooter(ctx, eff.footer);
+      ctx.ui.notify(
+        `${config.footerLabel} workflow complete. Artifacts: ${eff.artifactDir}`,
+        "info",
+      );
+      return;
+    case "terminalNeedsArtifacts":
+      if (eff.promptToQueue) continueAgent(pi, ctx, eff.promptToQueue);
+      return;
+    case "blocked":
+    case "terminalReady":
+    case "endBlocked":
+    case "idle":
+    case "noOp":
+    case "alreadyActive":
+      return;
+  }
+}
+
+function registerSharedArtifactWriter(pi: ExtensionAPI): void {
+  if (registry.writerRegisteredFor.has(pi)) return;
+  registry.writerRegisteredFor.add(pi);
+  pi.registerTool({
+    name: WORKFLOW_ARTIFACT_TOOL,
+    label: "Write Workflow Artifact",
+    description: "Write the current workflow phase artifact. The workflow enforces the destination path; provide content only.",
+    promptSnippet: `${WORKFLOW_ARTIFACT_TOOL}(content) - write the active workflow artifact; path is chosen by the workflow, not the agent.`,
+    promptGuidelines: [
+      `During any workflow, use ${WORKFLOW_ARTIFACT_TOOL} instead of write/edit for workflow artifacts.`,
+      "Provide artifact content only; do not provide a path.",
+    ],
+    parameters: Type.Object({
+      content: Type.String({ description: "Artifact markdown/text content to save." }),
+    }),
+    async execute(_id, params, _signal, _onUpdate, ctx) {
+      const active = activeControllersFor(pi);
+      if (active.length !== 1) {
+        const msg = active.length === 0
+          ? "No active workflow."
+          : `Multiple active workflows (${active.map((c) => c.config.mode).join(", ")}); close one first.`;
+        return { content: [{ type: "text", text: msg }], details: { active: active.length } };
+      }
+      const controller = active[0]!;
+      const snap = controller.sm.snapshot;
+      const file = controller.config.phaseArtifacts[snap.phase];
+      if (!file) {
+        return {
+          content: [{ type: "text", text: `Phase ${snap.phase} has no workflow artifact.` }],
+          details: { phase: snap.phase, blocked: true },
+        };
+      }
+      const path = resolve(snap.artifactDir, file);
+      await mkdir(snap.artifactDir, { recursive: true });
+      await writeFile(path, params.content, "utf8");
+      const eff = await controller.sm.onArtifactMaybe(controller.deps);
+      applyEffect(pi, ctx, controller.config, eff);
+      return {
+        content: [{ type: "text", text: `Wrote ${path}.` }],
+        details: { mode: controller.config.mode, phase: snap.phase, path, file },
+      };
+    },
+    renderResult(result, _options, theme) {
+      const d = result.details as { path?: string; blocked?: boolean };
+      if (d.blocked) return new Text(theme.fg("warning", "○ workflow artifact not written"), 0, 0);
+      return new Text(theme.fg(d.path ? "success" : "warning", d.path ? `✓ wrote ${d.path}` : "○ no active workflow"), 0, 0);
+    },
+  } satisfies ToolDefinition);
+}
+
+export function createWorkflowExtension(
+  config: WorkflowConfig,
+  options: WorkflowAdapterOptions,
+): (pi: ExtensionAPI) => void {
+  return function workflowExtension(pi: ExtensionAPI): void {
+    const deps = makeDeps(pi, config);
+    // ponytail: default skip rule — reuse is skipped on empty projects (no git
+    // commits). Shared by every mode today; a mode that wants a different rule
+    // supplies its own skipRules in config and we respect them as-is.
+    const skipRules = config.skipRules ?? [
+      {
+        phase: "reuse",
+        shouldSkip: async () => isEmptyProject(pi),
+      },
+    ];
+    const sm = new WorkflowStateMachine({ ...config, skipRules });
+    const controller: WorkflowController = { pi, config, sm, deps };
+    registry.controllers.push(controller);
+    registerSharedArtifactWriter(pi);
+    const { start, end } = options.toolNames;
+    const { mode, footerLabel } = config;
+
+    // ── start tool ──
+    pi.registerTool({
+      name: start,
+      label: options.toolLabels.start,
+      description: `Start the ${mode} workflow for the given goal. Sets up grilling as the first phase and returns the grilling prompt. Do not call if a workflow is already active.`,
+      promptSnippet: `${start}(goal) - start the ${mode} workflow; goal is what the user wants to build.`,
+      promptGuidelines: [
+        `Call ${start} only when the user explicitly asks to start a ${mode} workflow and none is active.`,
+        "Pass the user's full goal as the goal parameter.",
+      ],
+      parameters: Type.Object({
+        goal: Type.String({
+          description: `What the user wants the ${mode} workflow to build or accomplish.`,
+        }),
+      }),
+      async execute(_id, params, _signal, _onUpdate, ctx) {
+        const other = activeControllersFor(pi).find((c) => c.sm !== sm);
+        if (other) {
+          return {
+            content: [{ type: "text", text: `A ${other.config.mode} workflow is already active (phase: ${other.sm.snapshot.phase}). Close it before starting ${mode}.` }],
+            details: { phase: other.sm.snapshot.phase, alreadyActive: true },
+          };
+        }
+        const eff = await sm.start(params.goal, deps);
+        applyEffect(pi, ctx, config, eff);
+        if (eff.kind === "alreadyActive") {
+          return {
+            content: [
+              {
+                type: "text",
+                text: `A ${mode} workflow is already active (phase: ${eff.phase}). Do not call ${start} again. Phases auto-advance as artifacts land; call ${end} only from the final phase.`,
+              },
+            ],
+            details: { phase: eff.phase, alreadyActive: true },
+          };
+        }
+        return {
+          content: [
+            { type: "text", text: `${footerLabel} workflow started. ${eff.prompt}` },
+          ],
+          details: { phase: eff.phase },
+        };
+      },
+      renderResult(_result, _options, theme) {
+        return new Text(
+          theme.fg("warning", `● ${footerLabel} started · 1/${config.phases.length} ${config.phases[0]}`),
+          0,
+          0,
+        );
+      },
+    } satisfies ToolDefinition);
+
+    // ── end tool ──
+    pi.registerTool({
+      name: end,
+      label: options.toolLabels.end,
+      description: `Close the ${mode} workflow. Must be called when the final phase is complete. Marks the workflow finished and stops the agent loop.`,
+      promptSnippet: `${end}() - close the finished ${mode} workflow; no further phase transitions allowed.`,
+      promptGuidelines: [
+        `Call ${end} exactly once, from the terminal phase, when all close artifacts are complete.`,
+      ],
+      parameters: Type.Object({}),
+      async execute(_id, _params, _signal, _onUpdate, ctx) {
+        const eff = await sm.end(deps);
+        applyEffect(pi, ctx, config, eff);
+        switch (eff.kind) {
+          case "closed":
+            return {
+              content: [{ type: "text", text: `Workflow ended and closed. It can no longer be used. Artifacts saved at ${eff.artifactDir}.` }],
+              details: { closed: true, phase: eff.phase, artifactDir: eff.artifactDir },
+              terminate: true,
+            };
+          case "endBlocked": {
+            // ponytail: missing is either a filename (closeArtifacts loop)
+            // or a phase description like "not at terminal (audit)". Only
+            // suggest writing when it's an actual artifact file.
+            const isArtifactFile =
+              !eff.missing.includes(" ") && eff.missing.includes(".");
+            const hint = isArtifactFile
+              ? ` Write ${sm.snapshot.artifactDir}/${eff.missing} first.`
+              : ` Continue through the phases to ${config.phases[config.phases.length - 1]}.`;
+            return {
+              content: [{ type: "text", text: `Cannot end: ${eff.missing}.${hint}` }],
+              details: { phase: eff.phase, blocked: eff.missing },
+            };
+          }
+          default:
+            return {
+              content: [{ type: "text", text: `No active ${mode} workflow to end.` }],
+              details: { active: false },
+            };
+        }
+      },
+      renderResult(result, _options, theme) {
+        const d = result.details as { closed?: boolean; artifactDir?: string };
+        if (!d.closed) {
+          return new Text(theme.fg("dim", "○ no workflow to end"), 0, 0);
+        }
+        return new Text(
+          theme.fg("success", `✓ ${footerLabel} closed · ${d.artifactDir}`),
+          0,
+          0,
+        );
+      },
+    } satisfies ToolDefinition);
+
+    // ── session_start: restore state from persisted entries ──
+    pi.on("session_start", async (_event: any, ctx: ExtensionContext) => {
+      const entries = ctx.sessionManager.getEntries();
+      for (let i = entries.length - 1; i >= 0; i--) {
+        const e = entries[i] as { type: string; customType?: string; data?: any };
+        if (e.type === "custom" && e.customType === config.entryType && e.data) {
+          if (e.data.done) {
+            sm.rehydrate({
+              active: false,
+              phase: e.data.phase as Phase,
+              userPrompt: e.data.userPrompt ?? "",
+              artifactDir: e.data.artifactDir ?? "",
+              autoArmed: false,
+            });
+          } else {
+            sm.rehydrate({
+              active: true,
+              phase: e.data.phase as Phase,
+              userPrompt: e.data.userPrompt ?? "",
+              artifactDir: e.data.artifactDir ?? "",
+              autoArmed: true,
+            });
+          }
+          // ponytail: re-render footer from snapshot without advancing.
+          if (sm.snapshot.active) {
+            ctx.ui.setStatus(
+              config.statusKey,
+              ctx.ui.theme.fg(
+                "warning",
+                `● ${config.footerLabel} · ${config.phases.indexOf(sm.snapshot.phase) + 1}/${config.phases.length} ${sm.snapshot.phase}`,
+              ),
+            );
+          } else {
+            ctx.ui.setStatus(config.statusKey, undefined);
+          }
+          break;
+        }
+      }
+    });
+
+    // ── tool_call: enforce workflow boundaries. ──
+    pi.on("tool_call", (event: any, _ctx: ExtensionContext) => {
+      const tool = event.toolName;
+      if (tool !== "subagent" && tool !== "write" && tool !== "edit") return;
+      const snap = sm.snapshot;
+      if (!snap.active) return;
+      const file = config.phaseArtifacts[snap.phase];
+      if (tool === "write" || tool === "edit") {
+        return {
+          block: true,
+          reason: `Workflow is active (${mode}/${snap.phase}). Use ${WORKFLOW_ARTIFACT_TOOL} for workflow artifacts; workspace edits must be delegated to subagents.`,
+        };
+      }
+      if (!file || !event.input || !FORCE_OUTPUT_PHASES.has(snap.phase)) return;
+      const onlyAgents = snap.phase === "audit" ? new Set(["commentator", "reviewer"]) : undefined;
+      forceSubagentOutputToArtifactDir(event.input, snap.artifactDir, file, onlyAgents);
+    });
+
+    // ── tool_result: auto-advance after subagent/bash artifacts. ──
+    pi.on("tool_result", async (event: any, ctx: ExtensionContext) => {
+      if (event.toolName !== "bash" && event.toolName !== "subagent") return;
+      // ponytail: if a subagent returned text but did not write the expected
+      // artifact (common with dumb/local models), save the returned text as
+      // the artifact so the workflow can still advance.
+      if (event.toolName === "subagent" && sm.snapshot.active && SUBAGENT_FALLBACK_PHASES.has(sm.snapshot.phase)) {
+        const file = config.phaseArtifacts[sm.snapshot.phase];
+        if (file) {
+          const expectedPath = resolve(sm.snapshot.artifactDir, file);
+          if (!(await realFileExists(expectedPath))) {
+            const text = textFromToolResultContent(event.content);
+            if (text) {
+              await mkdir(sm.snapshot.artifactDir, { recursive: true });
+              await writeFile(expectedPath, text, "utf8");
+            }
+          }
+        }
+      }
+      const eff = await sm.onArtifactMaybe(deps);
+      applyEffect(pi, ctx, config, eff);
+    });
+
+    // ── /<command> ──
+    pi.registerCommand(options.commandName, {
+      description: options.commandDescription,
+      handler: async (args: string, ctx: ExtensionCommandContext) => {
+        if (!ctx.isIdle()) {
+          ctx.ui.notify(
+            `Agent is busy. Wait for it to finish before calling /${options.commandName}.`,
+            "warning",
+          );
+          return;
+        }
+
+        if (sm.snapshot.active) {
+          let goal = args.trim();
+          const choice = ctx.hasUI
+            ? await ctx.ui.select(
+                `Workflow already active (phase: ${sm.snapshot.phase}). What do you want to do?`,
+                [
+                  `Continue current workflow at ${sm.snapshot.phase}`,
+                  "Close current and start a new one",
+                ],
+              )
+            : undefined;
+          if (choice === undefined) return;
+          if (choice.startsWith("Continue")) {
+            const eff = sm.continueCurrent();
+            applyEffect(pi, ctx, config, eff);
+            if (eff.kind === "advanced" && eff.prompt) {
+              // continueCurrent already applied footer+entry; send the prompt.
+              continueAgent(pi, ctx, eff.prompt);
+            }
+            return;
+          }
+          if (!goal && ctx.hasUI) {
+            goal = (await ctx.ui.input("Goal for the new workflow:")) ?? "";
+          }
+          if (!goal.trim()) {
+            ctx.ui.notify(
+              "No goal provided. Keeping current workflow active.",
+              "warning",
+            );
+            return;
+          }
+          const closed = sm.closeCurrent();
+          if (closed) {
+            applyEntry(pi, config, closed);
+            ctx.ui.notify(`Closed ${mode} workflow at ${closed.artifactDir}.`, "info");
+          }
+          args = goal;
+        } else if (!args.trim()) {
+          ctx.ui.notify(`Usage: /${options.commandName} <what to build>`, "warning");
+          return;
+        }
+
+        const other = activeControllersFor(pi).find((c) => c.sm !== sm);
+        if (other) {
+          ctx.ui.notify(
+            `${other.config.footerLabel} workflow already active at ${other.sm.snapshot.phase}. Close it before starting ${mode}.`,
+            "warning",
+          );
+          return;
+        }
+        const eff = await sm.start(args, deps);
+        applyEffect(pi, ctx, config, eff);
+      },
+    });
+  };
+}

package/dist/extensions/workflow/extension.ts

@@ -0,0 +1,24 @@
+// ponytail: single pi extension that mounts every workflow mode. One load
+// resolves a single writer tool + N start/end tool pairs. Avoids the per-mode
+// load conflict (multiple extension modules would each try to register the
+// shared writer).
+
+import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { __resetWorkflowRegistryForTests, createWorkflowExtension } from "./adapter.ts";
+import { prototypeMode } from "./modes/prototype.ts";
+import { quickMode } from "./modes/quick.ts";
+
+export { __resetWorkflowRegistryForTests };
+
+const MODES = [prototypeMode, quickMode] as const;
+
+export default function workflowModesExtension(pi: ExtensionAPI): void {
+  for (const mode of MODES) {
+    createWorkflowExtension(mode.config, {
+      toolNames: mode.toolNames,
+      toolLabels: mode.toolLabels,
+      commandName: mode.commandName,
+      commandDescription: mode.commandDescription,
+    })(pi);
+  }
+}