pi-baton 0.7.5 → 0.8.5

package/lib/run-store.ts

@@ -1,4 +1,4 @@
-import { readFile, writeFile } from "node:fs/promises";
+import { readdir, readFile, writeFile } from "node:fs/promises";
 import { randomUUID } from "node:crypto";
 import {
   ensureBatonScaffolding,
@@ -6,6 +6,7 @@ import {
   getActiveRunPointerPath,
   getRunManifestPath,
   getRunStepsDir,
+  getRunsDir,
 } from "./paths.ts";
 import type { ActiveRunPointer, RunManifest, RunState, StepRecord } from "./types.ts";
 
@@ -60,6 +61,117 @@ export async function loadActiveRun(cwd: string): Promise<RunManifest | null> {
   }
 }
 
+export const TERMINAL_HISTORY_DEFAULT_LIMIT = 10;
+export const TERMINAL_HISTORY_HARD_CAP = 20;
+export const TERMINAL_HISTORY_MAX_SCAN = 200;
+
+export interface TerminalRunHistoryResult {
+  runs: RunManifest[];
+  skippedCount: number;
+}
+
+function isCompleteManifest(value: unknown): value is RunManifest {
+  if (!value || typeof value !== "object") return false;
+
+  const manifest = value as Partial<RunManifest>;
+  return (
+    typeof manifest.id === "string" &&
+    typeof manifest.state === "string" &&
+    typeof manifest.workflowName === "string" &&
+    typeof manifest.updatedAt === "string" &&
+    typeof manifest.createdAt === "string" &&
+    typeof manifest.iteration === "number" &&
+    (manifest.lastStep === null || typeof manifest.lastStep === "string")
+  );
+}
+
+function runIdTimestamp(runId: string): string {
+  const prefix = runId.slice(0, 14);
+  return /^\d{14}$/.test(prefix) ? prefix : "";
+}
+
+function compareRunIdsNewestFirst(a: string, b: string): number {
+  const aTimestamp = runIdTimestamp(a);
+  const bTimestamp = runIdTimestamp(b);
+  if (aTimestamp && bTimestamp && aTimestamp !== bTimestamp) {
+    return bTimestamp.localeCompare(aTimestamp);
+  }
+
+  return b.localeCompare(a);
+}
+
+function compareRunsNewestFirst(a: RunManifest, b: RunManifest): number {
+  const updatedCompare = b.updatedAt.localeCompare(a.updatedAt);
+  if (updatedCompare !== 0) return updatedCompare;
+
+  const createdCompare = b.createdAt.localeCompare(a.createdAt);
+  if (createdCompare !== 0) return createdCompare;
+
+  return compareRunIdsNewestFirst(a.id, b.id);
+}
+
+export async function loadTerminalRunHistory(
+  cwd: string,
+  options: { limit?: number } = {},
+): Promise<TerminalRunHistoryResult> {
+  await ensureBatonScaffolding(cwd);
+
+  const limit = Math.min(
+    Math.max(1, options.limit ?? TERMINAL_HISTORY_DEFAULT_LIMIT),
+    TERMINAL_HISTORY_HARD_CAP,
+  );
+
+  let entries;
+  try {
+    entries = await readdir(getRunsDir(cwd), { withFileTypes: true });
+  } catch {
+    return { runs: [], skippedCount: 0 };
+  }
+
+  const runIds = entries
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name)
+    .sort(compareRunIdsNewestFirst)
+    .slice(0, TERMINAL_HISTORY_MAX_SCAN);
+
+  const scanResults = await Promise.all(
+    runIds.map(async (runId) => {
+      try {
+        const manifest = await readJson<unknown>(getRunManifestPath(cwd, runId));
+        if (!isCompleteManifest(manifest)) {
+          return { kind: "skipped" as const };
+        }
+        if (!isTerminalRunState(manifest.state)) {
+          return { kind: "non-terminal" as const };
+        }
+        return { kind: "terminal" as const, manifest };
+      } catch {
+        return { kind: "skipped" as const };
+      }
+    }),
+  );
+
+  const terminalRuns: RunManifest[] = [];
+  let skippedCount = 0;
+
+  for (const result of scanResults) {
+    if (result.kind === "skipped") {
+      skippedCount++;
+      continue;
+    }
+    if (result.kind === "terminal") {
+      terminalRuns.push(result.manifest);
+    }
+  }
+
+  terminalRuns.sort(compareRunsNewestFirst);
+
+  return {
+    runs: terminalRuns.slice(0, limit),
+    skippedCount,
+  };
+}
+
 export async function loadMostRecentTerminalRun(cwd: string): Promise<RunManifest | null> {
   const pointer = await readActiveRunPointer(cwd);
   if (!pointer?.runId) return null;

package/lib/status.ts

@@ -1,3 +1,4 @@
+import type { TerminalRunHistoryResult } from "./run-store.ts";
 import type { RunManifest } from "./types.ts";
 
 function isTerminalRunState(state: RunManifest["state"]): boolean {
@@ -21,8 +22,50 @@ export function formatStatusSummary(manifest: RunManifest): string {
     `run directory: .pi/baton/runs/${manifest.id}`,
   );
 
+  if (manifest.failureReason) {
+    lines.push(`failure: ${manifest.failureReason}`);
+  }
+
   return lines.join("\n");
 }
 
 export const NO_ACTIVE_RUN_MESSAGE =
   "No active Baton run. Start one with /baton:start after choosing a workflow and task brief.";
+
+export const NO_TERMINAL_HISTORY_MESSAGE =
+  "No completed or failed Baton runs yet. Start one with /baton:start, then /baton:run.";
+
+function formatRelativeRunDirectory(runId: string): string {
+  return `.pi/baton/runs/${runId}`.replace(/\\/g, "/");
+}
+
+function formatHistoryRow(manifest: RunManifest): string {
+  const lastStep = manifest.lastStep ?? "(none)";
+  return [
+    manifest.state,
+    manifest.id,
+    manifest.workflowName,
+    `last: ${lastStep}`,
+    `iter: ${manifest.iteration}`,
+    `updated: ${manifest.updatedAt}`,
+    formatRelativeRunDirectory(manifest.id),
+  ].join(" | ");
+}
+
+export function formatHistorySummary(result: TerminalRunHistoryResult): string {
+  const lines: string[] = [];
+
+  if (result.runs.length === 0) {
+    lines.push(NO_TERMINAL_HISTORY_MESSAGE);
+  } else {
+    for (const manifest of result.runs) {
+      lines.push(formatHistoryRow(manifest));
+    }
+  }
+
+  if (result.skippedCount > 0) {
+    lines.push(`(${result.skippedCount} run(s) skipped: unreadable or incomplete manifest)`);
+  }
+
+  return lines.join("\n");
+}

package/lib/workflow-discovery.ts

@@ -15,42 +15,82 @@ async function listYamlFiles(dir: string): Promise<string[]> {
   }
 }
 
+async function loadWorkflowItems(
+  filePaths: string[],
+  source: "user" | "builtin",
+): Promise<WorkflowListItem[]> {
+  return Promise.all(
+    filePaths.map(async (filePath) => {
+      const yamlText = await readFile(filePath, "utf8");
+      const id = basename(filePath, ".yaml");
+      const workflow = parseWorkflowDocument(yamlText, { id, source, path: filePath });
+      return { id, name: workflow.name, source, path: filePath };
+    }),
+  );
+}
+
 export async function discoverWorkflowItems(cwd: string): Promise<WorkflowListItem[]> {
-  const userFiles = await listYamlFiles(getWorkflowsDir(cwd));
-  const builtinFiles = await listYamlFiles(getPackageWorkflowsDir());
-
-  const userItems: WorkflowListItem[] = [];
-  for (const filePath of userFiles) {
-    const yamlText = await readFile(filePath, "utf8");
-    const id = basename(filePath, ".yaml");
-    const workflow = parseWorkflowDocument(yamlText, { id, source: "user", path: filePath });
-    userItems.push({ id, name: workflow.name, source: "user", path: filePath });
-  }
+  const [userFiles, builtinFiles] = await Promise.all([
+    listYamlFiles(getWorkflowsDir(cwd)),
+    listYamlFiles(getPackageWorkflowsDir()),
+  ]);
 
-  const builtinItems: WorkflowListItem[] = [];
-  for (const filePath of builtinFiles) {
-    const yamlText = await readFile(filePath, "utf8");
-    const id = basename(filePath, ".yaml");
-    const workflow = parseWorkflowDocument(yamlText, { id, source: "builtin", path: filePath });
-    builtinItems.push({ id, name: workflow.name, source: "builtin", path: filePath });
-  }
+  const [userItems, builtinItems] = await Promise.all([
+    loadWorkflowItems(userFiles, "user"),
+    loadWorkflowItems(builtinFiles, "builtin"),
+  ]);
 
   return [...userItems, ...builtinItems];
 }
 
+function isMissingFileError(error: unknown): boolean {
+  return (
+    typeof error === "object" &&
+    error !== null &&
+    "code" in error &&
+    (error as NodeJS.ErrnoException).code === "ENOENT"
+  );
+}
+
+const UNSAFE_WORKFLOW_ID_PATTERN = /[\\/\0]/;
+
+function isSafeWorkflowId(workflowId: string): boolean {
+  return (
+    workflowId.length > 0 &&
+    workflowId !== "." &&
+    workflowId !== ".." &&
+    !UNSAFE_WORKFLOW_ID_PATTERN.test(workflowId)
+  );
+}
+
 export async function loadWorkflowById(cwd: string, workflowId: string): Promise<WorkflowDefinition> {
-  const items = await discoverWorkflowItems(cwd);
-  const match = items.find((item) => item.id === workflowId);
-  if (!match) {
+  // The direct lookup builds a path from the id, so ids that could escape the
+  // workflow directories are rejected before any read is attempted.
+  if (!isSafeWorkflowId(workflowId)) {
     throw new Error(`Unknown workflow: ${workflowId}`);
   }
 
-  const yamlText = await readFile(match.path, "utf8");
-  return parseWorkflowDocument(yamlText, {
-    id: match.id,
-    source: match.source,
-    path: match.path,
-  });
+  const userPath = join(getWorkflowsDir(cwd), `${workflowId}.yaml`);
+  try {
+    const yamlText = await readFile(userPath, "utf8");
+    return parseWorkflowDocument(yamlText, { id: workflowId, source: "user", path: userPath });
+  } catch (error) {
+    if (!isMissingFileError(error)) {
+      throw error;
+    }
+  }
+
+  const builtinPath = join(getPackageWorkflowsDir(), `${workflowId}.yaml`);
+  try {
+    const yamlText = await readFile(builtinPath, "utf8");
+    return parseWorkflowDocument(yamlText, { id: workflowId, source: "builtin", path: builtinPath });
+  } catch (error) {
+    if (!isMissingFileError(error)) {
+      throw error;
+    }
+  }
+
+  throw new Error(`Unknown workflow: ${workflowId}`);
 }
 
 export async function loadWorkflowFromPath(

package/package.json

@@ -1,67 +1,67 @@
-{
-  "name": "pi-baton",
-  "version": "0.7.5",
-  "description": "Pi-native workflow baton runner with per-step model switching and isolated step context.",
-  "type": "module",
-  "engines": {
-    "node": ">=22.6.0"
-  },
-  "license": "MIT",
-  "author": "eiei114",
-  "keywords": [
-    "pi-package",
-    "pi",
-    "pi-extension",
-    "workflow",
-    "review-loop",
-    "typescript"
-  ],
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/eiei114/pi-baton.git"
-  },
-  "bugs": {
-    "url": "https://github.com/eiei114/pi-baton/issues"
-  },
-  "homepage": "https://github.com/eiei114/pi-baton#readme",
-  "files": [
-    "assets/",
-    "extensions/",
-    "lib/",
-    "agents/",
-    "workflows/",
-    "docs/",
-    "README.md",
-    "LICENSE",
-    "CHANGELOG.md"
-  ],
-  "scripts": {
-    "typecheck": "tsc --noEmit",
-    "test": "node --test tests/*.test.mjs",
-    "ci": "npm run typecheck && npm test && npm run pack:check",
-    "pack:check": "npm pack --dry-run"
-  },
-  "pi": {
-    "extensions": [
-      "./extensions"
-    ]
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "dependencies": {
-    "yaml": "^2.9.0"
-  },
-  "peerDependencies": {
-    "@earendil-works/pi-ai": "*",
-    "@earendil-works/pi-coding-agent": "*",
-    "typebox": "*"
-  },
-  "devDependencies": {
-    "@earendil-works/pi-ai": "^0.84.1",
-    "@earendil-works/pi-coding-agent": "^0.84.1",
-    "typebox": "latest",
-    "@types/node": "^26.0.1",
-    "typescript": "^7.0.2"
-  }
-}
+{
+  "name": "pi-baton",
+  "version": "0.8.5",
+  "description": "Pi-native workflow baton runner with per-step model switching and isolated step context.",
+  "type": "module",
+  "engines": {
+    "node": ">=22.6.0"
+  },
+  "license": "MIT",
+  "author": "eiei114",
+  "keywords": [
+    "pi-package",
+    "pi",
+    "pi-extension",
+    "workflow",
+    "review-loop",
+    "typescript"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/eiei114/pi-baton.git"
+  },
+  "bugs": {
+    "url": "https://github.com/eiei114/pi-baton/issues"
+  },
+  "homepage": "https://github.com/eiei114/pi-baton#readme",
+  "files": [
+    "assets/",
+    "extensions/",
+    "lib/",
+    "agents/",
+    "workflows/",
+    "docs/",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "scripts": {
+    "typecheck": "tsc --noEmit",
+    "test": "node --test tests/*.test.mjs",
+    "ci": "npm run typecheck && npm test && npm run pack:check",
+    "pack:check": "npm pack --dry-run"
+  },
+  "pi": {
+    "extensions": [
+      "./extensions"
+    ]
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "dependencies": {
+    "yaml": "^2.9.0"
+  },
+  "peerDependencies": {
+    "@earendil-works/pi-ai": "*",
+    "@earendil-works/pi-coding-agent": "*",
+    "typebox": "*"
+  },
+  "devDependencies": {
+    "@earendil-works/pi-ai": "^0.84.1",
+    "@earendil-works/pi-coding-agent": "^0.84.1",
+    "typebox": "latest",
+    "@types/node": "^26.0.1",
+    "typescript": "^7.0.2"
+  }
+}