@wichayutdew/pi-workflows 1.0.1 → 2.0.0

package/src/harness/action-context.ts

@@ -22,6 +22,7 @@ import type { WorkflowStepResult } from '../runtime/step-result.ts';
 import type { WorkflowStatusSnapshot } from '../workflow-status.ts';
 import type { DelegationFailureActions } from './delegation-failure.ts';
 import type { WorkflowHarnessDependencies } from './dependencies.ts';
+import type { SettledStepReport } from './step-reporting.ts';
 import type {
   ActiveDelegation,
   ActivePromptReview,
@@ -61,6 +62,10 @@ export type HarnessActionContext = {
   legacyProgressWidgetContext: ExtensionContext | undefined;
   workflowIds: () => Array<string>;
   list: (context: ExtensionCommandContext) => Promise<void>;
+  doctor: (
+    workflowId: string,
+    context: ExtensionCommandContext,
+  ) => Promise<void>;
   start: (
     workflowId: string,
     input: string,
@@ -74,8 +79,11 @@ export type HarnessActionContext = {
   ) => Promise<void>;
   pause: (reason: string, context: ExtensionCommandContext) => Promise<void>;
   pauseNow: (reason: string, context: ExtensionCommandContext) => Promise<void>;
-  resume: (context: ExtensionCommandContext) => Promise<void>;
-  resumeNow: (context: ExtensionCommandContext) => Promise<void>;
+  resume: (input: string, context: ExtensionCommandContext) => Promise<void>;
+  resumeNow: (
+    context: ExtensionCommandContext,
+    input?: string,
+  ) => Promise<void>;
   abort: (reason: string, context: ExtensionCommandContext) => Promise<void>;
   abortNow: (reason: string, context: ExtensionCommandContext) => Promise<void>;
   reload: (context: ExtensionCommandContext) => Promise<void>;
@@ -93,6 +101,16 @@ export type HarnessActionContext = {
     run: WorkflowRun,
     step: WorkflowStep,
   ) => void;
+  queueMainStepLog: (
+    identity: MainStepIdentity,
+    lines: ReadonlyArray<string>,
+    context: ExtensionContext,
+  ) => Promise<void>;
+  recordMainStepLog: (
+    identity: MainStepIdentity,
+    lines: ReadonlyArray<string>,
+    context: ExtensionContext,
+  ) => Promise<void>;
   queueMainStepResult: (
     identity: MainStepIdentity,
     result: WorkflowStepResult | undefined,
@@ -123,8 +141,12 @@ export type HarnessActionContext = {
     failure: DelegationFailureDetails | undefined,
     reason: string,
   ) => boolean;
-  pauseForDelegationFailure: (reason: string) => void;
-  pauseForExecutionFailure: (label: string, reason: string) => void;
+  pauseForDelegationFailure: (reason: string, failureSummary?: string) => void;
+  pauseForExecutionFailure: (
+    label: string,
+    reason: string,
+    failureSummary?: string,
+  ) => void;
   retainUnconfirmedDelegation: (
     active: ActiveDelegation,
     reason: string,
@@ -134,6 +156,7 @@ export type HarnessActionContext = {
     workflow: LoadedWorkflow,
     originalRun: WorkflowRun,
     outcome: string,
+    summary: string,
     artifact: string,
   ) => Promise<void>;
   launchPromptReview: (
@@ -157,7 +180,10 @@ export type HarnessActionContext = {
   cancelPromptReview: () => void;
   registerPlannotatorResults: () => void;
   handlePlannotatorResult: (data: unknown) => Promise<void>;
-  settleAfterTransition: (workflow: LoadedWorkflow) => void;
+  settleAfterTransition: (
+    workflow: LoadedWorkflow,
+    report: SettledStepReport,
+  ) => void;
   preflight: (workflow: LoadedWorkflow, stepId: string) => Array<string>;
   isolateMainSessionTools: () => void;
   restoreBaselineTools: () => void;
@@ -176,6 +202,5 @@ export type HarnessActionContext = {
   refreshStatusWhileRunning: () => void;
   stopStatusRefresh: () => void;
   registerWorkflowStatusShortcut: () => void;
-  openWorkflowStatus: (context: ExtensionContext) => void;
   showWorkflowStatus: (context: ExtensionContext) => Promise<void>;
 };

package/src/harness/core-actions.ts

@@ -7,6 +7,14 @@ import { failRun, pauseRun } from '../engine/transitions.ts';
 import { preflightStep } from '../preflight.ts';
 import type { HarnessActionContext as FullHarnessActionContext } from './action-context.ts';
 import { formatCatalogDiagnostics } from './catalog.ts';
+import {
+  conciseStepFailureSummary,
+  conciseStepPauseSummary,
+  reportFailedStep,
+  reportPausedStep,
+  reportSettledStep,
+  type SettledStepReport,
+} from './step-reporting.ts';
 
 const STATE_ENTRY_TYPE = 'pi-workflows-state-v1';
 
@@ -39,6 +47,7 @@ export type CoreActions = {
   settleAfterTransition: (
     this: HarnessActionContext,
     workflow: LoadedWorkflow,
+    report: SettledStepReport,
   ) => void;
   preflight: (
     this: HarnessActionContext,
@@ -71,6 +80,7 @@ export type CoreActions = {
 function settleAfterTransition(
   this: HarnessActionContext,
   workflow: LoadedWorkflow,
+  report: SettledStepReport,
 ): void {
   if (!this.run) return;
   if (this.run.status === 'running') {
@@ -85,6 +95,14 @@ function settleAfterTransition(
   }
 
   this.persist();
+  reportSettledStep(this.pi, workflow, this.run, report);
+  if (
+    this.run.status === 'paused' &&
+    this.run.failedStepId === this.run.currentStepId &&
+    this.run.pauseReason
+  ) {
+    reportFailedStep(this.pi, workflow, this.run, this.run.pauseReason);
+  }
   if (this.run.status !== 'running') {
     this.restoreBaselineTools();
     this.updateStatus();
@@ -94,8 +112,13 @@ function settleAfterTransition(
         'info',
       );
     } else if (this.run.status === 'paused') {
+      const reason = this.run.pauseReason ?? 'manual action required';
       this.latestContext?.ui.notify(
-        `Workflow paused: ${this.run.pauseReason ?? 'manual action required'}`,
+        `Workflow paused: ${
+          this.run.failedStepId
+            ? conciseStepFailureSummary(reason)
+            : conciseStepPauseSummary(reason)
+        }`,
         'warning',
       );
     }
@@ -195,6 +218,12 @@ function restoreFromSession(
       this.dependencies.now(),
     );
     this.persist();
+    reportPausedStep(
+      this.pi,
+      this.catalog.workflows.get(this.run.workflowId),
+      this.run,
+      this.run.pauseReason ?? 'Session was restored',
+    );
   }
   if (!this.run && previousBaseline) {
     this.pi.setActiveTools([...previousBaseline]);

package/src/harness/delegation-control-actions.ts

@@ -4,6 +4,10 @@ import {
   boundedFailureField,
   MAX_DELEGATION_RECOVERY_ATTEMPTS,
 } from './delegation-retry-policy.ts';
+import {
+  conciseStepFailureSummary,
+  reportFailedStep,
+} from './step-reporting.ts';
 import type { ActiveDelegation, DelegationFailureDetails } from './types.ts';
 
 type HarnessActionContext = Pick<
@@ -20,6 +24,7 @@ type HarnessActionContext = Pick<
   | 'mainSteps'
   | 'pauseForExecutionFailure'
   | 'persist'
+  | 'pi'
   | 'restoreBaselineTools'
   | 'run'
   | 'sessionEpoch'
@@ -45,11 +50,13 @@ export type DelegationControlActions = {
   pauseForDelegationFailure: (
     this: HarnessActionContext,
     reason: string,
+    failureSummary?: string,
   ) => void;
   pauseForExecutionFailure: (
     this: HarnessActionContext,
     label: string,
     reason: string,
+    failureSummary?: string,
   ) => void;
   retainUnconfirmedDelegation: (
     this: HarnessActionContext,
@@ -162,14 +169,16 @@ function retryDelegationAfterFailure(
 function pauseForDelegationFailure(
   this: HarnessActionContext,
   reason: string,
+  failureSummary = reason,
 ): void {
-  this.pauseForExecutionFailure('Subagent step', reason);
+  this.pauseForExecutionFailure('Subagent step', reason, failureSummary);
 }
 
 function pauseForExecutionFailure(
   this: HarnessActionContext,
   label: string,
   reason: string,
+  failureSummary = reason,
 ): void {
   if (!this.run || this.run.status !== 'running') return;
   this.mainSteps.deactivate();
@@ -179,6 +188,12 @@ function pauseForExecutionFailure(
     this.dependencies.now(),
   );
   this.persist();
+  reportFailedStep(
+    this.pi,
+    this.catalog.workflows.get(this.run.workflowId),
+    this.run,
+    failureSummary,
+  );
   if (this.activeDelegation) {
     this.isolateMainSessionTools();
   } else {
@@ -186,7 +201,7 @@ function pauseForExecutionFailure(
   }
   this.updateStatus();
   this.latestContext?.ui.notify(
-    `Workflow paused at "${this.run.currentStepId}": ${reason}`,
+    `Workflow paused at "${this.run.currentStepId}": ${conciseStepFailureSummary(failureSummary)}`,
     'error',
   );
 }
@@ -198,6 +213,7 @@ function retainUnconfirmedDelegation(
 ): void {
   active.cancelling = true;
   active.progress = 'cancellation unconfirmed';
+  let didFail = false;
   if (this.run?.status === 'running') {
     this.run = failRun(
       this.run,
@@ -205,6 +221,15 @@ function retainUnconfirmedDelegation(
       this.dependencies.now(),
     );
     this.persist();
+    didFail = true;
+  }
+  if (didFail && this.run) {
+    reportFailedStep(
+      this.pi,
+      this.catalog.workflows.get(this.run.workflowId),
+      this.run,
+      reason,
+    );
   }
   this.isolateMainSessionTools();
   this.updateStatus();

package/src/harness/delegation-failure.ts

@@ -2,6 +2,7 @@ import type { WorkflowStepResult } from '../runtime/step-result.ts';
 import {
   failedToolName,
   formatToolFailureDiagnostic,
+  type CompletedDelegationTranscriptAudit,
 } from '../integrations/subagents/diagnostics.ts';
 import type {
   ChildStepPolicy,
@@ -28,6 +29,10 @@ import type {
 export type DelegationFailureActions = {
   delegationFailureFingerprint: (failure: DelegationFailureDetails) => string;
   hasContradictoryCompletion: (response: SubagentDelegationResponse) => boolean;
+  completedResponseAudit: (
+    active: ActiveDelegation,
+    response: SubagentDelegationResponse,
+  ) => Promise<CompletedDelegationTranscriptAudit>;
   isRetryableTerminalFailure: (failure: DelegationFailureDetails) => boolean;
   isSafeToRetryDelegation: (
     policy: ChildStepPolicy,
@@ -134,8 +139,42 @@ export function createDelegationFailureActions(
   dependencies: Pick<
     WorkflowHarnessDependencies,
     'readDelegationReplayAudit' | 'readToolFailureDiagnostic'
-  >,
+  > &
+    Partial<
+      Pick<WorkflowHarnessDependencies, 'auditCompletedDelegationTranscript'>
+    >,
 ): DelegationFailureActions {
+  const responseIdentity = (
+    active: ActiveDelegation,
+    response: SubagentDelegationResponse,
+  ): { readonly runId: string; readonly childIndex: 0 } | undefined => {
+    if (
+      response.childIndex !== 0 ||
+      typeof response.runId !== 'string' ||
+      (response.agent !== undefined && response.agent !== active.agent)
+    ) {
+      return undefined;
+    }
+    return { runId: response.runId, childIndex: 0 };
+  };
+
+  const completedResponseAudit = async (
+    active: ActiveDelegation,
+    response: SubagentDelegationResponse,
+  ): Promise<CompletedDelegationTranscriptAudit> => {
+    if (!dependencies.auditCompletedDelegationTranscript) {
+      return {
+        verified: false,
+        reason: 'completed transcript auditing is unavailable',
+      };
+    }
+    return dependencies.auditCompletedDelegationTranscript(
+      response.sessionFile,
+      active.trustedSessionRoot,
+      responseIdentity(active, response),
+    );
+  };
+
   const describeDelegationFailure = async (
     active: ActiveDelegation,
     response: SubagentDelegationResponse,
@@ -144,13 +183,7 @@ export function createDelegationFailureActions(
     const terminalError = nonEmptyTerminalError(response);
     const error =
       terminalError ?? 'The subagent returned no terminal error details.';
-    const isResponseIdentityValid =
-      response.childIndex === 0 &&
-      (response.agent === undefined || response.agent === active.agent);
-    const identity =
-      isResponseIdentityValid && response.runId !== undefined
-        ? { runId: response.runId, childIndex: 0 }
-        : undefined;
+    const identity = responseIdentity(active, response);
     const [diagnostic, replayAudit] = await Promise.all([
       dependencies.readToolFailureDiagnostic(
         response.sessionFile,
@@ -166,7 +199,6 @@ export function createDelegationFailureActions(
         {
           task: active.transcriptTask,
           bashPermission: active.policy.permissions.bash,
-          approvedBashCommands: active.policy.approvedBashCommands ?? [],
         },
       ),
     ]);
@@ -205,6 +237,7 @@ export function createDelegationFailureActions(
   return {
     delegationFailureFingerprint,
     hasContradictoryCompletion,
+    completedResponseAudit,
     isRetryableTerminalFailure,
     isSafeToRetryDelegation,
     rejectedRecoveryReason,

package/src/harness/delegation-plan.ts

@@ -9,10 +9,6 @@ import {
   type ChildStepPolicy,
   type SubagentDelegationRequest,
 } from '../integrations/subagents/protocol.ts';
-import {
-  narrowApprovedBashCommands,
-  resolveReviewedRepositoryCwd,
-} from '../policy/approved-commands.ts';
 import { automaticRecoveryTask, buildDelegatedStepTask } from '../prompt.ts';
 import { WORKFLOW_COMPLETION_PARAMETERS } from '../runtime/completion-tool.ts';
 import { MAX_DELEGATION_RECOVERY_ATTEMPTS } from './delegation-retry-policy.ts';
@@ -46,17 +42,6 @@ function delegationTranscriptBinding(
   return `<pi-workflows-delegation-binding-v1>${requestId}:${policyDigest}</pi-workflows-delegation-binding-v1>`;
 }
 
-function approvedCommands(
-  run: WorkflowRun,
-  step: WorkflowStep,
-): ReadonlyArray<string> {
-  return narrowApprovedBashCommands(
-    run.reviewedArtifact ?? '',
-    run.stepHandoff ?? '',
-    step.permissions.bash.approvedSources ?? [],
-  );
-}
-
 /**
  * Creates one immutable subagent request from workflow state and injected
  * identity/workspace effects.
@@ -65,7 +50,9 @@ export function createDelegationPlan(
   input: DelegationPlanInput,
   dependencies: Pick<
     WorkflowHarnessDependencies,
-    'createDelegationWorkspace' | 'createRequestId' | 'currentWorkingDirectory'
+    | 'createDelegationWorkspace'
+    | 'createRequestId'
+    | 'resolveWorkspaceDirectory'
   >,
 ): DelegationPlan {
   const { workflow, run, step, latestContext, recovery } = input;
@@ -76,33 +63,100 @@ export function createDelegationPlan(
       reason: `Step "${run.currentStepId}" has no subagent configuration`,
     };
   }
+  if (!run.cwd) {
+    return {
+      kind: 'invalid',
+      reason:
+        'Workflow run has no captured working directory; abort it and start a new run',
+    };
+  }
+  if (!run.startCwd || !latestContext?.cwd) {
+    return {
+      kind: 'invalid',
+      reason:
+        'Workflow start directory or current session directory is unavailable; abort it and start a new run',
+    };
+  }
 
-  const reviewedRepository = resolveReviewedRepositoryCwd(
-    run.reviewedArtifact ?? '',
-  );
-  if (reviewedRepository.kind === 'invalid') {
-    return { kind: 'invalid', reason: reviewedRepository.reason };
+  let canonicalStartCwd: string;
+  let canonicalSessionCwd: string;
+  try {
+    canonicalStartCwd = dependencies.resolveWorkspaceDirectory({
+      candidateCwd: run.startCwd,
+      startCwd: run.startCwd,
+      allowedRoots: ['.'],
+    });
+    canonicalSessionCwd = dependencies.resolveWorkspaceDirectory({
+      candidateCwd: latestContext.cwd,
+      startCwd: latestContext.cwd,
+      allowedRoots: ['.'],
+    });
+  } catch (error) {
+    return {
+      kind: 'invalid',
+      reason: `Workflow start directory is no longer valid: ${
+        error instanceof Error ? error.message : String(error)
+      }`,
+    };
+  }
+  if (
+    canonicalStartCwd !== run.startCwd ||
+    canonicalSessionCwd !== canonicalStartCwd
+  ) {
+    return {
+      kind: 'invalid',
+      reason:
+        'Current session cwd does not match the captured workflow start directory',
+    };
   }
 
-  const delegationCwd =
-    reviewedRepository.kind === 'resolved'
-      ? reviewedRepository.cwd
-      : (latestContext?.cwd ?? dependencies.currentWorkingDirectory());
+  let delegationCwd = run.cwd;
+  const bindingEntry = [...run.history]
+    .reverse()
+    .find((entry) => entry.workspaceCwd !== undefined);
+  if (!bindingEntry && run.cwd !== run.startCwd) {
+    return {
+      kind: 'invalid',
+      reason:
+        'Workflow cwd differs from its start directory without a workspace binding',
+    };
+  }
+  if (bindingEntry) {
+    const binding = workflow.definition.steps[bindingEntry.stepId]?.workspace;
+    if (!binding || !run.startCwd || bindingEntry.workspaceCwd !== run.cwd) {
+      return {
+        kind: 'invalid',
+        reason:
+          'Workflow workspace binding no longer matches its persisted configuration',
+      };
+    }
+    try {
+      delegationCwd = dependencies.resolveWorkspaceDirectory({
+        candidateCwd: run.cwd,
+        startCwd: run.startCwd,
+        allowedRoots: binding.allowedRoots,
+      });
+    } catch (error) {
+      return {
+        kind: 'invalid',
+        reason: `Workflow workspace is no longer valid: ${
+          error instanceof Error ? error.message : String(error)
+        }`,
+      };
+    }
+    if (delegationCwd !== run.cwd) {
+      return {
+        kind: 'invalid',
+        reason:
+          'Workflow workspace no longer resolves to the bound canonical directory',
+      };
+    }
+  }
   const requestId =
     `${run.runId}:${run.currentStepId}:` + dependencies.createRequestId();
   const workspace = dependencies.createDelegationWorkspace();
   const outcomes = allowedOutcomes(workflow, run);
   const outcomeSet = new Set(outcomes);
-  const approvedBashCommands = approvedCommands(run, step);
-  const repositoryPolicy =
-    reviewedRepository.kind === 'resolved'
-      ? {
-          repositoryCwd: reviewedRepository.repositoryCwd,
-          ...(reviewedRepository.bootstrapping
-            ? { bootstrapCwd: reviewedRepository.cwd }
-            : {}),
-        }
-      : {};
   const policyDigest = digest({
     version: 1,
     requestId,
@@ -110,10 +164,12 @@ export function createDelegationPlan(
     runId: run.runId,
     stepId: run.currentStepId,
     stepDigest: run.currentStepDigest,
+    cwd: delegationCwd,
     capabilityPath: workspace.capabilityPath,
     resultPath: workspace.resultPath,
-    approvedBashCommands,
-    ...repositoryPolicy,
+    permissions: step.permissions,
+    outcomes,
+    ...(step.workspace ? { workspace: step.workspace } : {}),
   });
   const policy: ChildStepPolicy = {
     version: 1,
@@ -123,13 +179,12 @@ export function createDelegationPlan(
     runId: run.runId,
     stepId: run.currentStepId,
     stepTitle: step.title,
+    cwd: delegationCwd,
     policyDigest,
     capabilityPath: workspace.capabilityPath,
     capabilityToken: workspace.capabilityToken,
     resultPath: workspace.resultPath,
     permissions: structuredClone(step.permissions),
-    ...(approvedBashCommands.length > 0 ? { approvedBashCommands } : {}),
-    ...repositoryPolicy,
     outcomes,
     pauseOutcomes: Object.entries(step.transitions)
       .filter(
@@ -138,9 +193,10 @@ export function createDelegationPlan(
       .map(([outcome]) => outcome),
     summaryMaxChars: workflow.definition.summaryMaxChars,
     ...(step.gate ? { gateSubmitOutcome: step.gate.submitOutcome } : {}),
+    ...(step.workspace ? { workspace: structuredClone(step.workspace) } : {}),
   };
   const trustedSessionRoot = deriveSubagentSessionRoot(
-    latestContext?.sessionManager.getSessionFile(),
+    latestContext.sessionManager.getSessionFile(),
   );
   const transcriptTask = [
     buildDelegatedStepTask(workflow, run, ''),

package/src/harness/delegation-recovery-validation.ts

@@ -25,6 +25,7 @@ export function completionMatchesResult(
     'outcome',
     'summary',
     ...(result.artifact === undefined ? [] : ['artifact']),
+    ...(result.workspace === undefined ? [] : ['workspace']),
   ].sort();
   const actualKeys = Object.keys(value).sort();
   if (
@@ -45,7 +46,8 @@ export function completionMatchesResult(
     return (
       completion.outcome === result.outcome &&
       completion.summary === result.summary &&
-      completion.artifact === result.artifact
+      completion.artifact === result.artifact &&
+      completion.workspace?.cwd === result.workspace?.cwd
     );
   } catch {
     return false;

package/src/harness/delegation-response-actions.ts

@@ -4,9 +4,14 @@ import {
   type SubagentDelegationUpdate,
 } from '../integrations/subagents/protocol.ts';
 import { advanceRun } from '../engine/transitions.ts';
+import {
+  attachSubagentTranscript,
+  recordCurrentStepResult,
+} from '../engine/step-trace.ts';
 import type { WorkflowStepResult } from '../runtime/step-result.ts';
 import type { HarnessActionContext as FullHarnessActionContext } from './action-context.ts';
 import type { ActiveDelegation, DelegationFailureDetails } from './types.ts';
+import { resolveStepEffects } from './step-effects.ts';
 
 type HarnessActionContext = Pick<
   FullHarnessActionContext,
@@ -138,11 +143,51 @@ async function finishDelegation(
     ) {
       return;
     }
+    const terminalAt = this.dependencies.now();
+    if (
+      response.requestId === active.requestId &&
+      (response.agent === undefined || response.agent === active.agent) &&
+      response.sessionFile &&
+      active.trustedSessionRoot &&
+      typeof response.runId === 'string' &&
+      response.runId &&
+      response.childIndex === 0
+    ) {
+      try {
+        this.run = attachSubagentTranscript(
+          this.run,
+          active.requestId,
+          {
+            trustedRoot: active.trustedSessionRoot,
+            sessionFile: response.sessionFile,
+            runId: response.runId,
+            childIndex: response.childIndex,
+          },
+          terminalAt,
+        );
+      } catch {
+        // Status evidence is best-effort and cannot alter terminal handling.
+      }
+    }
     const workflow = this.catalog.workflows.get(this.run.workflowId);
     const step = workflow?.definition.steps[this.run.currentStepId];
     if (!workflow || !step) {
       throw new Error('Active workflow configuration is unavailable');
     }
+    if (response.status === 'completed') {
+      const transcriptAudit =
+        await this.delegationFailures.completedResponseAudit(active, response);
+      if (!transcriptAudit.verified) {
+        throw new Error(
+          `Subagent "${active.agent}" completed without a verifiable terminal transcript: ${transcriptAudit.reason}`,
+        );
+      }
+      if (transcriptAudit.warning) {
+        throw new Error(
+          `Subagent "${active.agent}" completed with an unresolved post-completion watchdog warning: ${transcriptAudit.warning}`,
+        );
+      }
+    }
     let recoveredTerminalFailure: DelegationFailureDetails | undefined;
     if (
       response.status !== 'completed' ||
@@ -237,6 +282,7 @@ async function finishDelegation(
         ),
       );
     }
+    const acceptedAt = terminalAt;
     if (recoveredTerminalFailure) {
       const isFalsePositive =
         recoveredTerminalFailure.diagnostic?.correlation ===
@@ -249,29 +295,53 @@ async function finishDelegation(
       );
     }
     if (step.gate?.submitOutcome === result.outcome) {
+      this.run = recordCurrentStepResult(this.run, result, acceptedAt);
       await this.submitGate(
         workflow,
         this.run,
         result.outcome,
+        result.summary,
         result.artifact ?? '',
       );
       return;
     }
 
+    const effects = resolveStepEffects(
+      this.run,
+      step,
+      result,
+      this.dependencies,
+    );
+    const tracedRun = recordCurrentStepResult(
+      this.run,
+      result,
+      acceptedAt,
+      effects.workspaceCwd,
+    );
     this.run = advanceRun(
       workflow,
-      this.run,
+      tracedRun,
       result.outcome,
       result.summary,
       this.dependencies.now(),
+      effects,
     );
-    this.settleAfterTransition(workflow);
+    this.settleAfterTransition(workflow, {
+      stepId: active.stepId,
+      outcome: result.outcome,
+      summary: result.summary,
+    });
   } catch (error) {
     const reason = error instanceof Error ? error.message : String(error);
     cleanupAttempted = true;
     await this.cleanupDelegation(active);
     if (!this.retryDelegationAfterFailure(active, terminalFailure, reason)) {
-      this.pauseForDelegationFailure(reason);
+      const failureSummary = terminalFailure?.error
+        ? `Subagent ${terminalFailure.status.replaceAll('_', ' ')}: ${terminalFailure.error}`
+        : terminalFailure
+          ? `Subagent ${terminalFailure.status.replaceAll('_', ' ')}`
+          : reason;
+      this.pauseForDelegationFailure(reason, failureSummary);
     }
   } finally {
     try {