portable-agent-layer 0.111.0 → 0.113.0

package/README.md

@@ -77,7 +77,7 @@ pal cli status        # check your setup
 | `pal cli init` | Scaffold PAL home directory and install hooks |
 | `pal cli install` | Register hooks/skills for targets |
 | `pal cli uninstall` | Remove hooks/skills for targets |
-| `pal cli update` | Update PAL (git pull or npm update) and reinstall hooks. Install asks once whether to do this on its own: when a session closes PAL checks for a release (at most hourly) and installs it, so opening PAL is never slowed. A failed update waits a day before retrying. The switch lives in the control room under Settings → Updates. On a repo install an update waits while the clone has uncommitted changes |
+| `pal cli update` | Update PAL (git pull or npm update) and reinstall hooks. Install asks once whether to do this on its own: when a session closes PAL checks for a release (at most hourly) and installs it, so opening PAL is never slowed. A failed update waits a day before retrying. The switch lives in the control room under Settings → Updates. On a repo install an update waits while the clone has uncommitted changes. `--canary` installs the latest prerelease from the `canary` branch instead; auto-update always follows the stable release |
 | `pal cli export` | Export user state (telos, memory) to a zip |
 | `pal cli import` | Import user state from a zip |
 | `pal cli status` | Show current PAL configuration |
@@ -88,6 +88,7 @@ pal cli status        # check your setup
 | `pal cli cost` | What each month was paid against its API-equivalent cost, per agent |
 | `pal cli wrapped [--year <yyyy>]` | A year of your work in numbers, read from the event log |
 | `pal cli patterns` | How you work across projects, read from the event log |
+| `pal cli work [show\|list\|open\|enter\|park\|wait\|done\|stopped\|decide\|attach\|follow-up]` | The work tree: what you are on in this project, where it stopped, what is parked or waiting, and the decisions and artifacts on each node. Detours are child nodes and `done` returns to the parent. With `dynamicContext.workTree` opted into, the active node rides along in every session and prompt, and your own commits attach to it at turn end |
 | `pal cli content preserve` | Copy every Claude Code transcript, gzipped, into `memory/content/` before Claude Code deletes it (30 days by default). Runs on its own whenever a session closes; the content store never leaves the machine, so `export` skips it |
 | `pal cli events discord-nag <sent\|answered>` | For a bot outside PAL: record a nag it sent (`--kind <kind>`), or the answer to one and how long it took (`--after-sec <n>`), in the local event log |
 | `pal cli infer` | One model call for scripts and bots, on the active agent's route: prompt on stdin, reply on stdout. `--tier small\|medium\|large\|flagship` (on Claude: Haiku, Sonnet, Opus, Fable; on Codex: Luna, Sol, Sol at high effort, Astra; on Antigravity: Flash at low, medium and high effort, and no flagship; an agent without the tier asked refuses it), `--system <file>`, `--schema <file>` for a JSON reply checked against it, `--timeout <seconds>`. The call loads no PAL hooks or context; exits 1 with the reason when no route answers |

package/assets/schema/pal-settings.schema.json

@@ -74,6 +74,14 @@
           "type": "boolean",
           "description": "One line with every prompt saying whether the work in the current directory is committed, pushed and released; a registered project without git is named as such."
         },
+        "workTree": {
+          "type": "boolean",
+          "description": "Opt-in, off by default until 1.0. The work tree (pal cli work): the active node, the detours it sits inside, parked work and what waits on the user at session start and after compaction, one line of it with every prompt, and new commits and branches attached to the active node at the end of a turn."
+        },
+        "workTreeGate": {
+          "type": "boolean",
+          "description": "Opt-in, off by default until 1.0. Send a turn back when it committed, made a branch, opened a PR or published an artifact without recording it in the work tree (pal cli work). Needs workTree."
+        },
         "dueReminders": {
           "type": "boolean",
           "description": "Opt-in, off by default until 1.0. Due maintenance reminders (learning analysis, relationship reflect) with every prompt until a reply names their command; then quiet until the next day."

package/assets/templates/AGENTS.md.template

@@ -56,6 +56,7 @@ Start your response with the following header in this mode:
 - **Mandatory output format** — Every response MUST use exactly one of the output formats above (ALGORITHM, NATIVE, or MINIMAL). No freeform output.
 - **Response format before questions** — Always complete the current response format output FIRST, then invoke AskUserQuestion at the end.
 - **Named project → resume first** — Whenever the user references a project by name in ANY mode, run `pal cli project resume <slug>` before any file search or task execution. The project record has paths, context, and handoff notes that make manual searching unnecessary.
+{{IF workTree}}- **Keep the work tree true** — Record work in the tree with `pal cli work` as it happens, not at the end: `open` a node for new work (`--root` when it is unrelated), update `stopped` when the state moves, `decide` when a choice is settled, `attach` what the work produced, `done` when it is finished. When the user switches topic mid-work, `park --stopped "…"` the current node before starting the new one. Once a scope has work, the `Work:` line in each prompt shows where you are.
 
 ---
 

package/assets/templates/pal-settings.json

@@ -27,6 +27,8 @@
     "skillMatching": true,
     "wallClock": true,
     "repoState": true,
+    "workTree": false,
+    "workTreeGate": false,
     "dueReminders": false,
     "interactionAwareness": true,
     "reactionSampling": true,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "portable-agent-layer",
-  "version": "0.111.0",
+  "version": "0.113.0",
   "description": "PAL — Portable Agent Layer: persistent personal context for AI coding assistants",
   "type": "module",
   "bin": {

package/src/cli/index.ts

@@ -49,7 +49,7 @@ const tree = cliTree({
     process.exit(await install(resolveTargets(argv), argv));
   },
   uninstall: ({ argv }) => uninstall(argv),
-  update: () => update(),
+  update: ({ values }) => update(values.canary === true),
   export: ({ argv }) => exportState(argv),
   import: ({ argv }) => importState(argv),
   status: () => status(),
@@ -553,15 +553,23 @@ async function importState(args: string[]) {
   log.info("Run 'pal cli install' to re-register hooks.");
 }
 
-async function update() {
-  const { checkForUpdate, clearUpdateCache } = await import(
+async function update(canary: boolean) {
+  const { checkCanary, checkForUpdate, clearUpdateCache, isRepoMode } = await import(
     "../hooks/handlers/update-check"
   );
   const { reinstallInFreshProcess } = await import("./reinstall");
-  const { runUpdate } = await import("./update-flow");
+  const { CANARY_NEEDS_PACKAGE, runUpdate, updateCheck } = await import("./update-flow");
+  const check = updateCheck(canary, isRepoMode(), {
+    stable: () => checkForUpdate(true),
+    canary: checkCanary,
+  });
+  if (!check) {
+    log.error(CANARY_NEEDS_PACKAGE);
+    process.exit(1);
+  }
   process.exit(
     await runUpdate({
-      check: () => checkForUpdate(true),
+      check,
       reinstall: (env) => {
         clearUpdateCache();
         return reinstallInFreshProcess(process.argv[1], env);

package/src/cli/tree.ts

@@ -30,6 +30,7 @@ import { serverCommand } from "./server";
 import { skillCommand } from "./skill";
 import { subagentCommand } from "./subagent";
 import { usageCommand } from "./usage";
+import { workCommand } from "./work";
 import { wrappedCommand } from "./wrapped";
 
 type Handler = Leaf["run"];
@@ -108,7 +109,17 @@ function adminCommands(admin: AdminHandlers): Record<string, Leaf | Group> {
       options: agentOptions("Uninstall from"),
       run: admin.uninstall,
     }),
-    update: leaf({ summary: "Update PAL (git pull or bun add -g)", run: admin.update }),
+    update: leaf({
+      summary: "Update PAL (git pull or bun add -g)",
+      options: {
+        canary: {
+          type: "boolean",
+          description:
+            "Install the latest canary prerelease instead of the stable release",
+        },
+      },
+      run: admin.update,
+    }),
     export: leaf({
       summary: "Export your state to a zip",
       args: "[path]",
@@ -171,6 +182,7 @@ export function cliTree(admin: AdminHandlers): Group {
       ledger: ledgerCommand,
       rule: ruleCommand,
       correction: correctionCommand,
+      work: workCommand,
       server: serverCommand,
       skill: skillCommand,
       subagent: subagentCommand,

package/src/cli/update-flow.ts

@@ -33,6 +33,21 @@ export interface UpdateSteps {
   run?: Run;
 }
 
+export const CANARY_NEEDS_PACKAGE =
+  "--canary installs from npm. A repo install follows its git checkout: check out the canary branch there instead.";
+
+type Check = UpdateSteps["check"];
+
+/** Null when --canary is asked of a repo install, which has no npm channel to follow. */
+export function updateCheck(
+  canary: boolean,
+  repoMode: boolean,
+  checks: { stable: Check; canary: Check }
+): Check | null {
+  if (!canary) return checks.stable;
+  return repoMode ? null : checks.canary;
+}
+
 /** `bun update -g` keeps the caret range, and on 0.x a caret allows only patch bumps. */
 export function downloadCommand(
   update: UpdateCache

package/src/cli/whats-new.ts

@@ -15,16 +15,22 @@ export interface WhatsNew {
 
 const SHOWN = 3;
 
-function parts(version: string): number[] {
-  return version.replace(/^v/, "").split(".").map(Number);
+function bare(version: string): string {
+  return version.replace(/^v/, "");
 }
 
 export function newer(a: string, b: string): boolean {
-  const [x, y] = [parts(a), parts(b)];
-  for (let i = 0; i < 3; i++) {
-    if ((x[i] ?? 0) !== (y[i] ?? 0)) return (x[i] ?? 0) > (y[i] ?? 0);
-  }
-  return false;
+  return Bun.semver.order(bare(a), bare(b)) === 1;
+}
+
+function isPrerelease(version: string): boolean {
+  return bare(version).includes("-");
+}
+
+/** A stable release's notes already cover the canaries before it, so a stable update skips them. */
+function inRange(tag: string, from: string, to: string): boolean {
+  if (isPrerelease(tag) && !isPrerelease(to)) return false;
+  return newer(tag, from) && !newer(tag, to);
 }
 
 /** "* **rating:** confirm corrections ([abc](url))" reads "Confirm corrections". */
@@ -71,7 +77,7 @@ export function summarizeReleases(
   slug: string
 ): WhatsNew | null {
   const items = releases
-    .filter((r) => newer(r.tag_name, from) && !newer(r.tag_name, to))
+    .filter((r) => inRange(r.tag_name, from, to))
     .flatMap((r) => releaseNotes(r.body ?? ""));
   if (items.length === 0) return null;
   return {

package/src/cli/work.ts

@@ -0,0 +1,344 @@
+/**
+ * pal cli work — the work tree: what is active, what is parked and where it
+ * stopped, the decisions and artifacts of each piece of work.
+ */
+
+import {
+  ARTIFACT_KINDS,
+  type ArtifactKind,
+  appendEvent,
+  findNode,
+  newNodeId,
+  readTree,
+  type ScopeTree,
+  scopeOf,
+  type WorkNode,
+} from "../hooks/lib/work-tree";
+import {
+  renderNodeDetail,
+  renderSessionContext,
+  renderTreeList,
+  suffix,
+} from "../hooks/lib/work-tree-render";
+import { group, leaf, runCommand, UsageError } from "../tools/lib/command";
+
+const SCOPE = {
+  type: "string",
+  description: "Project or folder the work belongs to (default: the current one)",
+} as const;
+const NODE = {
+  type: "string",
+  description: "Node id or unambiguous prefix (default: the active node)",
+} as const;
+
+class NodeError extends Error {}
+
+function scopeFrom(values: { scope?: string }): string {
+  return values.scope ?? scopeOf(process.cwd());
+}
+
+function requireText(text: string | undefined, what: string): string {
+  if (!text?.trim()) throw new UsageError(`${what} is required`);
+  return text.trim();
+}
+
+function targetNode(tree: ScopeTree, idOrPrefix: string | undefined): WorkNode {
+  if (idOrPrefix) {
+    const node = findNode(tree, idOrPrefix);
+    if (!node)
+      throw new NodeError(`No single node matches "${idOrPrefix}" in ${tree.scope}`);
+    return node;
+  }
+  const active = tree.active ? tree.nodes.get(tree.active) : undefined;
+  if (!active)
+    throw new NodeError(
+      `No active node in ${tree.scope}; pass --node, or open or enter one first`
+    );
+  return active;
+}
+
+function guarded(run: () => void): number {
+  try {
+    run();
+    return 0;
+  } catch (err) {
+    if (!(err instanceof NodeError)) throw err;
+    console.error(err.message);
+    return 1;
+  }
+}
+
+function record<T extends Parameters<typeof appendEvent>[2]>(
+  values: { scope?: string; node?: string },
+  type: T,
+  payload: Parameters<typeof appendEvent<T>>[3],
+  done: (node: WorkNode) => string
+): number {
+  return guarded(() => {
+    const scope = scopeFrom(values);
+    const node = targetNode(readTree(scope), values.node);
+    appendEvent(scope, node.id, type, payload);
+    console.log(done(node));
+  });
+}
+
+function parentFor(tree: ScopeTree, under: string | undefined, root: boolean) {
+  if (root) return null;
+  if (under) return targetNode(tree, under).id;
+  return tree.active;
+}
+
+function optionalIsc(isc: string | undefined): number | undefined {
+  if (isc === undefined) return undefined;
+  const parsed = Number(isc);
+  if (!Number.isInteger(parsed) || parsed < 1)
+    throw new UsageError(`--isc must be an ISC number, got "${isc}"`);
+  return parsed;
+}
+
+function cmdOpen(
+  title: string | undefined,
+  values: {
+    scope?: string;
+    under?: string;
+    root?: boolean;
+    isc?: string;
+    commitment?: string;
+  }
+): number {
+  const text = requireText(title, "A title");
+  const isc = optionalIsc(values.isc);
+  return guarded(() => {
+    const scope = scopeFrom(values);
+    const tree = readTree(scope);
+    const parent = parentFor(tree, values.under, values.root === true);
+    const id = newNodeId();
+    const links = {
+      ...(isc !== undefined && { isc }),
+      ...(values.commitment && { commitment: values.commitment }),
+    };
+    appendEvent(scope, id, "open", { title: text, parent, links });
+    const under = parent ? ` under ${tree.nodes.get(parent)?.title ?? parent}` : "";
+    console.log(`Opened ${text} [${id}]${under}; it is now active.`);
+  });
+}
+
+function backTo(scope: string): string {
+  const tree = readTree(scope);
+  const active = tree.active ? tree.nodes.get(tree.active) : undefined;
+  if (!active) return "No node is active now.";
+  return `Back to ${active.title} [${active.id}]${suffix(", stopped at: ", active.stoppedAt)}.`;
+}
+
+function cmdDone(values: { scope?: string; node?: string; summary?: string }): number {
+  return guarded(() => {
+    const scope = scopeFrom(values);
+    const node = targetNode(readTree(scope), values.node);
+    appendEvent(
+      scope,
+      node.id,
+      "done",
+      values.summary ? { summary: values.summary } : {}
+    );
+    console.log(`Done: ${node.title} [${node.id}]. ${backTo(scope)}`);
+  });
+}
+
+function artifactKind(kind: string | undefined): ArtifactKind {
+  if (kind && (ARTIFACT_KINDS as readonly string[]).includes(kind))
+    return kind as ArtifactKind;
+  throw new UsageError(
+    `kind must be one of ${ARTIFACT_KINDS.join(", ")}, got "${kind ?? ""}"`
+  );
+}
+
+function cmdShow(values: { scope?: string; node?: string; json?: boolean }): number {
+  return guarded(() => {
+    const tree = readTree(scopeFrom(values));
+    if (!values.node && !tree.active) {
+      console.log(
+        renderSessionContext(tree) || `No work recorded for ${tree.scope} yet.`
+      );
+      return;
+    }
+    const node = targetNode(tree, values.node);
+    console.log(
+      values.json ? JSON.stringify(node, null, 2) : renderNodeDetail(tree, node)
+    );
+  });
+}
+
+function cmdList(values: { scope?: string; all?: boolean; json?: boolean }): number {
+  const tree = readTree(scopeFrom(values));
+  if (values.json) {
+    console.log(JSON.stringify({ ...tree, nodes: [...tree.nodes.values()] }, null, 2));
+    return 0;
+  }
+  console.log(renderTreeList(tree, values.all === true));
+  return 0;
+}
+
+export const workCommand = group({
+  summary: "The work tree: what is active, parked, waiting, and where each piece stopped",
+  fallback: "show",
+  commands: {
+    show: leaf({
+      summary: "The active node in full, or the whole picture when none is active",
+      options: {
+        scope: SCOPE,
+        node: NODE,
+        json: { type: "boolean", description: "As JSON" },
+      },
+      run: ({ values }) => cmdShow(values),
+    }),
+    list: leaf({
+      summary: "Every open node as a tree",
+      options: {
+        scope: SCOPE,
+        all: { type: "boolean", description: "Include finished nodes" },
+        json: { type: "boolean", description: "As JSON" },
+      },
+      run: ({ values }) => cmdList(values),
+    }),
+    open: leaf({
+      summary: "Open a node and make it active (a child of the active node by default)",
+      args: "<title...>",
+      options: {
+        scope: SCOPE,
+        under: { type: "string", description: "Parent node id or prefix" },
+        root: {
+          type: "boolean",
+          description: "Open at the top level, not under the active node",
+        },
+        isc: { type: "string", description: "The project ISC this node works on" },
+        commitment: {
+          type: "string",
+          description: "The commitment id this node fulfils",
+        },
+      },
+      run: ({ positionals, values }) => cmdOpen(positionals.join(" "), values),
+    }),
+    enter: leaf({
+      summary: "Make a node active, parking the one that was",
+      args: "<node>",
+      options: { scope: SCOPE },
+      run: ({ positionals, values }) =>
+        record(
+          { ...values, node: requireText(positionals[0], "A node") },
+          "enter",
+          {},
+          (n) => `Entered ${n.title} [${n.id}]${suffix(", stopped at: ", n.stoppedAt)}.`
+        ),
+    }),
+    park: leaf({
+      summary: "Park a node, saying where it stopped",
+      options: {
+        scope: SCOPE,
+        node: NODE,
+        stopped: { type: "string", description: "Where it stopped, to resume from" },
+      },
+      run: ({ values }) =>
+        record(
+          values,
+          "park",
+          values.stopped ? { stoppedAt: values.stopped } : {},
+          (n) => `Parked ${n.title} [${n.id}].`
+        ),
+    }),
+    wait: leaf({
+      summary: "Mark a node as waiting on the user",
+      args: "<waits-on...>",
+      options: { scope: SCOPE, node: NODE },
+      run: ({ positionals, values }) =>
+        record(
+          values,
+          "wait",
+          { on: requireText(positionals.join(" "), "What it waits on") },
+          (n) => `${n.title} [${n.id}] is waiting on the user.`
+        ),
+    }),
+    done: leaf({
+      summary: "Finish a node; a finished detour hands the work back to its parent",
+      options: {
+        scope: SCOPE,
+        node: NODE,
+        summary: { type: "string", description: "One line on what it ended with" },
+      },
+      run: ({ values }) => cmdDone(values),
+    }),
+    stopped: leaf({
+      summary: "Record where the work stands now",
+      args: "<text...>",
+      options: { scope: SCOPE, node: NODE },
+      run: ({ positionals, values }) =>
+        record(
+          values,
+          "stopped",
+          { text: requireText(positionals.join(" "), "Where it stopped") },
+          (n) => `Stopped-at recorded on ${n.title} [${n.id}].`
+        ),
+    }),
+    decide: leaf({
+      summary: "Record a decision on a node",
+      args: "<decision...>",
+      options: {
+        scope: SCOPE,
+        node: NODE,
+        why: { type: "string", description: "The reason" },
+      },
+      run: ({ positionals, values }) =>
+        record(
+          values,
+          "decide",
+          {
+            text: requireText(positionals.join(" "), "A decision"),
+            ...(values.why && { why: values.why }),
+          },
+          (n) => `Decision recorded on ${n.title} [${n.id}].`
+        ),
+    }),
+    attach: leaf({
+      summary: `Attach an artifact to a node (${ARTIFACT_KINDS.join(", ")})`,
+      args: "<kind> <ref...>",
+      options: {
+        scope: SCOPE,
+        node: NODE,
+        label: { type: "string", description: "What it is" },
+      },
+      run: ({ positionals, values }) =>
+        record(
+          values,
+          "attach",
+          {
+            kind: artifactKind(positionals[0]),
+            ref: requireText(positionals.slice(1).join(" "), "A ref"),
+            ...(values.label && { label: values.label }),
+          },
+          (n) => `Attached to ${n.title} [${n.id}].`
+        ),
+    }),
+    "follow-up": leaf({
+      summary: "Record a follow-up on a node",
+      args: "<text...>",
+      options: {
+        scope: SCOPE,
+        node: NODE,
+        due: { type: "string", description: "When it is due, such as 2026-10-25" },
+      },
+      run: ({ positionals, values }) =>
+        record(
+          values,
+          "follow-up",
+          {
+            text: requireText(positionals.join(" "), "A follow-up"),
+            ...(values.due && { due: values.due }),
+          },
+          (n) => `Follow-up recorded on ${n.title} [${n.id}].`
+        ),
+    }),
+  },
+});
+
+export function runWork(args: string[]): Promise<number> {
+  return runCommand(workCommand, args, ["pal", "cli", "work"]);
+}

package/src/hooks/StopOrchestrator.ts

@@ -20,6 +20,7 @@ import { logError } from "./lib/log";
 import { isPalSpawnedInference } from "./lib/spawn-guard";
 import { readStdinJSON } from "./lib/stdin";
 import { type StopTurnPayload, stopTurn } from "./lib/stop";
+import { stopWorkTree } from "./lib/work-tree-gate";
 
 // Recursion guard — spawned inference subprocesses must not record session
 // learning, ratings, or handoffs from their throwaway transcript.
@@ -62,4 +63,13 @@ try {
 } catch (err) {
   logError("StopOrchestrator:adaptation-rules", err);
 }
+try {
+  const sendBack = stopWorkTree(payload);
+  if (sendBack) {
+    process.stdout.write(stopBlockResponse(sendBack));
+    process.exit(0);
+  }
+} catch (err) {
+  logError("StopOrchestrator:work-tree", err);
+}
 await stopTurn(payload);

package/src/hooks/handlers/inject-retrieval.ts

@@ -22,6 +22,7 @@ import { isEnabled } from "../lib/settings";
 import { getSkillReminder } from "../lib/skill-match";
 import { getSteeringReminder } from "../lib/steering";
 import { getWallClockReminder } from "../lib/wall-clock";
+import { workTreePromptLine } from "../lib/work-tree-context";
 
 const BUDGET_MS = 250;
 
@@ -88,6 +89,7 @@ export async function getPromptContext(
     getWallClockReminder(),
     userText && withinBudget(() => promptRulesReminder(userText, sessionId), BUDGET_MS),
     withinBudget(() => getRepoStateReminder(), BUDGET_MS),
+    withinBudget(() => workTreePromptLine(userText), BUDGET_MS),
     userText && withinBudget(() => observeTurn(userText, sessionId), BUDGET_MS),
     withinBudget(() => dueNudgeReminder(), BUDGET_MS),
     userText && getSteeringReminder(userText),

package/src/hooks/handlers/update-check.ts

@@ -139,12 +139,18 @@ export function isNewerRelease(latest: string, current: string): boolean {
   return Bun.semver.order(latest, current) === 1;
 }
 
-async function checkNpm(): Promise<UpdateCache> {
+/** latest is the stable release from main; canary is the prerelease from the canary branch. */
+export type Channel = "latest" | "canary";
+
+export async function checkNpm(
+  channel: Channel = "latest",
+  fetchImpl: typeof fetch = fetch
+): Promise<UpdateCache> {
   const current = getInstalledVersion();
 
   try {
-    const response = await fetch(
-      "https://registry.npmjs.org/portable-agent-layer/latest",
+    const response = await fetchImpl(
+      `https://registry.npmjs.org/portable-agent-layer/${channel}`,
       { signal: AbortSignal.timeout(5000) }
     );
 
@@ -170,6 +176,11 @@ async function checkNpm(): Promise<UpdateCache> {
   }
 }
 
+/** The canary check is never cached: the cache feeds the stable update notice. */
+export function checkCanary(fetchImpl: typeof fetch = fetch): Promise<UpdateCache> {
+  return checkNpm("canary", fetchImpl);
+}
+
 /** Run update check. Caches result. Use force=true to skip cache (e.g. for `pal cli update`). */
 export async function checkForUpdate(force = false): Promise<UpdateCache> {
   if (!force) {

package/src/hooks/lib/claim-check.ts

@@ -139,21 +139,22 @@ function isUserPrompt(entry: TranscriptLine): boolean {
 
 const ran = (input: unknown) => JSON.stringify(input ?? {});
 
-function commandsIn(entry: TranscriptLine): string[] {
+function callsIn(entry: TranscriptLine, tools: ReadonlySet<string>): string[] {
   if (entry.type === "PLANNER_RESPONSE")
     return toolCallsOf(entry)
-      .filter((call) => COMMAND_TOOLS.has(call.name ?? ""))
+      .filter((call) => tools.has(call.name ?? ""))
       .map((call) => ran(call.args));
   if (entry.type === "assistant")
     return blocks(entry.message?.content)
-      .filter((b) => b.type === "tool_use" && COMMAND_TOOLS.has(b.name ?? ""))
+      .filter((b) => b.type === "tool_use" && tools.has(b.name ?? ""))
       .map((b) => ran(b.input));
   const call = entry.payload;
   if (entry.type !== "response_item" || !call) return [];
   const input = call.input ?? call.arguments ?? call.action;
-  if (call.type === "local_shell_call") return [ran(input)];
+  if (call.type === "local_shell_call")
+    return tools === COMMAND_TOOLS ? [ran(input)] : [];
   const isCall = call.type === "function_call" || call.type === "custom_tool_call";
-  return isCall && COMMAND_TOOLS.has(call.name ?? "") ? [ran(input)] : [];
+  return isCall && tools.has(call.name ?? "") ? [ran(input)] : [];
 }
 
 function isTurnEntry(entry: TranscriptLine): boolean {
@@ -162,17 +163,24 @@ function isTurnEntry(entry: TranscriptLine): boolean {
   );
 }
 
-/** What each command this turn ran. Null when no line reads as a turn, so an
- *  unknown transcript format never counts as none. */
-export function commandsThisTurn(lines: string[]): string[] | null {
+/** The input of each call this turn made to one of the tools. Null when no line reads
+ *  as a turn, so an unknown transcript format never counts as none. */
+export function callsThisTurn(
+  lines: string[],
+  tools: ReadonlySet<string>
+): string[] | null {
   const entries = lines.map(parsed).filter((e): e is TranscriptLine => e !== null);
   if (!entries.some(isTurnEntry)) return null;
-  let commands: string[] = [];
+  let calls: string[] = [];
   for (const entry of entries) {
-    if (isUserPrompt(entry)) commands = [];
-    commands.push(...commandsIn(entry));
+    if (isUserPrompt(entry)) calls = [];
+    calls.push(...callsIn(entry, tools));
   }
-  return commands;
+  return calls;
+}
+
+export function commandsThisTurn(lines: string[]): string[] | null {
+  return callsThisTurn(lines, COMMAND_TOOLS);
 }
 
 function isBacked(claim: string, commands: string[]): boolean {