@tt-a1i/openpi 0.1.0

package/extensions/goal/ui.ts

@@ -0,0 +1,158 @@
+import type { Theme } from "@earendil-works/pi-coding-agent";
+import { Text, truncateToWidth } from "@earendil-works/pi-tui";
+import { sanitizeTerminalText } from "../shared/terminal-text.ts";
+import type { GoalSnapshot } from "./state.ts";
+
+export interface GoalToolDetails {
+  goal?: GoalSnapshot;
+  message: string;
+}
+
+export function formatTokensCompact(value: number) {
+  const safe = Math.max(0, value);
+  if (safe === 0) return "0";
+  if (safe < 1_000) return Math.floor(safe).toString();
+  const [divisor, suffix] =
+    safe >= 1_000_000_000_000
+      ? [1_000_000_000_000, "T"]
+      : safe >= 1_000_000_000
+        ? [1_000_000_000, "B"]
+        : safe >= 1_000_000
+          ? [1_000_000, "M"]
+          : [1_000, "K"];
+  const scaled = safe / divisor;
+  const decimals = scaled < 10 ? 2 : scaled < 100 ? 1 : 0;
+  const fixed = scaled.toFixed(decimals);
+  const formatted = fixed.includes(".")
+    ? fixed.replace(/0+$/u, "").replace(/\.$/u, "")
+    : fixed;
+  return `${formatted}${suffix}`;
+}
+
+export function formatGoalElapsedSeconds(value: number) {
+  const seconds = Math.max(0, Math.floor(value));
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  if (minutes < 60) return `${minutes}m`;
+  const hours = Math.floor(minutes / 60);
+  const remainingMinutes = minutes % 60;
+  if (hours >= 24) {
+    const days = Math.floor(hours / 24);
+    return `${days}d ${hours % 24}h ${remainingMinutes}m`;
+  }
+  return remainingMinutes === 0
+    ? `${hours}h`
+    : `${hours}h ${remainingMinutes}m`;
+}
+
+export function goalFooterText(goal: GoalSnapshot) {
+  switch (goal.status) {
+    case "active":
+      return goal.tokenBudget === undefined
+        ? `Pursuing goal (${formatGoalElapsedSeconds(goal.timeUsedSeconds)})`
+        : `Pursuing goal (${formatTokensCompact(goal.tokensUsed)} / ${formatTokensCompact(goal.tokenBudget)})`;
+    case "paused":
+      return "Goal paused (/goal resume)";
+    case "blocked":
+      return "Goal blocked (/goal resume)";
+    case "usage_limited":
+      return "Goal hit usage limits (/goal resume)";
+    case "budget_limited":
+      return goal.tokenBudget === undefined
+        ? "Goal abandoned"
+        : `Goal unmet (${formatTokensCompact(goal.tokensUsed)} / ${formatTokensCompact(goal.tokenBudget)} tokens)`;
+    case "complete": {
+      if (goal.completionAcknowledged) return "";
+      const usage =
+        goal.tokenBudget === undefined
+          ? formatGoalElapsedSeconds(goal.timeUsedSeconds)
+          : `${formatTokensCompact(goal.tokensUsed)} tokens`;
+      return `Goal achieved (${usage})`;
+    }
+    case "cleared":
+      return "";
+  }
+}
+
+export function truncateGoalObjective(objective: string, width = 44) {
+  return truncateToWidth(
+    sanitizeTerminalText(objective).replace(/\s+/gu, " "),
+    width,
+    "…",
+  );
+}
+
+export function goalContinuationLabel(details: unknown) {
+  if (!isRecord(details)) return "↻ Goal continuation";
+  if (details.kind === "objective_updated") return "↻ Goal objective updated";
+  if (details.kind === "budget_limit") return "↻ Goal budget reached";
+  return "↻ Goal continuation";
+}
+
+export function renderGoalTool(
+  details: GoalToolDetails | undefined,
+  expanded: boolean,
+  theme: Theme,
+  background?: (text: string) => string,
+) {
+  if (!details?.goal) {
+    return new Text(
+      theme.fg(
+        "dim",
+        sanitizeTerminalText(details?.message ?? "No goal is currently set."),
+      ),
+      0,
+      0,
+    );
+  }
+  const goal = details.goal;
+  const usage = goal.tokenBudget
+    ? `${formatTokensCompact(goal.tokensUsed)} / ${formatTokensCompact(goal.tokenBudget)} tokens`
+    : `${formatGoalElapsedSeconds(goal.timeUsedSeconds)} · ${formatTokensCompact(goal.tokensUsed)} tokens`;
+  const lines = [
+    `${theme.fg("accent", theme.bold("Goal"))} ${theme.fg(statusColor(goal), sanitizeTerminalText(statusLabel(goal.status)))}`,
+    theme.fg(
+      "text",
+      expanded
+        ? sanitizeTerminalText(goal.objective)
+        : truncateGoalObjective(goal.objective, 70),
+    ),
+    theme.fg("dim", usage),
+  ];
+  if (expanded && goal.reason) {
+    lines.push(theme.fg("dim", `Reason: ${sanitizeTerminalText(goal.reason)}`));
+  }
+  // ToolExecutionComponent normally paints the enclosing Box, but terminals
+  // can expose an unpainted suffix when a styled child line resets its own
+  // attributes. Painting each Goal result row as well makes the full-width
+  // status background deterministic; the enclosing Box still owns padding.
+  return new Text(lines.join("\n"), 0, 0, background);
+}
+
+export function statusColor(goal: GoalSnapshot) {
+  if (goal.status === "active") return "accent" as const;
+  if (goal.status === "complete") return "success" as const;
+  if (
+    goal.status === "blocked" ||
+    goal.status === "usage_limited" ||
+    goal.status === "budget_limited"
+  ) {
+    return "warning" as const;
+  }
+  return "muted" as const;
+}
+
+export function statusLabel(status: GoalSnapshot["status"]) {
+  switch (status) {
+    case "usage_limited":
+      return "usage limited";
+    case "budget_limited":
+      return "limited by budget";
+    default:
+      return sanitizeTerminalText(status);
+  }
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/extensions/model-info/index.ts

@@ -0,0 +1,234 @@
+import type {
+  ExtensionAPI,
+  ExtensionContext,
+} from "@earendil-works/pi-coding-agent";
+import {
+  emptyModelInfoState,
+  MODEL_INFO_CHANNEL,
+  REFRESH_CHANNEL,
+} from "../shared/dashboard-state.ts";
+
+const CHARS_PER_ESTIMATED_TOKEN = 4;
+const LIVE_UPDATE_INTERVAL_MS = 200;
+
+function getSessionMetrics(ctx: ExtensionContext) {
+  let cost = 0;
+  let cacheRead = 0;
+  let promptTokens = 0;
+
+  for (const entry of ctx.sessionManager.getBranch()) {
+    let usage;
+    if (entry.type === "message") {
+      const message = entry.message;
+      if (message.role === "assistant" || message.role === "toolResult") {
+        usage = message.usage;
+      }
+    } else if (entry.type === "compaction" || entry.type === "branch_summary") {
+      usage = entry.usage;
+    }
+    if (!usage) continue;
+    cost += usage.cost.total;
+    cacheRead += usage.cacheRead;
+    promptTokens += usage.input + usage.cacheRead + usage.cacheWrite;
+  }
+
+  return {
+    cost,
+    cachePercent: promptTokens > 0 ? (cacheRead / promptTokens) * 100 : null,
+  };
+}
+
+function estimateContentTokens(characters: number) {
+  return Math.ceil(characters / CHARS_PER_ESTIMATED_TOKEN);
+}
+
+export default function modelInfo(pi: ExtensionAPI) {
+  let state = emptyModelInfoState();
+  let contentStreamStart: number | null = null;
+  let lastContentDeltaAt: number | null = null;
+  let contentCharacters = 0;
+  let firstContentDeltaCharacters = 0;
+  let contentDeltaCount = 0;
+  let sawToolCall = false;
+  let runContentTokens = 0;
+  let runContentStreamMs = 0;
+  let lastLiveUpdate = 0;
+  let currentContext: ExtensionContext | undefined;
+
+  const publish = () => pi.events.emit(MODEL_INFO_CHANNEL, { ...state });
+
+  function refresh(ctx: ExtensionContext) {
+    currentContext = ctx;
+    const model = ctx.model;
+    const usage = ctx.getContextUsage();
+    const metrics = getSessionMetrics(ctx);
+
+    state = {
+      ...state,
+      provider: model?.provider ?? "",
+      modelId: model?.id ?? "no-model",
+      modelName: model?.name ?? model?.id ?? "No model",
+      thinking: model?.reasoning ? pi.getThinkingLevel() : "off",
+      contextTokens: usage?.tokens ?? null,
+      contextWindow: usage?.contextWindow ?? model?.contextWindow ?? 0,
+      contextPercent: usage?.percent ?? null,
+      cachePercent: metrics.cachePercent,
+      cost: metrics.cost,
+    };
+    publish();
+  }
+
+  function resetMessageTracking() {
+    contentStreamStart = null;
+    lastContentDeltaAt = null;
+    contentCharacters = 0;
+    firstContentDeltaCharacters = 0;
+    contentDeltaCount = 0;
+    sawToolCall = false;
+    lastLiveUpdate = 0;
+  }
+
+  const stopRefreshListener = pi.events.on(REFRESH_CHANNEL, () => {
+    if (currentContext) refresh(currentContext);
+  });
+
+  pi.on("session_start", (_event, ctx) => {
+    resetMessageTracking();
+    runContentTokens = 0;
+    runContentStreamMs = 0;
+    state = { ...state, tokensPerSecond: null, generating: false };
+    refresh(ctx);
+  });
+
+  pi.on("model_select", (event, ctx) => {
+    state = {
+      ...state,
+      provider: event.model.provider,
+      modelId: event.model.id,
+      modelName: event.model.name,
+      thinking: event.model.reasoning ? pi.getThinkingLevel() : "off",
+      contextWindow: event.model.contextWindow,
+    };
+    refresh(ctx);
+  });
+
+  pi.on("thinking_level_select", (event) => {
+    state = { ...state, thinking: event.level };
+    publish();
+  });
+
+  pi.on("agent_start", (_event, ctx) => {
+    runContentTokens = 0;
+    runContentStreamMs = 0;
+    resetMessageTracking();
+    state = { ...state, tokensPerSecond: null, generating: true };
+    refresh(ctx);
+  });
+
+  pi.on("message_start", (event) => {
+    if (event.message.role === "assistant") resetMessageTracking();
+  });
+
+  pi.on("message_update", (event) => {
+    if (event.message.role !== "assistant") return;
+
+    const streamEvent = event.assistantMessageEvent;
+    if (streamEvent.type === "toolcall_delta") {
+      sawToolCall = true;
+      return;
+    }
+    if (
+      streamEvent.type !== "text_delta" &&
+      streamEvent.type !== "thinking_delta"
+    )
+      return;
+    if (!streamEvent.delta) return;
+
+    const now = Date.now();
+    if (contentStreamStart === null) {
+      contentStreamStart = now;
+      firstContentDeltaCharacters = streamEvent.delta.length;
+    }
+    lastContentDeltaAt = now;
+    contentCharacters += streamEvent.delta.length;
+    contentDeltaCount += 1;
+
+    const elapsedMs = now - contentStreamStart;
+    const streamedCharacters = contentCharacters - firstContentDeltaCharacters;
+    if (
+      contentDeltaCount < 2 ||
+      elapsedMs <= 0 ||
+      streamedCharacters <= 0 ||
+      now - lastLiveUpdate < LIVE_UPDATE_INTERVAL_MS
+    ) {
+      return;
+    }
+    lastLiveUpdate = now;
+
+    state = {
+      ...state,
+      tokensPerSecond:
+        estimateContentTokens(streamedCharacters) / (elapsedMs / 1000),
+    };
+    publish();
+  });
+
+  pi.on("message_end", (event, ctx) => {
+    if (event.message.role !== "assistant") return;
+
+    sawToolCall ||= event.message.content.some(
+      (block) => block.type === "toolCall",
+    );
+
+    if (contentStreamStart !== null && contentCharacters > 0) {
+      const streamEnd = lastContentDeltaAt ?? contentStreamStart;
+      const streamMs = streamEnd - contentStreamStart;
+      const estimatedFirstDeltaTokens = estimateContentTokens(
+        firstContentDeltaCharacters,
+      );
+      // Measure tokens received after the first content event over the interval
+      // from the first event to the last. This avoids counting an initial chunk
+      // as if it were generated instantaneously at t=0.
+      const streamedTokens =
+        !sawToolCall && event.message.usage.output > 0
+          ? Math.max(0, event.message.usage.output - estimatedFirstDeltaTokens)
+          : Math.max(
+              0,
+              estimateContentTokens(contentCharacters) -
+                estimatedFirstDeltaTokens,
+            );
+
+      // A single event or a sub-50ms burst has no useful observable cadence.
+      if (contentDeltaCount >= 2 && streamMs >= 50 && streamedTokens > 0) {
+        runContentTokens += streamedTokens;
+        runContentStreamMs += streamMs;
+        state = {
+          ...state,
+          tokensPerSecond: runContentTokens / (runContentStreamMs / 1000),
+        };
+      }
+    }
+
+    resetMessageTracking();
+    refresh(ctx);
+  });
+
+  pi.on("turn_end", (_event, ctx) => refresh(ctx));
+
+  // Compaction and branch moves rewrite history, so the cached percentage is
+  // stale the moment they land. Pi reports unknown occupancy until the next
+  // assistant reply, which is the honest state to show.
+  pi.on("session_compact", (_event, ctx) => refresh(ctx));
+
+  pi.on("session_tree", (_event, ctx) => refresh(ctx));
+
+  pi.on("agent_settled", (_event, ctx) => {
+    state = { ...state, generating: false };
+    refresh(ctx);
+  });
+
+  pi.on("session_shutdown", () => {
+    stopRefreshListener();
+    currentContext = undefined;
+  });
+}

package/extensions/plan-mode/bash-policy.ts

@@ -0,0 +1,313 @@
+/**
+ * Deciding whether an ARBITRARY shell command is read-only is undecidable, so
+ * this does not try. It answers a much narrower question: is this command one
+ * of a few known investigation commands, built ONLY from parts on an explicit
+ * allowlist? Anything not on a list is refused — the same fail-closed stance
+ * as PLAN_SAFE_TOOLS one level up, one level finer.
+ *
+ * It exists because planning without `git log`/`git diff`/`git status` means
+ * planning without history: `read`/`rg` show what the code says, never why it
+ * came to say it.
+ *
+ * THREAT MODEL. The adversary is a model that would start changing things
+ * before the user approved a plan — including one steered by injected text it
+ * read while investigating. It is NOT a hostile repository: `git diff` honors
+ * `diff.external` from the repo's own config, so a checkout whose `.git/config`
+ * is attacker-controlled can run a program through a command this module
+ * allows. Nothing here can prevent that, and nothing above it tries to: pi
+ * already runs the project's own tooling under the user's trust decision.
+ *
+ * EVERY LIST BELOW IS AN ALLOWLIST, deliberately. An earlier version scanned
+ * for known-dangerous flags instead, and review found four separate escapes in
+ * one pass (`git grep -O<cmd>` executes, `file --compile` writes, `tree -ao`
+ * writes, `date -s` sets the clock). A denylist over an unbounded flag space
+ * cannot be finished; a missing allowlist entry only costs a refusal.
+ */
+
+/**
+ * Any of these means the text is more than one plain command — a pipeline, a
+ * sequence, a redirect, a substitution, a glob, or a background job. Rather
+ * than parse shell (where every parser bug is a bypass), refuse outright.
+ *
+ * `\` is here because a line continuation splices in the next line; `$` covers
+ * both `$(...)` and a `$VAR` that expands into arguments never inspected here.
+ */
+const SHELL_METACHARACTERS = /[;&|<>$`\\!*?{}()[\]\n\r#]/;
+
+/**
+ * Tilde expansion, but only where a shell would actually expand it: at the
+ * start of a word. `HEAD~3` is ordinary revision syntax and must survive,
+ * while `~/notes` and `~user/x` resolve to a path this module never sees.
+ */
+const TILDE_EXPANSION = /(^|\s)~/;
+
+/** Quotes hide word boundaries from the tokenizer below, so they are refused too. */
+const QUOTES = /["']/;
+
+/**
+ * Read-only git subcommands. Absent on purpose: `config`, `stash`, `tag`,
+ * `branch`, `remote`, `reflog`, `worktree` — each has a listing form, but
+ * telling it apart from the writing form means parsing that subcommand's own
+ * grammar, which is the analysis this module refuses to do.
+ */
+const GIT_SUBCOMMANDS = new Set([
+  "log",
+  "diff",
+  "status",
+  "show",
+  "blame",
+  "shortlog",
+  "describe",
+  "rev-parse",
+  "rev-list",
+  "ls-files",
+  "ls-tree",
+  "cat-file",
+  "merge-base",
+  "name-rev",
+  "whatchanged",
+  "grep",
+]);
+
+/**
+ * Flags accepted after a git subcommand. The admission rule for this list is
+ * narrow: a flag qualifies only if it shapes OUTPUT or SELECTS commits, and
+ * never names a program, a file to write, or a path git will execute from.
+ * That is why `-O`/`--open-files-in-pager` (runs a program per match),
+ * `-o`/`--output` (writes a file) and `--contents` (reads an out-of-tree file)
+ * are absent, and why an unrecognized flag is refused rather than assumed dull.
+ *
+ * A `--flag=value` form is matched on the `--flag` part; a value given as the
+ * next word is admitted by the non-flag branch of the scan.
+ */
+const GIT_FLAGS = new Set([
+  // Patch and stat shaping.
+  "-p",
+  "--patch",
+  "--no-patch",
+  "-s",
+  "--stat",
+  "--shortstat",
+  "--numstat",
+  "--summary",
+  "--raw",
+  "--name-only",
+  "--name-status",
+  "--no-color",
+  "--color",
+  "--word-diff",
+  "-U",
+  "--unified",
+  "--no-ext-diff",
+  // Commit formatting.
+  "--oneline",
+  "--graph",
+  "--abbrev-commit",
+  "--no-abbrev-commit",
+  "--format",
+  "--pretty",
+  "--date",
+  "--relative-date",
+  "--decorate",
+  "--no-decorate",
+  // Commit selection.
+  "-n",
+  "--max-count",
+  "--skip",
+  "--since",
+  "--after",
+  "--until",
+  "--before",
+  "--author",
+  "--committer",
+  "--grep",
+  "--all",
+  "--branches",
+  "--tags",
+  "--remotes",
+  "--first-parent",
+  "--no-merges",
+  "--merges",
+  "--reverse",
+  "--follow",
+  "--topo-order",
+  "--date-order",
+  // Diff/blame comparison.
+  "--cached",
+  "--staged",
+  "-w",
+  "--ignore-all-space",
+  "--ignore-space-change",
+  "-M",
+  "-C",
+  "-L",
+  "--find-renames",
+  "--find-copies",
+  // Plumbing queries used while orienting.
+  "--abbrev-ref",
+  "--show-toplevel",
+  "--git-dir",
+  "--is-inside-work-tree",
+  "--verify",
+  "--short",
+  "--porcelain",
+  "--branch",
+  "-b",
+  "-u",
+  "--untracked-files",
+  "-t",
+  "-r",
+  "--long",
+  "--count",
+]);
+
+/** gh subcommands paired with the verbs under each that only read. */
+const GH_SUBCOMMANDS = new Map<string, ReadonlySet<string>>([
+  ["pr", new Set(["view", "list", "diff", "checks", "status"])],
+  ["issue", new Set(["view", "list", "status"])],
+  ["search", new Set(["code", "commits", "issues", "prs", "repos"])],
+]);
+
+/**
+ * Flags accepted after a gh verb. `--web` is absent on purpose: it opens the
+ * user's browser, which reads nothing and is a side effect they did not ask a
+ * planning step to cause.
+ */
+const GH_FLAGS = new Set([
+  "--json",
+  "--jq",
+  "--template",
+  "--repo",
+  "-R",
+  "--state",
+  "--limit",
+  "-L",
+  "--author",
+  "--assignee",
+  "--label",
+  "--search",
+  "--draft",
+  "--base",
+  "--head",
+  "--owner",
+  "--language",
+  "--comments",
+]);
+
+/** `-5`, `-20`: git's count shorthand, which is a number rather than a flag. */
+const NUMERIC_SHORTHAND = /^-\d+$/;
+
+export interface BashPlanDecision {
+  allowed: boolean;
+  /** Why it was refused, phrased for the model that must react to it. */
+  reason?: string;
+}
+
+const refuse = (reason: string): BashPlanDecision => ({
+  allowed: false,
+  reason,
+});
+
+/** Split `--flag=value` into the flag part the allowlists are keyed on. */
+function flagName(word: string) {
+  const eq = word.indexOf("=");
+  return eq === -1 ? word : word.slice(0, eq);
+}
+
+/**
+ * Check the argument tail. Words after `--` are pathspecs by definition and
+ * need no check; before it, a word either is an allowlisted flag or is not a
+ * flag at all (a path, ref, or pattern, none of which can execute).
+ */
+function scanArguments(
+  words: readonly string[],
+  allowed: ReadonlySet<string>,
+  program: string,
+): BashPlanDecision {
+  for (const word of words) {
+    if (word === "--") break;
+    if (!word.startsWith("-")) continue;
+    if (NUMERIC_SHORTHAND.test(word)) continue;
+    if (!allowed.has(flagName(word))) {
+      return refuse(
+        `plan mode does not recognize "${word}" as a read-only ${program} option, so it will not run this command`,
+      );
+    }
+  }
+  return { allowed: true };
+}
+
+/**
+ * Whether this exact command may run during plan mode. The contract is
+ * one-directional: `allowed: true` means proven read-only by the rules above,
+ * `allowed: false` means only "not proven", never "proven dangerous".
+ */
+export function planBashDecision(command: unknown): BashPlanDecision {
+  if (typeof command !== "string") {
+    return refuse("plan mode could not read the command to check it");
+  }
+  const text = command.trim();
+  if (!text) return refuse("plan mode received an empty command");
+
+  if (SHELL_METACHARACTERS.test(text)) {
+    return refuse(
+      "plan mode only runs a single plain command — no pipes, redirects, substitutions, globs, or chained commands",
+    );
+  }
+  if (QUOTES.test(text)) {
+    return refuse("plan mode only runs unquoted commands while planning");
+  }
+  if (TILDE_EXPANSION.test(text)) {
+    return refuse(
+      "plan mode does not run commands with `~` paths — give a path relative to the project instead",
+    );
+  }
+
+  const [program, ...rest] = text.split(/\s+/);
+
+  /*
+   * The subcommand must be the FIRST word, never "the first word that is not a
+   * flag". Skipping over flags assumes they are value-less, and git's
+   * `--namespace x` / `--attr-source x` and gh's cobra parser each consume the
+   * next word — so a skip-to-first-non-flag rule lets `git --namespace log
+   * push --force` donate the allowlisted subcommand to the flag and run the
+   * one behind it. Requiring position refuses `git -P log` too; that is a
+   * false negative, which this module is allowed to have.
+   */
+  if (program === "git") {
+    const [subcommand, ...args] = rest;
+    if (!subcommand || !GIT_SUBCOMMANDS.has(subcommand)) {
+      return refuse(
+        `plan mode allows only a read-only git subcommand immediately after "git" (log, diff, status, show, blame, …), not "${subcommand ?? "(none)"}"`,
+      );
+    }
+    return scanArguments(args, GIT_FLAGS, "git");
+  }
+
+  if (program === "gh") {
+    const [subcommand, verb, ...args] = rest;
+    const verbs = subcommand ? GH_SUBCOMMANDS.get(subcommand) : undefined;
+    if (!verbs) {
+      return refuse(
+        `plan mode allows only "gh pr", "gh issue" or "gh search" while planning, not "${subcommand ?? "(none)"}"`,
+      );
+    }
+    if (!verb || !verbs.has(verb)) {
+      return refuse(
+        `plan mode allows only read verbs after "gh ${subcommand}" (${[...verbs].join(", ")}), not "${verb ?? "(none)"}"`,
+      );
+    }
+    return scanArguments(args, GH_FLAGS, "gh");
+  }
+
+  /*
+   * Nothing else is admitted. `ls`, `cat`, `head`, `tail` and `wc` were on an
+   * earlier version of this list and are gone: plan mode already grants the
+   * `ls`, `read`, `grep` and `fd`/`rg` TOOLS, so those shell forms added no
+   * capability while each contributed its own flag grammar to get wrong
+   * (`file --compile` and `tree -ao` both write files).
+   */
+  return refuse(
+    `plan mode runs only read-only git and gh investigation commands while planning, not "${program}" — use the read, ls, grep or fd tools for files`,
+  );
+}