pi-workflow-engine 1.1.0 → 1.2.0

package/.pi/extensions/pi-workflow-engine/src/progress.ts

@@ -69,7 +69,9 @@ export class ProgressTracker {
   private readonly lanes = new Map<string, WorkflowLaneItem[]>();
   private readonly laneOverflow = new Map<string, number>();
   private readonly rowsById = new Map<number, AgentRow>();
-  private readonly agentCounts: Record<AgentRowStatus, number> = { queued: 0, running: 0, done: 0, failed: 0 };
+  /** How to abort each running row's agent; never part of a snapshot, so it is never persisted. */
+  private readonly skipHandlers = new Map<number, () => void>();
+  private readonly agentCounts: Record<AgentRowStatus, number> = { queued: 0, running: 0, done: 0, failed: 0, skipped: 0 };
   private readonly startedAt = Date.now();
   private readonly laneItemLimit = laneItemLimitFromEnv();
   private doneAt: number | undefined;
@@ -168,12 +170,13 @@ export class ProgressTracker {
     return id;
   }
 
-  agentStart(id: number): void {
+  agentStart(id: number, skip?: () => void): void {
     const row = this.rowsById.get(id);
     if (row) {
       this.transitionAgentStatus(row, "running");
       row.startedAt = Date.now();
       row.error = undefined;
+      if (skip) this.skipHandlers.set(id, skip);
     }
     this.publish();
   }
@@ -188,8 +191,9 @@ export class ProgressTracker {
   }
 
   agentDone(id: number): void {
+    this.skipHandlers.delete(id);
     const row = this.rowsById.get(id);
-    if (row && row.status !== "failed") {
+    if (row && row.status !== "failed" && row.status !== "skipped") {
       this.transitionAgentStatus(row, "done");
       row.doneAt = Date.now();
     }
@@ -197,6 +201,7 @@ export class ProgressTracker {
   }
 
   agentFailed(id: number, error: unknown): void {
+    this.skipHandlers.delete(id);
     const row = this.rowsById.get(id);
     if (row) {
       this.transitionAgentStatus(row, "failed");
@@ -206,6 +211,28 @@ export class ProgressTracker {
     this.publish();
   }
 
+  agentSkipped(id: number): void {
+    this.skipHandlers.delete(id);
+    const row = this.rowsById.get(id);
+    if (row) {
+      this.transitionAgentStatus(row, "skipped");
+      row.doneAt = Date.now();
+    }
+    this.publish();
+  }
+
+  /**
+   * Abort one running agent at the user's request (the inspector's skip key); false when the row is
+   * no longer running. The row turns `skipped` once the agent's session has wound down.
+   */
+  skipAgent(id: number): boolean {
+    const skip = this.skipHandlers.get(id);
+    if (!skip || this.rowsById.get(id)?.status !== "running") return false;
+    this.skipHandlers.delete(id);
+    skip();
+    return true;
+  }
+
   updateUsage(snapshot: WorkflowUsageSnapshot): void {
     this.usageSnapshot = snapshot;
     this.publish();
@@ -238,7 +265,8 @@ export class ProgressTracker {
       running: this.agentCounts.running,
       done: this.agentCounts.done,
       failed: this.agentCounts.failed,
-      total: this.agentCounts.queued + this.agentCounts.running + this.agentCounts.done + this.agentCounts.failed,
+      skipped: this.agentCounts.skipped,
+      total: this.agentCounts.queued + this.agentCounts.running + this.agentCounts.done + this.agentCounts.failed + this.agentCounts.skipped,
     };
   }
 

package/.pi/extensions/pi-workflow-engine/src/prompt-sections.ts

@@ -0,0 +1,15 @@
+import type { BeforeAgentStartEventResult, NormalizedBuildSystemPromptOptions } from "@earendil-works/pi-coding-agent";
+
+type PromptSectionOptions = Pick<NormalizedBuildSystemPromptOptions, "sections" | "forceSystemPrompt">;
+
+/**
+ * Finish adding the `name` section from a `before_agent_start` handler. Normally the section in
+ * `options.sections` is enough and pi appends it as a patch. An earlier handler that forced the whole
+ * prompt makes pi render no sections, so the section is appended to that text instead; pi hands the
+ * returned prompt to later handlers as their `forceSystemPrompt`, so several sections chain.
+ */
+export function appendSectionToForcedPrompt(options: PromptSectionOptions, name: string): BeforeAgentStartEventResult | undefined {
+  const text = options.sections[name];
+  if (options.forceSystemPrompt === undefined || text === undefined) return undefined;
+  return { systemPrompt: `${options.forceSystemPrompt}\n\n<${name}>\n${text}\n</${name}>` };
+}

package/.pi/extensions/pi-workflow-engine/src/research-evidence.ts

@@ -29,7 +29,8 @@ export function normalizeResearchLanes(plan: ResearchPlan): ResearchLane[] {
   return lanes;
 }
 
-export function buildClaimCandidates(results: readonly ResearchLaneResult[]): ResearchClaimCandidate[] {
+/** Distinct claims, most important first, bounded to {@link MAX_VERIFICATION_CLAIMS}; `overCap` counts the claims cut. */
+export function buildClaimCandidates(results: readonly ResearchLaneResult[]): { candidates: ResearchClaimCandidate[]; overCap: number } {
   const byClaim = new Map<string, { claim: string; importance: ResearchEvidence["importance"]; evidence: ResearchEvidence[] }>();
   for (const item of results.flatMap((result) => result.evidence.map(sanitizeEvidence).filter(isDefined))) {
     const key = item.claim.toLowerCase();
@@ -41,9 +42,8 @@ export function buildClaimCandidates(results: readonly ResearchLaneResult[]): Re
     if (IMPORTANCE_RANK[item.importance] < IMPORTANCE_RANK[current.importance]) current.importance = item.importance;
     current.evidence = dedupeEvidence([...current.evidence, item]);
   }
-  return [...byClaim.values()]
-    .sort((left, right) => IMPORTANCE_RANK[left.importance] - IMPORTANCE_RANK[right.importance])
-    .slice(0, MAX_VERIFICATION_CLAIMS);
+  const ranked = [...byClaim.values()].sort((left, right) => IMPORTANCE_RANK[left.importance] - IMPORTANCE_RANK[right.importance]);
+  return { candidates: ranked.slice(0, MAX_VERIFICATION_CLAIMS), overCap: Math.max(0, ranked.length - MAX_VERIFICATION_CLAIMS) };
 }
 
 export function sanitizeVerification(

package/.pi/extensions/pi-workflow-engine/src/resume-context.ts

@@ -438,7 +438,7 @@ export async function captureWorkflowResumeContext(
   if (mod.source.kind === "unverifiable") {
     return unverifiableWorkflowResumeContext(mod.meta.name, mod.source.reason);
   }
-  if (mod.source.kind === "fingerprint") {
+  if (mod.source.kind === "fingerprint" || mod.source.selfContained) {
     return mod.source.fingerprint.length > 0
       ? { kind: "verified", name: mod.meta.name, sourceFingerprint: mod.source.fingerprint }
       : unverifiableWorkflowResumeContext(mod.meta.name, "workflow source fingerprint is empty");

package/.pi/extensions/pi-workflow-engine/src/types.ts

@@ -16,14 +16,23 @@ import type { WorkflowRunState } from "./workflow-run-record.ts";
 
 export type { WorkflowLaneItemStatus } from "./progress-types.ts";
 
-/** A reference to a registered workflow by name. */
-export type WorkflowRef = string;
+/** A registered workflow by name, or an inline-format script file under the workflow cwd. */
+export type WorkflowRef = string | { readonly scriptPath: string };
+
+/** One declared phase of a workflow. */
+export interface WorkflowPhaseMeta {
+  title: string;
+  /** Profile for agents that pass this title as `phase` and set neither `model` nor `profile`. */
+  profile?: WorkflowModelProfileName;
+}
 
 /** Metadata every workflow module must export. */
 export interface WorkflowMeta {
   name: string;
   description: string;
-  phases?: Array<{ title: string }>;
+  /** When a host model should choose this workflow; listed in the system prompt's workflow catalog. */
+  whenToUse?: string;
+  phases?: WorkflowPhaseMeta[];
 }
 
 export interface WorkflowRunStats {
@@ -39,12 +48,16 @@ export interface WorkflowRunMetadata {
   readonly resumedFromRunId?: string;
   readonly journalPath: string;
   readonly recordPath: string;
+  /** The inline run's persisted script; absent for registered workflows or when the write failed. */
+  readonly scriptPath?: string;
 }
 
 export interface WorkflowBackgroundOrigin {
   /** Stable pi session id used to route and deduplicate completion delivery. */
   readonly sessionId: string;
   readonly requestedAt: number;
+  /** Deliver the completion with a new agent turn, because Dynamax was active when the run started. */
+  readonly wakeOnComplete?: boolean;
 }
 
 export interface WorkflowRunOptions {
@@ -101,6 +114,8 @@ export interface WorkflowProgressSource {
   snapshot(): WorkflowProgressSnapshot;
   /** Durable lifecycle state of the run, so a finished snapshot can tell completed from failed. */
   readonly state?: () => WorkflowRunState;
+  /** Skip one running agent by its progress row id; false when it is no longer running. */
+  readonly skipAgent?: (agentId: number) => boolean;
 }
 
 /** Options for a single `agent()` call. */
@@ -226,12 +241,14 @@ export interface WorkflowApi {
    */
   classify(context: ClassifierContext, opts?: ClassifyOptions): Promise<Record<string, ClassifierAnswer>>;
   /**
-   * Run another registered workflow inline as a sub-step and return its result. The child shares
+   * Run another workflow inline as a sub-step and return its result: a registered workflow by name, or
+   * an inline-format script file via `{ scriptPath }` relative to the workflow cwd. The child shares
    * this run's concurrency cap, abort signal, and perf sink. Nests one level only: calling
-   * `workflow()` from within a sub-workflow rejects. Rejects on unknown name — catch it to handle
-   * a missing sub-workflow gracefully.
+   * `workflow()` from within a sub-workflow rejects. Rejects on an unknown name, an unreadable
+   * scriptPath, or a script compile error — catch it to handle a missing sub-workflow gracefully.
+   * `args` is the child's input: a string or any JSON value, read there as `api.input` and `api.args`.
    */
-  workflow(ref: WorkflowRef, args?: string): Promise<unknown>;
+  workflow(ref: WorkflowRef, args?: unknown): Promise<unknown>;
   /**
    * Run every thunk concurrently and wait for all (a barrier). Recoverable thunk
    * failures become null slots by default; settled mode retains serialisable errors.
@@ -248,8 +265,13 @@ export interface WorkflowApi {
   log(message: string): void;
   /** Emit a structured progress event for native workflow UI surfaces. */
   progress(event: WorkflowProgressEvent): void;
-  /** Raw argument string passed after the workflow name. */
+  /**
+   * The invocation's arguments as text: the string passed after the workflow name, a non-string tool or
+   * `workflow()` argument as JSON text, or "" when none was given.
+   */
   args: string;
+  /** The invocation's arguments verbatim: the slash command's string, or the tool or `workflow()` JSON value. */
+  input: unknown;
   /** Working directory of the host session (typically the repo root). */
   cwd: string;
   /**
@@ -264,8 +286,19 @@ export interface WorkflowApi {
 
 export type WorkflowRun = (api: WorkflowApi) => Promise<unknown>;
 
+/**
+ * `file` workflows resolve by name from `path` under `root`. Their `fingerprint` hashes the `root` tree,
+ * revalidated on resume because imports may load lazily, unless `selfContained` marks a compiled saved
+ * script: it can import nothing, so the hash of its own content is its whole identity.
+ */
 export type WorkflowSourceIdentity =
-  | { readonly kind: "file"; readonly path: string; readonly root: string; readonly fingerprint: string }
+  | {
+      readonly kind: "file";
+      readonly path: string;
+      readonly root: string;
+      readonly fingerprint: string;
+      readonly selfContained?: true;
+    }
   | { readonly kind: "fingerprint"; readonly fingerprint: string }
   | { readonly kind: "unverifiable"; readonly reason: string };
 
@@ -279,4 +312,6 @@ export interface WorkflowModule {
 export interface LoadedWorkflow extends WorkflowModule {
   readonly source: WorkflowSourceIdentity;
   readonly isolatedWorktreeBaseline?: WorktreeBaseline;
+  /** An inline run's script source, persisted beside its run record so the run can be read and relaunched. */
+  readonly inlineScript?: string;
 }

package/.pi/extensions/pi-workflow-engine/src/ui/kit.ts

@@ -15,6 +15,7 @@ export const GLYPH = {
   failed: "✗",
   running: "●",
   queued: "○",
+  skipped: "⊘",
   warning: "⚠",
   bullet: "•",
   cursor: "›",

package/.pi/extensions/pi-workflow-engine/src/ui/workflow-format.ts

@@ -77,6 +77,7 @@ export interface WorkflowStatusCounts {
   readonly running: number;
   readonly done: number;
   readonly failed: number;
+  readonly skipped: number;
   readonly total: number;
 }
 
@@ -96,7 +97,7 @@ export function formatWorkflowInspection(inspection: WorkflowInspectionSource):
     `Workflow inspector: ${inspection.name}`,
     `Run: ${snapshot.runId}`,
     `Phase: ${snapshot.currentPhase}`,
-    `Agents: ${counts.running} running, ${counts.queued} queued, ${counts.done} done, ${counts.failed} failed`,
+    `Agents: ${counts.running} running, ${counts.queued} queued, ${counts.done} done, ${counts.failed} failed${counts.skipped > 0 ? `, ${counts.skipped} skipped` : ""}`,
   ];
   const usage = formatWorkflowUsageLine(snapshot.usage);
   if (usage) lines.push(usage);
@@ -109,7 +110,7 @@ export function statusTextFromCounts(snapshot: WorkflowProgressSnapshot, counts:
   if (snapshot.doneAt !== undefined) return undefined;
 
   const displayName = snapshot.title === "code-review" ? "review" : snapshot.title;
-  const progress = counts.total > 0 ? ` ${counts.done + counts.failed}/${counts.total}` : "";
+  const progress = counts.total > 0 ? ` ${finishedAgents(counts)}/${counts.total}` : "";
   return [
     `${theme.fg("accent", GLYPH.workflow)} ${theme.fg("accent", displayName)}`,
     theme.fg("muted", `${snapshot.currentPhase}${progress}`),
@@ -117,8 +118,13 @@ export function statusTextFromCounts(snapshot: WorkflowProgressSnapshot, counts:
   ].join(dot(theme));
 }
 
+/** Agents that will not run again: done, failed, or skipped. */
+export function finishedAgents(counts: WorkflowStatusCounts): number {
+  return counts.done + counts.failed + counts.skipped;
+}
+
 export function countAgents(phases: readonly PhaseSnapshot[]): WorkflowStatusCounts {
-  const counts = { queued: 0, running: 0, done: 0, failed: 0, total: 0 };
+  const counts = { queued: 0, running: 0, done: 0, failed: 0, skipped: 0, total: 0 };
   for (const phase of phases) {
     for (const agent of phase.agents) {
       counts[agent.status]++;

package/.pi/extensions/pi-workflow-engine/src/ui/workflow-inspector.ts

@@ -25,7 +25,7 @@ import {
   truncatePath,
   type ThemeColor,
 } from "./kit.ts";
-import { formatDuration } from "./workflow-format.ts";
+import { countAgents, finishedAgents, formatDuration } from "./workflow-format.ts";
 import { WORKFLOW_VIEWER_OVERLAY_OPTIONS } from "./workflow-viewer-layout.ts";
 
 /** What the inspector knows about a run beyond its progress snapshot. */
@@ -40,6 +40,12 @@ export interface WorkflowInspectorOutcome {
 
 type OutcomeSource = WorkflowInspectorOutcome | (() => WorkflowInspectorOutcome | undefined);
 
+/** Actions on a live run. A retained or finished run has none, so its inspector is read-only. */
+export interface WorkflowInspectorControls {
+  /** Skip one running agent by its progress row id; false when it is no longer running. */
+  readonly skipAgent?: (agentId: number) => boolean;
+}
+
 /** The tables need about 80 columns, so narrow terminals give the inspector nearly full width instead of 80%. */
 export const WORKFLOW_INSPECTOR_OVERLAY_OPTIONS = {
   overlay: true,
@@ -51,9 +57,10 @@ export async function showWorkflowInspector(
   ui: Pick<ExtensionContext["ui"], "custom">,
   snapshot: () => WorkflowProgressSnapshot,
   outcome?: OutcomeSource,
+  controls?: WorkflowInspectorControls,
 ): Promise<void> {
   await ui.custom<void>(
-    (...[tui, theme, , done]) => new WorkflowInspector(snapshot, tui, theme, () => done(undefined), outcome),
+    (...[tui, theme, , done]) => new WorkflowInspector(snapshot, tui, theme, () => done(undefined), outcome, controls),
     WORKFLOW_INSPECTOR_OVERLAY_OPTIONS,
   );
 }
@@ -113,6 +120,12 @@ export class WorkflowInspector {
   private readonly cursorIndexes = new Map<TabId, number>();
   private readonly scrollOffsets = new Map<TabId, number>();
   private readonly expanded = new Set<string>();
+  /** Agents whose skip was sent; they keep running until their session winds down. */
+  private readonly skipRequested = new Set<number>();
+  /** Agent armed by a first skip press; any other key disarms it. */
+  private pendingSkip: number | undefined;
+  /** One-keypress footer warning, as in the runs browser. */
+  private notice: string | undefined;
   private refreshTimer: ReturnType<typeof setInterval> | undefined;
 
   constructor(
@@ -121,6 +134,7 @@ export class WorkflowInspector {
     private readonly theme: Theme,
     private readonly close: () => void,
     private readonly outcomeSource?: OutcomeSource,
+    private readonly controls?: WorkflowInspectorControls,
   ) {}
 
   handleInput(data: string): void {
@@ -128,6 +142,10 @@ export class WorkflowInspector {
       this.close();
       return;
     }
+    const armedSkip = this.pendingSkip;
+    const hadNotice = this.notice !== undefined;
+    this.pendingSkip = undefined;
+    this.notice = undefined;
     const tabs = this.tabs(this.outcome());
     const digit = TAB_DIGITS.findIndex((candidate) => matchesKey(data, candidate));
     if (matchesKey(data, "tab") || matchesKey(data, "right")) this.tabIndex = (this.tabIndex + 1) % tabs.length;
@@ -142,7 +160,8 @@ export class WorkflowInspector {
     else if (matchesKey(data, "g") || matchesKey(data, "home")) this.move(-Infinity);
     else if (data === "G" || matchesKey(data, "shift+g") || matchesKey(data, "end")) this.move(Infinity);
     else if (matchesKey(data, "enter") || matchesKey(data, "return")) this.toggleExpanded();
-    else return;
+    else if (matchesKey(data, "s")) this.skipSelected(armedSkip);
+    else if (!hadNotice) return;
     this.tui.requestRender();
   }
 
@@ -175,11 +194,12 @@ export class WorkflowInspector {
     const title = `${this.theme.fg("accent", GLYPH.workflow)} ${this.theme.bold(snapshot.title)}`;
     // Border chrome around the two labels: `╭─ ` + title + ` ` … ` ` + right + ` ─╮`, plus one fill cell.
     const rightRoom = Math.max(0, width - visibleWidth(title) - 9);
+    const skippable = this.skippableAgent(active, snapshot, status) !== undefined;
     return frame(
       [tabLine, "", ...visible, ...Array.from({ length: viewRows - visible.length }, () => "")],
       width,
       this.theme,
-      { title, right: this.headerStatus(snapshot, status, rightRoom), footer: this.footer(active, rows, viewRows, offset, below, width) },
+      { title, right: this.headerStatus(snapshot, status, rightRoom), footer: this.footer(active, rows, viewRows, offset, below, width, skippable) },
     );
   }
 
@@ -250,6 +270,29 @@ export class WorkflowInspector {
     else this.expanded.add(key);
   }
 
+  /** Skipping ends live work, so like stopping a run in the runs browser it takes a second press on the same agent. */
+  private skipSelected(armed: number | undefined): void {
+    const snapshot = this.snapshotProvider();
+    const agent = this.skippableAgent(this.activeTab(), snapshot, runStatus(snapshot, this.outcome()?.state));
+    if (!agent) return;
+    if (armed !== agent.id) {
+      this.pendingSkip = agent.id;
+      this.notice = `press s again to skip ${agent.label}`;
+      return;
+    }
+    if (this.controls?.skipAgent?.(agent.id)) this.skipRequested.add(agent.id);
+    else this.notice = `${agent.label} is no longer running`;
+  }
+
+  /** The selected agent when it can be skipped: a running row of a live run whose source accepts skips. */
+  private skippableAgent(tab: TabId, snapshot: WorkflowProgressSnapshot, status: RunStatus): AgentRowSnapshot | undefined {
+    if (!this.controls?.skipAgent || tab !== "agents" || !status.live) return undefined;
+    const agents = snapshot.phases.flatMap((phase) => phase.agents);
+    const selected = this.selectedKey("agents", agents.map(agentKey));
+    const agent = agents.find((candidate) => agentKey(candidate) === selected);
+    return agent?.status === "running" && !this.skipRequested.has(agent.id) ? agent : undefined;
+  }
+
   /** Resolves the cursor by key so live rows inserted above it do not move the selection. */
   private cursorIndex(tab: TabId, keys: readonly string[]): number {
     const byKey = keys.indexOf(this.cursorKeys.get(tab) ?? "");
@@ -299,27 +342,29 @@ export class WorkflowInspector {
   /** State first; lower-priority parts (run id, then elapsed) drop whole rather than truncating. */
   private headerStatus(snapshot: WorkflowProgressSnapshot, status: RunStatus, room: number): string {
     const th = this.theme;
-    const agents = snapshot.phases.flatMap((phase) => phase.agents);
-    const failed = agents.filter((agent) => agent.status === "failed").length;
-    // A run that finished around failed agents is complete but not clean.
-    const degraded = !status.live && failed > 0 && status.color === "success";
+    const counts = countAgents(snapshot.phases);
+    // A run that finished around failed or skipped agents is complete but not clean.
+    const degraded = !status.live && counts.failed + counts.skipped > 0 && status.color === "success";
     const state = degraded ? th.fg("warning", `${GLYPH.warning} ${status.word}`) : th.fg(status.color, `${status.glyph} ${status.word}`);
-    const failures = failed > 0 ? th.fg("error", `${failed} failed`) : undefined;
+    const failures = counts.failed > 0 ? th.fg("error", `${counts.failed} failed`) : undefined;
+    const skips = counts.skipped > 0 ? th.fg("warning", `${counts.skipped} skipped`) : undefined;
     const runId = th.fg("dim", `run ${snapshot.runId.slice(0, 8)}`);
     if (status.live) {
-      const finished = agents.filter((agent) => agent.status === "done" || agent.status === "failed").length;
-      const progress = agents.length > 0 ? `${snapshot.currentPhase} ${finished}/${agents.length}` : snapshot.currentPhase;
-      return fitParts([state, th.fg("muted", progress), failures, th.fg("muted", formatDuration(Date.now() - snapshot.startedAt)), runId], room, th);
+      const progress = counts.total > 0 ? `${snapshot.currentPhase} ${finishedAgents(counts)}/${counts.total}` : snapshot.currentPhase;
+      return fitParts([state, th.fg("muted", progress), failures, skips, th.fg("muted", formatDuration(Date.now() - snapshot.startedAt)), runId], room, th);
     }
     const elapsed = snapshot.doneAt !== undefined ? th.fg("muted", formatDuration(snapshot.doneAt - snapshot.startedAt)) : undefined;
-    return fitParts([state, failures, elapsed, runId], room, th);
+    return fitParts([state, failures, skips, elapsed, runId], room, th);
   }
 
-  private footer(tab: TabId, rows: readonly Row[], viewRows: number, offset: number, below: number, width: number): string {
+  private footer(tab: TabId, rows: readonly Row[], viewRows: number, offset: number, below: number, width: number, skippable: boolean): string {
+    if (this.notice) return this.theme.fg("warning", `${GLYPH.warning} ${this.notice}`);
     const clipped = rows.length > viewRows;
     const pairs: (readonly [string, string])[] = [["tab", "sections"]];
     if (LIST_TABS.has(tab) && selectableKeys(rows).length > 0) pairs.push(["↑↓", "move"], ["enter", "expand"]);
     else if (clipped) pairs.push(["↑↓", "scroll"]);
+    // Like the runs browser's action keys, skip is listed only while the selection can take it.
+    if (skippable) pairs.push(["s", "skip"]);
     pairs.push(["q", "close"]);
     const hints = keyHints(pairs, this.theme);
     const scroll = [offset > 0 ? `↑ ${offset} more` : undefined, below > 0 ? `↓ ${below} more` : undefined].filter(Boolean).join("  ");
@@ -367,6 +412,7 @@ export class WorkflowInspector {
           countNote(phase.agents, "running", "accent", th),
           countNote(phase.agents, "queued", "dim", th),
           countNote(phase.agents, "failed", "error", th),
+          countNote(phase.agents, "skipped", "warning", th),
         ],
         th,
       );
@@ -449,9 +495,8 @@ export class WorkflowInspector {
     const now = Date.now();
     const rows: Row[] = [];
     for (const phase of phases) {
-      const failed = phase.agents.filter((agent) => agent.status === "failed").length;
-      const note = failed > 0 ? ` ${th.fg("error", `${failed} failed`)}` : "";
-      rows.push({ text: `  ${th.bold(th.fg("muted", phase.title))}${note}`, heading: true });
+      const notes = joinParts([countNote(phase.agents, "failed", "error", th), countNote(phase.agents, "skipped", "warning", th)], th);
+      rows.push({ text: `  ${th.bold(th.fg("muted", phase.title))}${notes ? ` ${notes}` : ""}`, heading: true });
       for (const agent of phase.agents) {
         const key = agentKey(agent);
         const cursor = key === selected ? th.fg("accent", GLYPH.cursor) : " ";
@@ -460,7 +505,8 @@ export class WorkflowInspector {
         const tools = agent.toolUses > 0 ? `${agent.toolUses} tool${agent.toolUses === 1 ? "" : "s"}` : "";
         const expanded = this.expanded.has(key);
         // Expanded rows carry the full error and tool below, so the inline note would repeat them.
-        const note = expanded ? "" : agentNote(agent, th);
+        const skipping = agent.status === "running" && this.skipRequested.has(agent.id);
+        const note = skipping ? th.fg("warning", "skipping…") : expanded ? "" : agentNote(agent, th);
         const line = `${cursor} ${agentGlyph(agent, th)} ${label}  ${padStartVisible(th.fg("muted", duration), 6)}  ${fit(th.fg("dim", tools), 8)}  ${note}`;
         rows.push({ text: line.trimEnd(), key });
         if (expanded) rows.push(...this.agentDetails(agent, phase, snapshot, width));
@@ -474,6 +520,7 @@ export class WorkflowInspector {
     const fields: [string, string][] = [];
     if (agent.error) fields.push(["error", th.fg("error", agent.error)]);
     if (agent.status === "queued") fields.push(["status", th.fg("muted", "queued, waiting for a free agent slot")]);
+    if (agent.status === "skipped") fields.push(["status", th.fg("warning", "skipped by the user; its result was dropped")]);
     if (agent.lastTool) {
       const calls = agent.toolUses > 1 ? th.fg("dim", ` · last of ${agent.toolUses} tool calls`) : "";
       fields.push(["tool", `${agent.lastTool}${calls}`]);
@@ -611,6 +658,7 @@ function phaseGlyph(phase: PhaseSnapshot, activeAndLive: boolean): { glyph: stri
   if (agents.length > 0 && agents.every((agent) => agent.status === "queued")) return { glyph: GLYPH.queued, color: "dim" };
   if (agents.some((agent) => agent.status === "queued")) return { glyph: GLYPH.running, color: "accent" };
   if (agents.length > 0 && agents.every((agent) => agent.status === "failed")) return { glyph: GLYPH.failed, color: "error" };
+  if (agents.length > 0 && agents.every((agent) => agent.status === "skipped")) return { glyph: GLYPH.skipped, color: "warning" };
   return { glyph: GLYPH.done, color: "success" };
 }
 
@@ -655,6 +703,8 @@ function agentGlyph(agent: AgentRowSnapshot, theme: Theme): string {
       return theme.fg("success", GLYPH.done);
     case "failed":
       return theme.fg("error", GLYPH.failed);
+    case "skipped":
+      return theme.fg("warning", GLYPH.skipped);
     case "running":
       return theme.fg("accent", GLYPH.running);
     case "queued":
@@ -664,6 +714,7 @@ function agentGlyph(agent: AgentRowSnapshot, theme: Theme): string {
 
 function agentNote(agent: AgentRowSnapshot, theme: Theme): string {
   if (agent.status === "failed") return theme.fg("error", firstLine(agent.error ?? "failed"));
+  if (agent.status === "skipped") return theme.fg("warning", "skipped");
   if (agent.status === "queued") return theme.fg("dim", "queued");
   if (agent.status === "running" && agent.lastTool) return theme.fg("dim", agent.lastTool);
   return "";

package/.pi/extensions/pi-workflow-engine/src/ui/workflow-runs-browser.ts

@@ -1,11 +1,13 @@
 import type { Theme } from "@earendil-works/pi-coding-agent";
-import { decodeKittyPrintable, matchesKey, visibleWidth, type Component, type TUI } from "@earendil-works/pi-tui";
+import { decodeKittyPrintable, matchesKey, truncateToWidth, visibleWidth, type Component, type TUI } from "@earendil-works/pi-tui";
 import { isRecord } from "../guards.ts";
 import { formatCount, truncateText } from "../text.ts";
 import {
   availableWorkflowRunActions,
   canRelaunchWorkflowRun,
   formatWorkflowRunDuration,
+  hasRelaunchableWorkflowSource,
+  isInlineWorkflowRun,
   type WorkflowRunActionContext,
   type WorkflowRunLifecycleAction,
 } from "../workflow-run-history.ts";
@@ -72,9 +74,12 @@ const OUTCOME_LINES = 3;
 const OUTCOME_CHARS = 600;
 const LIST_MIN = 3;
 const REFRESH_MS = 1_000;
+const INLINE_TAG = "inline";
 
 interface RunCells {
   readonly name: string;
+  /** `inline` for a run of an inline script; it stays visible however far the name is truncated. */
+  readonly tag: string;
   readonly state: string;
   readonly duration: string;
   readonly age: string;
@@ -212,9 +217,12 @@ export class WorkflowRunsBrowser implements Component {
     const style = STATE_STYLE[record.state];
     const selected = index === this.cursor;
     const cursor = selected ? this.theme.fg("accent", GLYPH.cursor) : " ";
-    const name = fit(cells.name, layout.name);
+    const tagWidth = cells.tag ? visibleWidth(cells.tag) + 1 : 0;
+    const name = truncateToWidth(cells.name, Math.max(1, layout.name - tagWidth), "…");
+    const tag = cells.tag ? ` ${this.theme.fg("dim", cells.tag)}` : "";
+    const padding = " ".repeat(Math.max(0, layout.name - visibleWidth(name) - tagWidth));
     const parts = [
-      `${cursor} ${this.theme.fg(style.color, style.glyph)} ${selected ? this.theme.bold(name) : name}`,
+      `${cursor} ${this.theme.fg(style.color, style.glyph)} ${selected ? this.theme.bold(name) : name}${tag}${padding}`,
       this.theme.fg(style.color, fit(cells.state, layout.state)),
     ];
     if (layout.duration > 0) parts.push(this.theme.fg("muted", padStartVisible(cells.duration, layout.duration)));
@@ -366,7 +374,7 @@ interface ColumnLayout {
 function columnLayout(cells: readonly RunCells[], width: number): ColumnLayout {
   const widest = (pick: (cell: RunCells) => string) => Math.max(0, ...cells.map((cell) => visibleWidth(pick(cell))));
   let layout: ColumnLayout = {
-    name: Math.min(NAME_MAX, widest((cell) => cell.name)),
+    name: Math.min(NAME_MAX, widest((cell) => (cell.tag ? `${cell.name} ${cell.tag}` : cell.name))),
     state: widest((cell) => cell.state),
     duration: widest((cell) => cell.duration),
     age: widest((cell) => cell.age),
@@ -389,6 +397,7 @@ function runCells(record: WorkflowRunRecord, now: number): RunCells {
   const cost = record.usage?.totals.cost.total ?? 0;
   return {
     name: record.workflow.name,
+    tag: isInlineWorkflowRun(record) ? INLINE_TAG : "",
     state: record.state,
     duration: record.state === "queued" ? "" : formatWorkflowRunDuration(record, now),
     age: relativeTime(record.createdAt, now),
@@ -446,8 +455,10 @@ function describeOutcome(record: WorkflowRunRecord): string | undefined {
 /** Why a finished or paused run cannot be relaunched, mirroring `canRelaunchWorkflowRun`. */
 function relaunchBlocker(record: WorkflowRunRecord): string | undefined {
   if (record.state === "queued" || record.state === "running" || canRelaunchWorkflowRun(record)) return undefined;
-  if (record.workflow.sourceKind !== "file" || typeof record.workflow.sourceFingerprint !== "string") {
-    return "the workflow source cannot be verified";
+  if (!hasRelaunchableWorkflowSource(record)) {
+    if (!isInlineWorkflowRun(record)) return "the workflow source cannot be verified";
+    if (record.scriptFile === undefined) return "its inline script was not retained";
+    return "its inline script has no seal from this pi install";
   }
   return record.options.argumentsPresent !== false ? "its arguments were not retained" : undefined;
 }

package/.pi/extensions/pi-workflow-engine/src/ui/workflow-tool-renderer.ts

@@ -2,6 +2,7 @@ import type { Theme } from "@earendil-works/pi-coding-agent";
 import { truncateToWidth, visibleWidth, type Component } from "@earendil-works/pi-tui";
 import { isRecord } from "../guards.ts";
 import { readInlineWorkflowMeta } from "../inline-workflow.ts";
+import { workflowArgsText } from "../workflow-input.ts";
 import { GLYPH, hangingWrap, keyHints, spread } from "./kit.ts";
 import { LinesComponent, shortRunId, type WorkflowResultHints } from "./result-layout.ts";
 import { isWorkflowResult, workflowResultComponent } from "./workflow-result-renderer.ts";
@@ -10,7 +11,9 @@ import { isWorkflowResult, workflowResultComponent } from "./workflow-result-ren
 export interface WorkflowToolCallArgs {
   readonly name?: string;
   readonly script?: string;
-  readonly args?: string;
+  readonly scriptPath?: string;
+  /** A string or any JSON value. */
+  readonly args?: unknown;
   readonly background?: boolean;
   readonly resumeFromRunId?: string;
 }
@@ -22,11 +25,13 @@ export interface WorkflowToolResultView {
 
 /** A named workflow, or an inline one identified by its literal meta (`inline` until that parses). */
 export function workflowToolTitle(args: WorkflowToolCallArgs): { readonly name: string; readonly detail?: string } {
-  const detail = collapseWhitespace(args.args ?? "");
+  const detail = collapseWhitespace(workflowArgsText(args.args));
   const named = args.name?.trim();
   if (named) return { name: named, detail: detail || undefined };
   const meta = args.script ? readInlineWorkflowMeta(args.script) : undefined;
-  return { name: meta?.name ?? "inline", detail: detail || collapseWhitespace(meta?.description ?? "") || undefined };
+  // The row renders synchronously, so a script file is named by its path rather than read for its meta.
+  const fallback = meta?.description ?? args.scriptPath ?? "";
+  return { name: meta?.name ?? "inline", detail: detail || collapseWhitespace(fallback) || undefined };
 }
 
 /** `▸ workflow code-review · HEAD~3 (background)`: the detail is shortened before the tags are. */