@wichayutdew/pi-workflows 1.0.0 → 2.0.0

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 {

package/src/harness/delegation-retry-policy.ts

@@ -32,6 +32,9 @@ export function delegationFailureFingerprint(
           tool: normalizedFingerprintField(failure.diagnostic.tool),
           call: normalizedFingerprintField(failure.diagnostic.call),
           output: normalizedFingerprintField(failure.diagnostic.output),
+          postCompletionWarning: normalizedFingerprintField(
+            failure.diagnostic.postCompletionWarning,
+          ),
         }
       : undefined,
   });
@@ -62,6 +65,7 @@ export function isRetryableTerminalFailure(
   failure: DelegationFailureDetails,
 ): boolean {
   if (failure.recoveryBlocker !== undefined) return false;
+  if (failure.diagnostic?.postCompletionWarning !== undefined) return false;
   if (
     failure.status === 'timed_out' ||
     failure.status === 'turn_budget_exhausted' ||
@@ -96,9 +100,7 @@ export function isSafeToRetryDelegation(
 ): boolean {
   return (
     replayAudit?.replaySafe === true &&
-    (isReplayExplicitlyAuthorized ||
-      policy.permissions.bash.mode === 'deny' ||
-      policy.permissions.bash.mode === 'read-only')
+    (isReplayExplicitlyAuthorized || policy.permissions.bash.mode === 'deny')
   );
 }
 

package/src/harness/dependencies.ts

@@ -15,6 +15,7 @@ import {
   type SubagentDelegationClientController,
 } from '../integrations/subagents/client.ts';
 import {
+  auditCompletedDelegationTranscript,
   readDelegationReplayAudit,
   readToolFailureDiagnostic,
 } from '../integrations/subagents/diagnostics.ts';
@@ -28,6 +29,10 @@ import {
 } from '../runtime/serial-task-queue.ts';
 import { showWorkflowStatus } from '../workflow-status.ts';
 import type { ActiveDelegation } from './types.ts';
+import {
+  resolveWorkspaceDirectory,
+  type ResolveWorkspaceDirectoryOptions,
+} from './workspace-directory.ts';
 
 const MAX_DELEGATED_RESULT_BYTES = 1024 * 1024;
 
@@ -47,14 +52,17 @@ export type WorkflowHarnessDependencies = {
   readonly removeDelegationWorkspace: (
     resultDirectory: string,
   ) => Promise<void>;
-  readonly currentWorkingDirectory: () => string;
   readonly waitForDelay: (delayMs: number) => Promise<void>;
+  readonly resolveWorkspaceDirectory: (
+    options: ResolveWorkspaceDirectoryOptions,
+  ) => string;
   readonly loadCatalog: typeof loadCatalog;
   readonly requestPlannotatorReview: typeof requestPlannotatorReview;
   readonly requestPlannotatorReviewStatus: typeof requestPlannotatorReviewStatus;
   readonly requestPromptGateReview: typeof requestPromptGateReview;
   readonly readDelegationReplayAudit: typeof readDelegationReplayAudit;
   readonly readToolFailureDiagnostic: typeof readToolFailureDiagnostic;
+  readonly auditCompletedDelegationTranscript: typeof auditCompletedDelegationTranscript;
   readonly showWorkflowStatus: typeof showWorkflowStatus;
   readonly createSubagentClient: (
     pi: ExtensionAPI,
@@ -132,15 +140,16 @@ const DEFAULT_DEPENDENCIES: WorkflowHarnessDependencies = {
   readDelegatedResult,
   removeDelegationWorkspace: async (resultDirectory) =>
     rm(resultDirectory, { recursive: true, force: true }),
-  currentWorkingDirectory: () => process.cwd(),
   waitForDelay: async (delayMs) =>
     new Promise((resolve) => setTimeout(resolve, delayMs)),
+  resolveWorkspaceDirectory,
   loadCatalog,
   requestPlannotatorReview,
   requestPlannotatorReviewStatus,
   requestPromptGateReview,
   readDelegationReplayAudit,
   readToolFailureDiagnostic,
+  auditCompletedDelegationTranscript,
   showWorkflowStatus,
   createSubagentClient: (pi) => createSubagentDelegationClient(pi.events),
   createMainStepRuntime: (pi) => createMainStepRuntime({ pi }),