@wichayutdew/pi-workflows 3.1.0 → 3.3.0

package/src/harness/step-execution-actions.ts

@@ -6,7 +6,10 @@ import {
   beginMainStepAttempt,
   beginSubagentStepAttempt,
   recordCurrentStepResult,
+  recordCurrentStepUsage,
+  usageAggregateFromModels,
 } from '../engine/step-trace.ts';
+import type { ModelUsage } from '../engine/usage.ts';
 import { advanceRun, allowedOutcomes } from '../engine/transitions.ts';
 import { digest } from '../digest.ts';
 import type { SubagentDelegationResponse } from '../integrations/subagents/protocol.ts';
@@ -62,12 +65,14 @@ export type StepExecutionActions = {
     identity: MainStepIdentity,
     lines: ReadonlyArray<string>,
     context: ExtensionContext,
+    usage?: ReadonlyArray<ModelUsage>,
   ) => Promise<void>;
   recordMainStepLog: (
     this: HarnessActionContext,
     identity: MainStepIdentity,
     lines: ReadonlyArray<string>,
     context: ExtensionContext,
+    usage?: ReadonlyArray<ModelUsage>,
   ) => Promise<void>;
   queueMainStepResult: (
     this: HarnessActionContext,
@@ -236,8 +241,8 @@ function launchMainStep(
     summaryMaxChars: workflow.definition.summaryMaxChars,
     ...(step.gate ? { gateSubmitOutcome: step.gate.submitOutcome } : {}),
     ...(step.workspace ? { workspace: structuredClone(step.workspace) } : {}),
-    onTrace: (lines, context) =>
-      this.queueMainStepLog(identity, lines, context),
+    onTrace: (lines, context, usage) =>
+      this.queueMainStepLog(identity, lines, context, usage),
     onSettled: (result, context) =>
       this.queueMainStepResult(identity, result, context),
   };
@@ -302,9 +307,10 @@ function queueMainStepLog(
   identity: MainStepIdentity,
   lines: ReadonlyArray<string>,
   context: ExtensionContext,
+  usage?: ReadonlyArray<ModelUsage>,
 ): Promise<void> {
   return this.mutationQueue
-    .run(() => this.recordMainStepLog(identity, lines, context))
+    .run(() => this.recordMainStepLog(identity, lines, context, usage))
     .catch(() => {
       // Status evidence is best-effort and must never pause step execution.
     });
@@ -315,6 +321,7 @@ async function recordMainStepLog(
   identity: MainStepIdentity,
   lines: ReadonlyArray<string>,
   context: ExtensionContext,
+  usage?: ReadonlyArray<ModelUsage>,
 ): Promise<void> {
   if (
     !hasCurrentMainStepIdentity(this, identity) ||
@@ -327,12 +334,20 @@ async function recordMainStepLog(
     return;
   }
   this.latestContext = context;
-  const traced = appendMainStepLog(
+  let traced = appendMainStepLog(
     this.run,
     identity.requestId,
     lines,
     this.dependencies.now(),
   );
+  if (usage && usage.length > 0) {
+    traced = recordCurrentStepUsage(
+      traced,
+      identity.requestId,
+      usageAggregateFromModels(usage),
+      this.dependencies.now(),
+    );
+  }
   if (traced === this.run) return;
   this.run = traced;
   this.persist();

package/src/harness/types.ts

@@ -11,6 +11,7 @@ export type ActiveDelegation = {
   policy: ChildStepPolicy;
   transcriptTask: string;
   agent: string;
+  model?: string;
   progress?: string;
   activityLog?: Array<string>;
   cancelling?: boolean;

package/src/index.ts

@@ -32,7 +32,9 @@ const DEFAULT_DEPENDENCIES = {
   loadSettings,
   userWorkflowDirectory: defaultUserWorkflowDirectory,
   runtimeEnvironment: (): PiWorkflowsRuntimeEnvironment => ({
-    isSubagentChild: process.env.PI_WORKFLOWS_CHILD === '1',
+    isSubagentChild:
+      process.env.PI_WORKFLOWS_CHILD === '1' &&
+      process.env.PI_WORKFLOWS_CHILD_RUNTIME === '1',
     childAgent: process.env.PI_WORKFLOWS_CHILD_AGENT?.trim(),
   }),
   registerChildRuntime: (pi, childAgent): void => {

package/src/integrations/subagents/client.ts

@@ -4,11 +4,17 @@ import type {
   SubagentDelegationRequest,
   SubagentDelegationResponse,
   SubagentDelegationUpdate,
+  SubagentModelUsage,
 } from './protocol-events.ts';
 import type {
   DelegationDiagnostic,
   DelegationDiagnosticCall,
 } from './diagnostics.ts';
+import {
+  emptyUsageAggregate,
+  mergeUsage,
+  modelUsageFromMessage,
+} from '../../engine/usage.ts';
 
 export type DelegateOptions = {
   readonly signal?: AbortSignal;
@@ -57,6 +63,7 @@ export function directWorkerResponse(
   signal: NodeJS.Signals | null,
   stderr: string,
   diagnostic?: DelegationDiagnostic,
+  usage: ReadonlyArray<SubagentModelUsage> = [],
 ): SubagentDelegationResponse {
   const status = code === 0 ? 'completed' : signal ? 'cancelled' : 'failed';
   return {
@@ -68,6 +75,7 @@ export function directWorkerResponse(
       ? { error: stderr.trim().slice(-4_000) }
       : {}),
     ...(diagnostic ? { diagnostic } : {}),
+    ...(usage.length > 0 ? { usage } : {}),
   };
 }
 
@@ -77,7 +85,12 @@ type WorkerJsonEvent = {
   readonly toolName?: unknown;
   readonly isError?: unknown;
   readonly args?: unknown;
-  readonly message?: { readonly role?: unknown };
+  readonly message?: {
+    readonly role?: unknown;
+    readonly provider?: unknown;
+    readonly model?: unknown;
+    readonly usage?: unknown;
+  };
   readonly assistantMessageEvent?: {
     readonly type?: unknown;
     readonly delta?: unknown;
@@ -92,6 +105,33 @@ type WorkerProgress = {
 
 const MAX_PROGRESS_DETAIL_CHARS = 480;
 const MAX_DIAGNOSTIC_CALLS = 64;
+
+/** Extracts usage only from finalized worker messages, never stream updates. */
+export function workerUsageFromJsonLine(
+  line: string,
+  fallbackProvider?: string,
+  fallbackModel?: string,
+): ReadonlyArray<SubagentModelUsage> {
+  let event: WorkerJsonEvent;
+  try {
+    const parsed: unknown = JSON.parse(line);
+    if (typeof parsed !== 'object' || parsed === null) return [];
+    event = parsed;
+  } catch {
+    return [];
+  }
+  if (event.type !== 'message_end' || !event.message) return [];
+  const role = event.message.role;
+  if (role !== 'assistant' && role !== 'toolResult' && role !== 'tool')
+    return [];
+  const usage = modelUsageFromMessage(
+    event.message,
+    fallbackProvider,
+    fallbackModel,
+  );
+  return usage ? [usage] : [];
+}
+
 const SECRET_KEY = /authorization|cookie|password|secret|token|api[-_]?key/i;
 
 function redactProgressValue(value: unknown, key = ''): unknown {
@@ -275,6 +315,7 @@ export function createSubagentDelegationClient(
         env: {
           ...process.env,
           PI_WORKFLOWS_CHILD: '1',
+          PI_WORKFLOWS_CHILD_RUNTIME: '1',
           PI_WORKFLOWS_CHILD_AGENT: request.agent,
         },
         stdio: ['ignore', 'pipe', 'pipe'],
@@ -285,7 +326,30 @@ export function createSubagentDelegationClient(
       let toolCount = 0;
       let responseText = '';
       const diagnostic = createDiagnostic();
+      let lastProvider: string | undefined;
+      let lastModel: string | undefined;
+      let usage = emptyUsageAggregate();
       const stdoutDecoder = new StringDecoder('utf8');
+      const updateLastModel = (line: string): void => {
+        let event: WorkerJsonEvent;
+        try {
+          const parsed: unknown = JSON.parse(line);
+          if (typeof parsed !== 'object' || parsed === null) return;
+          event = parsed;
+        } catch {
+          return;
+        }
+        if (
+          event.type === 'message_end' &&
+          event.message &&
+          event.message.role === 'assistant'
+        ) {
+          if (typeof event.message.provider === 'string')
+            lastProvider = event.message.provider;
+          if (typeof event.message.model === 'string')
+            lastModel = event.message.model;
+        }
+      };
       const consumeWorkerLines = (): void => {
         while (true) {
           const newline = stdoutBuffer.indexOf('\n');
@@ -293,6 +357,20 @@ export function createSubagentDelegationClient(
           const line = stdoutBuffer.slice(0, newline);
           stdoutBuffer = stdoutBuffer.slice(newline + 1);
           recordWorkerDiagnostic(line, diagnostic);
+          updateLastModel(line);
+          const lineUsage = workerUsageFromJsonLine(
+            line,
+            lastProvider,
+            lastModel,
+          );
+          if (lineUsage.length > 0) {
+            usage = mergeUsage(usage, lineUsage);
+            const latest = lineUsage[lineUsage.length - 1];
+            if (latest) {
+              lastProvider = latest.provider;
+              lastModel = latest.model;
+            }
+          }
           const progress = workerProgressFromJsonLine(
             line,
             request.requestId,
@@ -332,6 +410,7 @@ export function createSubagentDelegationClient(
             signal,
             stderr,
             diagnosticSnapshot(diagnostic),
+            usage.models,
           ),
         );
       });

package/src/integrations/subagents/protocol-events.ts

@@ -1,5 +1,5 @@
 import type { DelegationDiagnostic } from './diagnostics.ts';
-
+import type { UsageTotals } from '../../engine/usage.ts';
 export const SUBAGENT_DELEGATION_PROTOCOL_VERSION = 1 as const;
 export const SUBAGENT_DELEGATION_REQUEST_EVENT =
   'prompt-template:subagent:request';
@@ -35,6 +35,12 @@ export type SubagentDelegationUpdate = {
 };
 export type SubagentDelegationStatus = 'completed' | 'failed' | 'cancelled';
 
+export type SubagentModelUsage = {
+  readonly provider: string;
+  readonly model: string;
+  readonly usage: UsageTotals;
+};
+
 export type SubagentDelegationResponse = {
   readonly version?: number;
   readonly requestId: string;
@@ -44,4 +50,6 @@ export type SubagentDelegationResponse = {
   readonly exitCode?: number;
   readonly warnings?: ReadonlyArray<string>;
   readonly diagnostic?: DelegationDiagnostic;
+  /** Usage captured from terminal worker messages only. */
+  readonly usage?: ReadonlyArray<SubagentModelUsage>;
 };

package/src/runtime/main-step-runtime-types.ts

@@ -1,5 +1,6 @@
 import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
 import type { WorkflowStep } from '../config/types.ts';
+import type { ModelUsage } from '../engine/usage.ts';
 import type { invalidCompletionCallIds } from '../policy/completion-batch.ts';
 import type { freezeToolInput } from '../policy/immutable-input.ts';
 import type { authorizeToolCall, resolveActiveTools } from '../policy/tools.ts';
@@ -24,6 +25,7 @@ export type MainStepExecution = StepResultPolicy & {
   readonly onTrace: (
     lines: ReadonlyArray<string>,
     context: ExtensionContext,
+    usage?: ReadonlyArray<ModelUsage>,
   ) => Promise<void> | void;
   /** Handles the captured result after Pi fully settles the agent run. */
   readonly onSettled: (

package/src/runtime/main-step-trace.ts

@@ -1,12 +1,45 @@
 import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
 import { stepLogLinesFromTurn, textOnlyUserMessage } from '../step-log.ts';
+import { modelUsageFromMessage, type ModelUsage } from '../engine/usage.ts';
 import type { MainStepRuntimeState } from './main-step-runtime-types.ts';
 
+type UnknownRecord = Readonly<Record<string, unknown>>;
+const isRecord = (value: unknown): value is UnknownRecord =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
 type RegisterMainStepTraceOptions = {
   readonly pi: ExtensionAPI;
   readonly state: MainStepRuntimeState;
 };
 
+/** Extracts finalized assistant and nested tool-result usage from one Pi turn. */
+export function mainTurnUsage(event: {
+  readonly message?: unknown;
+  readonly toolResults?: ReadonlyArray<unknown>;
+}): ReadonlyArray<ModelUsage> {
+  const messageUsage = modelUsageFromMessage(event.message);
+  const fallbackProvider =
+    messageUsage?.provider ??
+    (isRecord(event.message) && typeof event.message.provider === 'string'
+      ? event.message.provider
+      : undefined);
+  const fallbackModel =
+    messageUsage?.model ??
+    (isRecord(event.message) && typeof event.message.model === 'string'
+      ? event.message.model
+      : undefined);
+  const entries: Array<ModelUsage> = messageUsage ? [messageUsage] : [];
+  for (const toolResult of event.toolResults ?? []) {
+    const toolUsage = modelUsageFromMessage(
+      toolResult,
+      fallbackProvider,
+      fallbackModel,
+    );
+    if (toolUsage) entries.push(toolUsage);
+  }
+  return entries;
+}
+
 /** Arms a trace only after Pi finalizes the exact extension-supplied task. */
 export function armMainStepTrace(
   state: MainStepRuntimeState,
@@ -33,7 +66,9 @@ export function registerMainStepTrace({
     if (!active || !state.traceArmed || state.traceClosed) return;
     const lines = stepLogLinesFromTurn(event.message, event.toolResults);
     try {
-      if (lines.length > 0) await active.onTrace(lines, context);
+      const usage = mainTurnUsage(event);
+      if (lines.length > 0 || usage.length > 0)
+        await active.onTrace(lines, context, usage);
     } catch {
       // Status evidence is best-effort and must never interrupt the agent loop.
     } finally {

package/src/workflow-status/format-status.ts

@@ -6,6 +6,7 @@ import {
   workflowStatusIcon,
 } from './formatting.ts';
 import { renderBoard } from './render-board.ts';
+import { formatUsage, workflowUsage } from './format-usage.ts';
 import type { WorkflowStatusSnapshot, WorkflowStatusTheme } from './types.ts';
 
 const UNSTYLED_THEME = {
@@ -26,11 +27,17 @@ export function formatWorkflowProgressStatus(
   );
   const activity =
     run.status === 'awaiting-gate' ? 'awaiting review' : 'working';
+  const workerModel =
+    snapshot.execution?.kind === 'subagent' && snapshot.execution.model
+      ? ` · model ${snapshot.execution.model}`
+      : '';
   const workerProgress =
     snapshot.execution?.kind === 'subagent'
       ? ` · ${snapshot.execution.progress}`
       : '';
-  return `${workflowStatusIcon(run, snapshot.now)} ${run.workflowId} · step ${currentStep} · ${activity}${workerProgress} · ${statusShortcutLabel}`;
+  const usage = workflowUsage(run);
+  const usageText = usage.models.length > 0 ? ` · ${formatUsage(usage)}` : '';
+  return `${workflowStatusIcon(run, snapshot.now)} ${run.workflowId} · step ${currentStep} · ${activity}${workerModel}${workerProgress}${usageText} · ${statusShortcutLabel}`;
 }
 
 /** Format a plain-text workflow status suitable for fallback notifications. */
@@ -50,6 +57,9 @@ export function formatWorkflowStatusText(
     `Status: ${run.status}`,
     `Step: ${run.currentStepId}`,
     `Completed steps: ${run.history.length}`,
+    ...(workflowUsage(run).models.length > 0
+      ? [`Usage: ${formatUsage(workflowUsage(run))}`]
+      : []),
   ];
   if (run.cwd && run.startCwd && run.cwd !== run.startCwd) {
     lines.push(`Workspace: ${run.cwd}`);

package/src/workflow-status/format-usage.ts

@@ -0,0 +1,33 @@
+import {
+  emptyUsageAggregate,
+  mergeUsage,
+  type UsageAggregate,
+  type UsageTotals,
+} from '../engine/usage.ts';
+import type { WorkflowRun } from '../engine/state.ts';
+
+export function workflowUsage(run: WorkflowRun): UsageAggregate {
+  return [
+    ...run.history.map((entry) => entry.usage),
+    run.currentStepUsage,
+  ].reduce<UsageAggregate>(
+    (total, usage) => (usage ? mergeUsage(total, usage.models) : total),
+    emptyUsageAggregate(),
+  );
+}
+
+export function formatUsd(value: number): string {
+  if (value === 0) return '$0.00';
+  return value < 0.01 ? `$${value.toFixed(4)}` : `$${value.toFixed(2)}`;
+}
+
+export function formatTokens(usage: UsageTotals): string {
+  const parts = [`${usage.inputTokens} in`, `${usage.outputTokens} out`];
+  const cache = usage.cacheReadTokens + usage.cacheWriteTokens;
+  if (cache > 0) parts.push(`${cache} cache`);
+  return parts.join(' · ');
+}
+
+export function formatUsage(usage: UsageAggregate): string {
+  return `${formatUsd(usage.usage.totalCostUsd)} · ${formatTokens(usage.usage)}`;
+}

package/src/workflow-status/render-path.ts

@@ -10,6 +10,7 @@ import {
   stepTitle,
 } from './formatting.ts';
 import { joinColumns, padAnsi } from './layout.ts';
+import { formatUsd } from './format-usage.ts';
 import type {
   PathEntry,
   WorkflowStatusSnapshot,
@@ -32,6 +33,7 @@ function historyPathEntry(
     status: 'completed',
     visit,
     outcome: entry.outcome,
+    ...(entry.usage ? { usage: entry.usage } : {}),
     isCurrent: false,
   };
 }
@@ -60,6 +62,7 @@ export function buildPathEntries(
           visits.get(run.currentStepId) ?? 0,
           run.visits[run.currentStepId] ?? 1,
         ),
+        ...(run.currentStepUsage ? { usage: run.currentStepUsage } : {}),
         isCurrent: true,
       },
     ];
@@ -76,6 +79,7 @@ export function buildPathEntries(
         title: stepTitle(workflow, run.currentStepId),
         status: 'completed',
         visit: Math.max(1, run.visits[run.currentStepId] ?? 1),
+        ...(run.currentStepUsage ? { usage: run.currentStepUsage } : {}),
         isCurrent: true,
       },
     ];
@@ -124,9 +128,12 @@ export function renderPathLines(
         entry.isCurrent ? 'text' : 'muted',
         entry.title,
       )}${visit}`;
+      const cost = entry.usage?.models.length
+        ? ` · ${formatUsd(entry.usage.usage.totalCostUsd)}`
+        : '';
       const right = entry.outcome
-        ? `${statusLabel(entry.status)} · ${inline(entry.outcome)}`
-        : statusLabel(entry.status);
+        ? `${statusLabel(entry.status)} · ${inline(entry.outcome)}${cost}`
+        : `${statusLabel(entry.status)}${cost}`;
       const row = joinColumns(
         left,
         theme.fg(statusColor(entry.status), right),

package/src/workflow-status/render-step-detail.ts

@@ -5,6 +5,7 @@ import type {
 } from '../engine/state.ts';
 import { redactStepDetailText } from '../step-log.ts';
 import { boxed, keyValueLines } from './layout.ts';
+import { formatUsage } from './format-usage.ts';
 import { buildPathEntries } from './render-path.ts';
 import type { StepTranscriptLog } from './transcript-reader.ts';
 import type { WorkflowStatusSnapshot, WorkflowStatusTheme } from './types.ts';
@@ -241,6 +242,20 @@ function renderAttempt(
   return [
     theme.bold(theme.fg('accent', `Attempt ${attemptNumber} · ${actor}`)),
     ...keyValueLines(theme, 'request', attempt.requestId, width, 'muted'),
+    ...(attempt.usage
+      ? [
+          ...keyValueLines(theme, 'usage', formatUsage(attempt.usage), width),
+          ...attempt.usage.models.flatMap((entry) =>
+            keyValueLines(
+              theme,
+              'model',
+              `${entry.provider}/${entry.model} · ${formatUsage({ usage: entry.usage, models: [] })}`,
+              width,
+              'muted',
+            ),
+          ),
+        ]
+      : []),
     '',
     theme.bold('Requirement fed to the agent'),
     ...wrapPlain(`${attempt.task}${truncation}`, width, theme),
@@ -296,6 +311,9 @@ function renderLiveWorkerSession(
       width,
       'accent',
     ),
+    ...(snapshot.execution.model
+      ? keyValueLines(theme, 'model', snapshot.execution.model, width, 'muted')
+      : []),
     ...keyValueLines(
       theme,
       'state',
@@ -404,6 +422,20 @@ export function renderStepDetail(
     ...keyValueLines(theme, 'step', entry.stepId, width),
     ...keyValueLines(theme, 'visit', String(entry.visit), width),
     ...keyValueLines(theme, 'status', entry.status, width),
+    ...(entry.usage
+      ? [
+          ...keyValueLines(theme, 'usage', formatUsage(entry.usage), width),
+          ...entry.usage.models.flatMap((model) =>
+            keyValueLines(
+              theme,
+              'model',
+              `${model.provider}/${model.model} · ${formatUsage({ usage: model.usage, models: [] })}`,
+              width,
+              'muted',
+            ),
+          ),
+        ]
+      : []),
     ...(history
       ? [
           ...keyValueLines(theme, 'outcome', history.outcome, width, 'success'),

package/src/workflow-status/render-summary.ts

@@ -14,6 +14,7 @@ import {
   stepTitle,
 } from './formatting.ts';
 import { clampRows, keyValueLines } from './layout.ts';
+import { formatUsage, workflowUsage } from './format-usage.ts';
 import type { WorkflowStatusSnapshot, WorkflowStatusTheme } from './types.ts';
 
 const MAX_REASON_ROWS = 5;
@@ -113,6 +114,21 @@ export function renderSummaryLines(
     ),
   ];
 
+  const usage = workflowUsage(run);
+  if (usage.models.length > 0) {
+    lines.push(...keyValueLines(theme, 'usage', formatUsage(usage), width));
+    lines.push(
+      ...usage.models.flatMap((entry) =>
+        keyValueLines(
+          theme,
+          'model',
+          `${entry.provider}/${entry.model} · ${formatUsage({ usage: entry.usage, models: [] })}`,
+          width,
+          'muted',
+        ),
+      ),
+    );
+  }
   if (run.cwd && run.startCwd && run.cwd !== run.startCwd) {
     lines.push(...keyValueLines(theme, 'workspace', run.cwd, width, 'accent'));
   }

package/src/workflow-status/types.ts

@@ -3,6 +3,7 @@ import type { TUI } from '@earendil-works/pi-tui';
 import type { LoadedWorkflow } from '../config/types.ts';
 import type { WorkflowRun, WorkflowRunStatus } from '../engine/state.ts';
 import type { StepExecutionAttempt } from '../engine/state.ts';
+import type { UsageAggregate } from '../engine/usage.ts';
 import type { StepTranscriptLog } from './transcript-reader.ts';
 
 export type WorkflowStatusExecution =
@@ -14,6 +15,7 @@ export type WorkflowStatusExecution =
       readonly agent: string;
       readonly requestId: string;
       readonly progress: string;
+      readonly model?: string;
       readonly activityLog?: ReadonlyArray<string>;
     };
 
@@ -38,6 +40,7 @@ export type PathEntry = {
   readonly status: StepDisplayStatus;
   readonly visit: number;
   readonly outcome?: string;
+  readonly usage?: UsageAggregate;
   readonly isCurrent: boolean;
 };