@wichayutdew/pi-workflows 2.5.1 → 2.7.0

package/src/harness/artifact-contract.ts

@@ -0,0 +1,46 @@
+import type { ArtifactContract } from '../config/types.ts';
+
+function countOccurrences(value: string, substring: string): number {
+  let count = 0;
+  let offset = 0;
+  while (true) {
+    const match = value.indexOf(substring, offset);
+    if (match === -1) return count;
+    count += 1;
+    offset = match + substring.length;
+  }
+}
+
+export function validateArtifactContract(
+  artifact: string,
+  contract: ArtifactContract | undefined,
+): string | undefined {
+  if (!contract) return undefined;
+  if (artifact.length > contract.maxChars) {
+    return `gate artifact exceeds ${contract.maxChars} characters`;
+  }
+  const required = contract.requiredSubstrings.find(
+    (substring) => !artifact.includes(substring),
+  );
+  if (required) {
+    return `gate artifact is missing required text: ${JSON.stringify(required)}`;
+  }
+  const forbidden = contract.forbiddenSubstrings.find((substring) =>
+    artifact.includes(substring),
+  );
+  if (forbidden) {
+    return `gate artifact contains forbidden text: ${JSON.stringify(forbidden)}`;
+  }
+  for (const group of contract.equalOccurrenceGroups) {
+    const counts = group.map((substring) =>
+      countOccurrences(artifact, substring),
+    );
+    if (counts.some((count) => count === 0)) {
+      return `gate artifact is missing required repeated text: ${JSON.stringify(group)}`;
+    }
+    if (!counts.every((count) => count === counts[0])) {
+      return `gate artifact has unequal repeated text counts: ${JSON.stringify(group)}`;
+    }
+  }
+  return undefined;
+}

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

@@ -1,33 +1,28 @@
 import { failRun } from '../engine/transitions.ts';
 import type { HarnessActionContext as FullHarnessActionContext } from './action-context.ts';
-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';
+import type { ActiveDelegation } from './types.ts';
+
+const boundedFailureField = (value: string): string =>
+  value.length <= 500 ? value : `${value.slice(0, 499)}…`;
 
 type HarnessActionContext = Pick<
   FullHarnessActionContext,
   | 'activeDelegation'
   | 'catalog'
   | 'cleanupDelegation'
-  | 'delegationFailures'
   | 'dependencies'
-  | 'isSessionActive'
   | 'isolateMainSessionTools'
   | 'latestContext'
-  | 'launchCurrentStep'
   | 'mainSteps'
   | 'pauseForExecutionFailure'
   | 'persist'
   | 'pi'
   | 'restoreBaselineTools'
   | 'run'
-  | 'sessionEpoch'
   | 'subagents'
   | 'updateStatus'
 >;
@@ -41,12 +36,6 @@ export type DelegationControlActions = {
     this: HarnessActionContext,
     active: ActiveDelegation,
   ) => Promise<void>;
-  retryDelegationAfterFailure: (
-    this: HarnessActionContext,
-    active: ActiveDelegation,
-    failure: DelegationFailureDetails | undefined,
-    reason: string,
-  ) => boolean;
   pauseForDelegationFailure: (
     this: HarnessActionContext,
     reason: string,
@@ -119,53 +108,6 @@ async function cleanupDelegation(
   }
 }
 
-function retryDelegationAfterFailure(
-  this: HarnessActionContext,
-  active: ActiveDelegation,
-  failure: DelegationFailureDetails | undefined,
-  reason: string,
-): boolean {
-  if (!failure) return false;
-  const fingerprint =
-    this.delegationFailures.delegationFailureFingerprint(failure);
-  const isRepeatedFailure = active.recoveryFailures.some(
-    (previousFailure) => previousFailure.fingerprint === fingerprint,
-  );
-  if (
-    active.recoveryAttemptCount >= MAX_DELEGATION_RECOVERY_ATTEMPTS ||
-    isRepeatedFailure ||
-    !this.delegationFailures.isRetryableTerminalFailure(failure) ||
-    !this.delegationFailures.isSafeToRetryDelegation(
-      active.policy,
-      active.broadRecoveryAuthorized,
-      failure.replayAudit,
-    ) ||
-    !this.isSessionActive ||
-    this.sessionEpoch !== active.sessionEpoch ||
-    !this.run ||
-    this.run.status !== 'running' ||
-    this.run.runId !== active.runId ||
-    this.run.currentStepId !== active.stepId ||
-    this.run.currentStepDigest !== active.stepDigest ||
-    this.activeDelegation
-  ) {
-    return false;
-  }
-  const workflow = this.catalog.workflows.get(this.run.workflowId);
-  if (!workflow) return false;
-
-  const attempt = active.recoveryAttemptCount + 1;
-  this.latestContext?.ui.notify(
-    `Automatic recovery for "${active.stepId}" after a subagent failure (${attempt}/${MAX_DELEGATION_RECOVERY_ATTEMPTS})`,
-    'warning',
-  );
-  this.launchCurrentStep(workflow, {
-    attempt,
-    failures: [...active.recoveryFailures, { fingerprint, reason }],
-  });
-  return true;
-}
-
 function pauseForDelegationFailure(
   this: HarnessActionContext,
   reason: string,
@@ -266,7 +208,6 @@ export function createDelegationControlActions(): DelegationControlActions {
   return {
     cancelActiveDelegation,
     cleanupDelegation,
-    retryDelegationAfterFailure,
     pauseForDelegationFailure,
     pauseForExecutionFailure,
     retainUnconfirmedDelegation,

package/src/harness/delegation-plan.ts

@@ -1,19 +1,17 @@
 import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
+import { loadAgentProfile } from '../agents/profile.ts';
 import type { LoadedWorkflow, WorkflowStep } from '../config/types.ts';
 import type { WorkflowRun } from '../engine/state.ts';
 import { allowedOutcomes } from '../engine/transitions.ts';
 import { digest } from '../digest.ts';
-import { deriveSubagentSessionRoot } from '../integrations/subagents/diagnostics.ts';
 import {
   encodeChildPolicy,
   type ChildStepPolicy,
   type SubagentDelegationRequest,
 } from '../integrations/subagents/protocol.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';
+import { buildDelegatedStepTask } from '../prompt.ts';
 import type { WorkflowHarnessDependencies } from './dependencies.ts';
-import type { ActiveDelegation, DelegationRecovery } from './types.ts';
+import type { ActiveDelegation } from './types.ts';
 
 type DelegationPlanInput = {
   workflow: LoadedWorkflow;
@@ -21,7 +19,6 @@ type DelegationPlanInput = {
   step: WorkflowStep;
   sessionEpoch: number;
   latestContext: ExtensionContext | undefined;
-  recovery: DelegationRecovery | undefined;
 };
 
 export type DelegationPlan =
@@ -35,13 +32,6 @@ export type DelegationPlan =
       request: SubagentDelegationRequest;
     };
 
-function delegationTranscriptBinding(
-  requestId: string,
-  policyDigest: string,
-): string {
-  return `<pi-workflows-delegation-binding-v1>${requestId}:${policyDigest}</pi-workflows-delegation-binding-v1>`;
-}
-
 /**
  * Creates one immutable subagent request from workflow state and injected
  * identity/workspace effects.
@@ -55,12 +45,21 @@ export function createDelegationPlan(
     | 'resolveWorkspaceDirectory'
   >,
 ): DelegationPlan {
-  const { workflow, run, step, latestContext, recovery } = input;
-  const subagent = step.subagent;
-  if (!subagent) {
+  const { workflow, run, step, latestContext } = input;
+  const agent = step.agent?.name;
+  if (!agent) {
+    return {
+      kind: 'invalid',
+      reason: `Step "${run.currentStepId}" has no agent profile`,
+    };
+  }
+  let agentProfile;
+  try {
+    agentProfile = loadAgentProfile(agent);
+  } catch (error) {
     return {
       kind: 'invalid',
-      reason: `Step "${run.currentStepId}" has no subagent configuration`,
+      reason: error instanceof Error ? error.message : String(error),
     };
   }
   if (!run.cwd) {
@@ -160,7 +159,7 @@ export function createDelegationPlan(
   const policyDigest = digest({
     version: 1,
     requestId,
-    agent: subagent.agent,
+    agent,
     runId: run.runId,
     stepId: run.currentStepId,
     stepDigest: run.currentStepDigest,
@@ -174,7 +173,7 @@ export function createDelegationPlan(
   const policy: ChildStepPolicy = {
     version: 1,
     requestId,
-    agent: subagent.agent,
+    agent,
     workflowId: workflow.definition.id,
     runId: run.runId,
     stepId: run.currentStepId,
@@ -195,22 +194,7 @@ export function createDelegationPlan(
     ...(step.gate ? { gateSubmitOutcome: step.gate.submitOutcome } : {}),
     ...(step.workspace ? { workspace: structuredClone(step.workspace) } : {}),
   };
-  const trustedSessionRoot = deriveSubagentSessionRoot(
-    latestContext.sessionManager.getSessionFile(),
-  );
-  const transcriptTask = [
-    buildDelegatedStepTask(workflow, run, ''),
-    delegationTranscriptBinding(requestId, policyDigest),
-    ...(recovery
-      ? [
-          automaticRecoveryTask(
-            recovery.failures.map(({ reason }) => reason),
-            recovery.attempt,
-            MAX_DELEGATION_RECOVERY_ATTEMPTS,
-          ),
-        ]
-      : []),
-  ].join('\n\n');
+  const task = buildDelegatedStepTask(workflow, run, '');
   const active: ActiveDelegation = {
     requestId,
     runId: run.runId,
@@ -219,56 +203,18 @@ export function createDelegationPlan(
     sessionEpoch: input.sessionEpoch,
     resultDirectory: workspace.resultDirectory,
     policy,
-    transcriptTask,
-    agent: subagent.agent,
-    ...(trustedSessionRoot ? { trustedSessionRoot } : {}),
-    broadRecoveryAuthorized: subagent.retryToolFailures,
-    recoveryAttemptCount: recovery?.attempt ?? 0,
-    recoveryFailures: recovery?.failures ?? [],
+    transcriptTask: task,
+    agent,
   };
   const request: SubagentDelegationRequest = {
     version: 1,
     requestId,
-    agent: subagent.agent,
-    task: `${encodeChildPolicy(policy)}\n\n${transcriptTask}`,
-    // Workflow steps are isolation boundaries. Parent/sibling transcripts are
-    // replaced by the explicit workflow handoff.
-    context: 'fresh',
+    agent,
+    task: `${encodeChildPolicy(policy)}\n\n${task}`,
     cwd: delegationCwd,
-    timeoutMs: subagent.timeoutMs,
-    skill:
-      step.permissions.skills.length > 0 ? [...step.permissions.skills] : false,
-    output: false,
-    // TypeBox schemas are structurally JSON objects, but the upstream contract
-    // exposes a generic record.
-    outputSchema: WORKFLOW_COMPLETION_PARAMETERS as unknown as Record<
-      string,
-      unknown
-    >,
-    agentContract: { version: 1 },
-    artifacts: subagent.artifacts,
-    ...(subagent.model ? { model: subagent.model } : {}),
-    ...(subagent.turnBudget
-      ? { turnBudget: structuredClone(subagent.turnBudget) }
-      : {}),
-    ...(subagent.toolBudget
-      ? {
-          toolBudget: {
-            hard: subagent.toolBudget.hard,
-            ...(subagent.toolBudget.soft === undefined
-              ? {}
-              : { soft: subagent.toolBudget.soft }),
-            ...(subagent.toolBudget.block === undefined
-              ? {}
-              : {
-                  block:
-                    subagent.toolBudget.block === '*'
-                      ? '*'
-                      : [...subagent.toolBudget.block],
-                }),
-          },
-        }
-      : {}),
+    timeoutMs: 900_000,
+    ...(agentProfile.model ? { model: agentProfile.model } : {}),
+    ...(agentProfile.thinking ? { thinking: agentProfile.thinking } : {}),
   };
 
   return { kind: 'ready', active, request };

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

@@ -4,13 +4,10 @@ import {
   type SubagentDelegationUpdate,
 } from '../integrations/subagents/protocol.ts';
 import { advanceRun } from '../engine/transitions.ts';
-import {
-  attachSubagentTranscript,
-  recordCurrentStepResult,
-} from '../engine/step-trace.ts';
+import { 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 type { ActiveDelegation } from './types.ts';
 import { resolveStepEffects } from './step-effects.ts';
 
 type HarnessActionContext = Pick<
@@ -18,7 +15,6 @@ type HarnessActionContext = Pick<
   | 'activeDelegation'
   | 'catalog'
   | 'cleanupDelegation'
-  | 'delegationFailures'
   | 'dependencies'
   | 'finishDelegation'
   | 'isSessionActive'
@@ -27,7 +23,6 @@ type HarnessActionContext = Pick<
   | 'pauseForDelegationFailure'
   | 'releaseMainAfterCancellation'
   | 'retainUnconfirmedDelegation'
-  | 'retryDelegationAfterFailure'
   | 'run'
   | 'sessionEpoch'
   | 'settleAfterTransition'
@@ -70,11 +65,22 @@ function handleDelegationUpdate(
 ): void {
   if (this.activeDelegation !== active) return;
   const progress = [
+    update.activity,
     update.currentTool ? `tool ${update.currentTool}` : undefined,
     update.toolCount !== undefined ? `${update.toolCount} calls` : undefined,
     update.tokens !== undefined ? `${update.tokens} tokens` : undefined,
   ].filter((part): part is string => part !== undefined);
   active.progress = progress.join(', ') || 'running';
+  if (update.detail) {
+    const previous = active.activityLog ?? [];
+    const replacesPreviousResponse =
+      update.detail.startsWith('response: ') &&
+      previous.at(-1)?.startsWith('response: ');
+    active.activityLog = [
+      ...(replacesPreviousResponse ? previous.slice(0, -1) : previous),
+      update.detail,
+    ].slice(-8);
+  }
   this.updateStatus();
 }
 
@@ -128,7 +134,6 @@ async function finishDelegation(
     return;
   }
   this.activeDelegation = undefined;
-  let terminalFailure: DelegationFailureDetails | undefined;
   let cleanupAttempted = false;
 
   try {
@@ -144,80 +149,15 @@ 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' ||
-      this.delegationFailures.hasContradictoryCompletion(response)
-    ) {
-      const failure = await this.delegationFailures.describeDelegationFailure(
-        active,
-        response,
-      );
-      terminalFailure = failure;
-      if (
-        response.status !== 'failed' ||
-        failure.diagnostic?.completionAfterFailure !== true
-      ) {
-        throw new Error(failure.reason);
-      }
-      const projectionError = this.delegationFailures.recoveredProjectionError(
-        active,
-        response,
-        failure.diagnostic,
+    if (response.status !== 'completed') {
+      throw new Error(
+        `Workflow worker "${active.agent}" ${response.status.replaceAll('_', ' ')}${response.error ? `: ${response.error}` : ''}`,
       );
-      if (projectionError) {
-        throw new Error(
-          this.delegationFailures.rejectedRecoveryReason(
-            failure,
-            projectionError,
-          ),
-        );
-      }
-      recoveredTerminalFailure = failure;
     }
     const requiredSkillWarning =
       step.requires.skills.length > 0
@@ -233,15 +173,6 @@ async function finishDelegation(
     try {
       serializedResult = await this.dependencies.readDelegatedResult(active);
     } catch (error) {
-      if (recoveredTerminalFailure) {
-        throw new Error(
-          this.delegationFailures.rejectedRecoveryReason(
-            recoveredTerminalFailure,
-            error,
-          ),
-          { cause: error },
-        );
-      }
       if (hasErrorCode(error, 'ENOENT')) {
         throw new Error(
           `Subagent "${active.agent}" completed without producing the required correlated structured_output result`,
@@ -251,49 +182,12 @@ async function finishDelegation(
       throw error;
     }
 
-    let result: WorkflowStepResult;
-    try {
-      const rawResult: unknown = JSON.parse(serializedResult);
-      result = parseDelegatedStepResult(rawResult, active.policy);
-    } catch (error) {
-      if (recoveredTerminalFailure) {
-        throw new Error(
-          this.delegationFailures.rejectedRecoveryReason(
-            recoveredTerminalFailure,
-            error,
-          ),
-          { cause: error },
-        );
-      }
-      throw error;
-    }
-    if (
-      recoveredTerminalFailure?.diagnostic &&
-      !this.delegationFailures.completionMatchesResult(
-        recoveredTerminalFailure.diagnostic,
-        result,
-        active.policy,
-      )
-    ) {
-      throw new Error(
-        this.delegationFailures.rejectedRecoveryReason(
-          recoveredTerminalFailure,
-          'structured_output transcript value does not match the correlated result',
-        ),
-      );
-    }
+    const rawResult: unknown = JSON.parse(serializedResult);
+    const result: WorkflowStepResult = parseDelegatedStepResult(
+      rawResult,
+      active.policy,
+    );
     const acceptedAt = terminalAt;
-    if (recoveredTerminalFailure) {
-      const isFalsePositive =
-        recoveredTerminalFailure.diagnostic?.correlation ===
-        'successful-output-before-completion';
-      this.latestContext?.ui.notify(
-        isFalsePositive
-          ? `Accepted "${active.stepId}" because the trusted child transcript proved the terminal tool error was a false positive and produced a matching structured result`
-          : `Accepted "${active.stepId}" because the child resolved an earlier tool failure and produced a valid structured result`,
-        'warning',
-      );
-    }
     if (step.gate?.submitOutcome === result.outcome) {
       this.run = recordCurrentStepResult(this.run, result, acceptedAt);
       await this.submitGate(
@@ -335,14 +229,7 @@ async function finishDelegation(
     const reason = error instanceof Error ? error.message : String(error);
     cleanupAttempted = true;
     await this.cleanupDelegation(active);
-    if (!this.retryDelegationAfterFailure(active, terminalFailure, reason)) {
-      const failureSummary = terminalFailure?.error
-        ? `Subagent ${terminalFailure.status.replaceAll('_', ' ')}: ${terminalFailure.error}`
-        : terminalFailure
-          ? `Subagent ${terminalFailure.status.replaceAll('_', ' ')}`
-          : reason;
-      this.pauseForDelegationFailure(reason, failureSummary);
-    }
+    this.pauseForDelegationFailure(reason);
   } finally {
     try {
       if (!cleanupAttempted) await this.cleanupDelegation(active);

package/src/harness/dependencies.ts

@@ -14,11 +14,6 @@ import {
   createSubagentDelegationClient,
   type SubagentDelegationClientController,
 } from '../integrations/subagents/client.ts';
-import {
-  auditCompletedDelegationTranscript,
-  readDelegationReplayAudit,
-  readToolFailureDiagnostic,
-} from '../integrations/subagents/diagnostics.ts';
 import {
   createMainStepRuntime,
   type MainStepRuntimeController,
@@ -61,9 +56,6 @@ export type WorkflowHarnessDependencies = {
   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,
@@ -150,11 +142,8 @@ const DEFAULT_DEPENDENCIES: WorkflowHarnessDependencies = {
   requestPlannotatorReview,
   requestPlannotatorReviewStatus,
   requestPromptGateReview,
-  readDelegationReplayAudit,
-  readToolFailureDiagnostic,
-  auditCompletedDelegationTranscript,
   showWorkflowStatus,
-  createSubagentClient: (pi) => createSubagentDelegationClient(pi.events),
+  createSubagentClient: () => createSubagentDelegationClient(),
   createMainStepRuntime: (pi) => createMainStepRuntime({ pi }),
   createMutationQueue: createSerialTaskQueue,
   flushUnwrittenSession,

package/src/harness/gate-submission-action.ts

@@ -1,7 +1,9 @@
 import type { LoadedWorkflow } from '../config/types.ts';
 import type { WorkflowRun } from '../engine/state.ts';
+import { validateArtifactContract } from './artifact-contract.ts';
 import {
   attachGateReviewId,
+  advanceRun,
   beginGate,
   failGate,
   failRun,
@@ -19,6 +21,7 @@ type HarnessActionContext = Pick<
   | 'pi'
   | 'restoreBaselineTools'
   | 'run'
+  | 'settleAfterTransition'
   | 'sessionEpoch'
   | 'updateStatus'
 >;
@@ -63,6 +66,31 @@ async function submitGate(
     this.dependencies.createRequestId();
   const step = workflow.definition.steps[originalRun.currentStepId];
   if (!step?.gate) throw new Error('Current step has no gate');
+  const contractError = validateArtifactContract(
+    artifact,
+    step.gate.artifactContract,
+  );
+  if (contractError) {
+    if (step.gate.artifactContract?.onValidationFailure !== 'retry') {
+      throw new Error(contractError);
+    }
+    const retrySummary = `Artifact contract failed: ${contractError}`;
+    this.run = advanceRun(
+      workflow,
+      originalRun,
+      'retry',
+      retrySummary,
+      this.dependencies.now(),
+    );
+    this.persist();
+    this.updateStatus();
+    this.settleAfterTransition(workflow, {
+      stepId: originalRun.currentStepId,
+      outcome: 'retry',
+      summary: retrySummary,
+    });
+    return;
+  }
 
   this.run = beginGate(
     workflow,

package/src/harness/status-actions.ts

@@ -63,6 +63,7 @@ function workflowStatusSnapshot(
       agent: this.activeDelegation.agent,
       requestId: this.activeDelegation.requestId,
       progress: this.activeDelegation.progress ?? 'starting',
+      activityLog: this.activeDelegation.activityLog ?? [],
     };
   } else if (this.mainSteps.activeStepId) {
     execution = { kind: 'main' };
@@ -77,6 +78,25 @@ function workflowStatusSnapshot(
 
 function updateStatus(this: StatusContext): void {
   refreshStatusWhileRunning.call(this);
+  const run = this.run;
+  this.pi.events.emit('pi-workflows:state', {
+    state:
+      run?.status === 'running'
+        ? 'working'
+        : run?.status === 'awaiting-gate' || run?.status === 'paused'
+          ? 'blocked'
+          : run?.status === 'completed'
+            ? 'completed'
+            : 'interrupted',
+    workflowId: run?.workflowId,
+    stepId: run?.currentStepId,
+    message:
+      run?.status === 'completed'
+        ? `Workflow "${run.workflowId}" completed`
+        : run?.status === 'paused'
+          ? run.pauseReason
+          : undefined,
+  });
   if (!this.latestContext) return;
   if (this.legacyProgressWidgetContext !== this.latestContext) {
     this.latestContext.ui.setWidget(LEGACY_PROGRESS_WIDGET_KEY, undefined);