@wichayutdew/pi-workflows 2.5.1 → 2.7.0

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

@@ -15,7 +15,7 @@ import type { MainStepExecution } from '../runtime/main-step-runtime.ts';
 import type { WorkflowStepResult } from '../runtime/step-result.ts';
 import type { HarnessActionContext as FullHarnessActionContext } from './action-context.ts';
 import { createDelegationPlan } from './delegation-plan.ts';
-import type { DelegationRecovery, MainStepIdentity } from './types.ts';
+import type { MainStepIdentity } from './types.ts';
 import { resolveStepEffects } from './step-effects.ts';
 
 type HarnessActionContext = Pick<
@@ -50,7 +50,6 @@ export type StepExecutionActions = {
   launchCurrentStep: (
     this: HarnessActionContext,
     workflow: LoadedWorkflow,
-    recovery?: DelegationRecovery,
   ) => void;
   launchMainStep: (
     this: HarnessActionContext,
@@ -87,7 +86,6 @@ export type StepExecutionActions = {
 function launchCurrentStep(
   this: HarnessActionContext,
   workflow: LoadedWorkflow,
-  recovery?: DelegationRecovery,
 ): void {
   const run = this.run;
   if (
@@ -106,11 +104,6 @@ function launchCurrentStep(
     );
     return;
   }
-  if (!step.subagent) {
-    this.launchMainStep(workflow, run, step);
-    return;
-  }
-
   const plan = createDelegationPlan(
     {
       workflow,
@@ -118,7 +111,6 @@ function launchCurrentStep(
       step,
       sessionEpoch: this.sessionEpoch,
       latestContext: this.latestContext,
-      recovery,
     },
     this.dependencies,
   );
@@ -243,6 +235,7 @@ function launchMainStep(
     outcomes: allowedOutcomes(workflow, run),
     summaryMaxChars: workflow.definition.summaryMaxChars,
     ...(step.gate ? { gateSubmitOutcome: step.gate.submitOutcome } : {}),
+    ...(step.workspace ? { workspace: structuredClone(step.workspace) } : {}),
     onTrace: (lines, context) =>
       this.queueMainStepLog(identity, lines, context),
     onSettled: (result, context) =>

package/src/harness/types.ts

@@ -1,10 +1,5 @@
 import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
-import type { DelegationReplayAudit } from '../integrations/subagents/diagnostics.ts';
-import type {
-  ChildStepPolicy,
-  SubagentDelegationStatus,
-} from '../integrations/subagents/protocol.ts';
-import type { WorkflowHarnessDependencies } from './dependencies.ts';
+import type { ChildStepPolicy } from '../integrations/subagents/protocol.ts';
 
 export type ActiveDelegation = {
   requestId: string;
@@ -16,34 +11,11 @@ export type ActiveDelegation = {
   policy: ChildStepPolicy;
   transcriptTask: string;
   agent: string;
-  trustedSessionRoot?: string;
-  broadRecoveryAuthorized: boolean;
-  recoveryAttemptCount: number;
-  recoveryFailures: ReadonlyArray<DelegationRecoveryFailure>;
   progress?: string;
+  activityLog?: Array<string>;
   cancelling?: boolean;
 };
 
-export type DelegationRecoveryBlocker =
-  | 'cancelled'
-  | 'detached'
-  | 'inconsistent-timeout'
-  | 'interrupted'
-  | 'reported-mutation'
-  | 'stopped';
-
-export type DelegationFailureDetails = {
-  reason: string;
-  status: SubagentDelegationStatus;
-  error?: string;
-  exitCode?: number;
-  recoveryBlocker?: DelegationRecoveryBlocker;
-  diagnostic?: Awaited<
-    ReturnType<WorkflowHarnessDependencies['readToolFailureDiagnostic']>
-  >;
-  replayAudit?: DelegationReplayAudit;
-};
-
 export type MainStepIdentity = {
   requestId: string;
   runId: string;
@@ -65,13 +37,3 @@ export type WorkflowStartContext = {
   skills: () => ReadonlyArray<{ name: string }> | undefined;
   waitForIdle: () => Promise<void>;
 };
-
-export type DelegationRecoveryFailure = {
-  readonly fingerprint: string;
-  readonly reason: string;
-};
-
-export type DelegationRecovery = {
-  readonly attempt: number;
-  readonly failures: ReadonlyArray<DelegationRecoveryFailure>;
-};

package/src/harness.ts

@@ -24,10 +24,6 @@ import {
 import type { MainStepRuntimeController } from './runtime/main-step-runtime.ts';
 import type { SerialTaskQueueController } from './runtime/serial-task-queue.ts';
 import type { WorkflowStepResult } from './runtime/step-result.ts';
-import {
-  createDelegationFailureActions,
-  type DelegationFailureActions,
-} from './harness/delegation-failure.ts';
 import { createEmptyCatalog } from './harness/catalog.ts';
 import {
   createWorkflowHarnessDependencies,
@@ -36,8 +32,6 @@ import {
 import type {
   ActiveDelegation,
   ActivePromptReview,
-  DelegationRecovery,
-  DelegationFailureDetails,
   MainStepIdentity,
   WorkflowStartContext,
 } from './harness/types.ts';
@@ -79,7 +73,6 @@ const CORE_ACTIONS = createCoreActions();
 export class WorkflowHarness implements WorkflowCommandController {
   private readonly pi: ExtensionAPI;
   private readonly dependencies: WorkflowHarnessDependencies;
-  private readonly delegationFailures: DelegationFailureActions;
   private readonly subagents: SubagentDelegationClientController;
   private readonly mainSteps: MainStepRuntimeController;
   private catalog: WorkflowCatalog = createEmptyCatalog();
@@ -149,10 +142,8 @@ export class WorkflowHarness implements WorkflowCommandController {
     LIFECYCLE_ACTIONS.registerLifecycle;
   private readonly registerPolicy: () => void =
     LIFECYCLE_ACTIONS.registerPolicy;
-  private readonly launchCurrentStep: (
-    workflow: LoadedWorkflow,
-    recovery?: DelegationRecovery,
-  ) => void = STEP_EXECUTION_ACTIONS.launchCurrentStep;
+  private readonly launchCurrentStep: (workflow: LoadedWorkflow) => void =
+    STEP_EXECUTION_ACTIONS.launchCurrentStep;
   private readonly launchMainStep: (
     workflow: LoadedWorkflow,
     run: WorkflowRun,
@@ -200,11 +191,6 @@ export class WorkflowHarness implements WorkflowCommandController {
   private readonly cleanupDelegation: (
     active: ActiveDelegation,
   ) => Promise<void> = DELEGATION_CONTROL_ACTIONS.cleanupDelegation;
-  private readonly retryDelegationAfterFailure: (
-    active: ActiveDelegation,
-    failure: DelegationFailureDetails | undefined,
-    reason: string,
-  ) => boolean = DELEGATION_CONTROL_ACTIONS.retryDelegationAfterFailure;
   private readonly pauseForDelegationFailure: (
     reason: string,
     failureSummary?: string,
@@ -298,7 +284,6 @@ export class WorkflowHarness implements WorkflowCommandController {
   ) {
     this.pi = pi;
     this.dependencies = createWorkflowHarnessDependencies(dependencyOverrides);
-    this.delegationFailures = createDelegationFailureActions(this.dependencies);
     this.statusShortcut = statusShortcut;
     this.statusShortcutLabel = formatShortcutLabel(statusShortcut);
     this.subagents = this.dependencies.createSubagentClient(pi);

package/src/herdr-workflow-state.ts

@@ -0,0 +1,65 @@
+import net from 'node:net';
+import type { ExtensionAPI } from '@earendil-works/pi-coding-agent';
+
+const source = 'herdr:pi-workflows';
+
+type WorkflowState = {
+  state: 'working' | 'blocked' | 'completed' | 'interrupted';
+  workflowId?: string;
+  stepId?: string;
+  message?: string;
+};
+
+export default function herdrWorkflowState(pi: ExtensionAPI): void {
+  const socketPath = process.env.HERDR_SOCKET_PATH;
+  const paneId = process.env.HERDR_PANE_ID;
+  if (process.env.HERDR_ENV !== '1' || !socketPath || !paneId) return;
+
+  let seq = Date.now() * 1000;
+  let last = '';
+  pi.events.on('pi-workflows:state', (data: unknown) => {
+    if (!data || typeof data !== 'object') return;
+    const event = data as WorkflowState;
+    if (
+      !['working', 'blocked', 'completed', 'interrupted'].includes(event.state)
+    )
+      return;
+    const state =
+      event.state === 'working'
+        ? 'working'
+        : event.state === 'blocked'
+          ? 'blocked'
+          : 'idle';
+    const message =
+      event.message ??
+      (event.workflowId
+        ? `Workflow "${event.workflowId}" ${event.state}`
+        : undefined);
+    const fingerprint = `${state}:${message ?? ''}`;
+    if (fingerprint === last) return;
+    last = fingerprint;
+    const request = {
+      id: `${source}:${Date.now()}:${++seq}`,
+      method: 'pane.report_agent',
+      params: {
+        pane_id: paneId,
+        source,
+        agent: 'pi-workflows',
+        state,
+        message,
+        seq,
+      },
+    };
+    const socket = net.createConnection(socketPath);
+    const timeout = setTimeout(() => socket.destroy(), 1500);
+    timeout.unref();
+    socket.on('connect', () => socket.write(`${JSON.stringify(request)}\n`));
+    socket.on('data', () => socket.destroy());
+    socket.on('close', () => {
+      clearTimeout(timeout);
+    });
+    socket.on('error', () => {
+      clearTimeout(timeout);
+    });
+  });
+}

package/src/index.ts

@@ -3,7 +3,6 @@ import type { KeyId } from '@earendil-works/pi-tui';
 import { defaultUserWorkflowDirectory, loadSettings } from './config/load.ts';
 import { WorkflowHarness } from './harness.ts';
 import { registerSubagentChildRuntime } from './integrations/subagents/child-runtime.ts';
-import { isSubagentRuntimeName } from './integrations/subagents/protocol.ts';
 
 /**
  * Asynchronous entry point accepted by Pi's extension loader.
@@ -25,7 +24,6 @@ export type PiWorkflowsExtensionDependencies = {
   readonly loadSettings: typeof loadSettings;
   readonly userWorkflowDirectory: () => string;
   readonly runtimeEnvironment: () => PiWorkflowsRuntimeEnvironment;
-  readonly isSubagentRuntimeName: typeof isSubagentRuntimeName;
   readonly registerChildRuntime: (pi: ExtensionAPI, childAgent: string) => void;
   readonly createHarness: (pi: ExtensionAPI, statusShortcut: KeyId) => void;
 };
@@ -34,10 +32,9 @@ const DEFAULT_DEPENDENCIES = {
   loadSettings,
   userWorkflowDirectory: defaultUserWorkflowDirectory,
   runtimeEnvironment: (): PiWorkflowsRuntimeEnvironment => ({
-    isSubagentChild: process.env.PI_SUBAGENT_CHILD === '1',
-    childAgent: process.env.PI_SUBAGENT_CHILD_AGENT?.trim(),
+    isSubagentChild: process.env.PI_WORKFLOWS_CHILD === '1',
+    childAgent: process.env.PI_WORKFLOWS_CHILD_AGENT?.trim(),
   }),
-  isSubagentRuntimeName,
   registerChildRuntime: (pi, childAgent): void => {
     registerSubagentChildRuntime(pi, { childAgent });
   },
@@ -59,10 +56,8 @@ export function createPiWorkflowsExtension(
   return async (pi): Promise<void> => {
     const environment = dependencies.runtimeEnvironment();
 
-    if (environment.isSubagentChild) {
-      if (dependencies.isSubagentRuntimeName(environment.childAgent)) {
-        dependencies.registerChildRuntime(pi, environment.childAgent);
-      }
+    if (environment.isSubagentChild && environment.childAgent) {
+      dependencies.registerChildRuntime(pi, environment.childAgent);
       return;
     }
 

package/src/integrations/subagents/child-policy-validation.ts

@@ -1,5 +1,5 @@
 import { dirname, isAbsolute, resolve } from 'node:path';
-import { SUBAGENT_RUNTIME_NAME_PATTERN } from '../../config/types.ts';
+import { AGENT_PROFILE_NAME_PATTERN } from '../../config/types.ts';
 import {
   DEFAULT_CHILD_POLICY_ENVIRONMENT,
   isSafeStepCapabilityPath,
@@ -61,11 +61,10 @@ const requiredString = (
 
 /**
  * Returns whether a name follows the runtime naming contract used by
- * pi-subagents.
+ * workflow agent profiles.
  */
-export const isSubagentRuntimeName = (
-  name: string | undefined,
-): name is string => Boolean(name && SUBAGENT_RUNTIME_NAME_PATTERN.test(name));
+export const isAgentProfileName = (name: string | undefined): name is string =>
+  Boolean(name && AGENT_PROFILE_NAME_PATTERN.test(name));
 
 const rejectUnknownProperties = (
   value: Readonly<Record<string, unknown>>,
@@ -115,8 +114,8 @@ const parseIdentityAndPaths = (
   if (!POLICY_DIGEST_PATTERN.test(policyDigest)) {
     throw new Error('child policy digest is invalid');
   }
-  if (!isSubagentRuntimeName(agent)) {
-    throw new Error('child policy agent is not a valid subagent runtime name');
+  if (!isAgentProfileName(agent)) {
+    throw new Error('child policy agent is not a valid agent profile name');
   }
   if (!CAPABILITY_TOKEN_PATTERN.test(capabilityToken)) {
     throw new Error('child policy capability token is invalid');

package/src/integrations/subagents/child-runtime-dependencies.ts

@@ -41,7 +41,7 @@ export const DEFAULT_CHILD_RUNTIME_DEPENDENCIES = {
   createUniqueId: randomUUID,
   currentWorkingDirectory: () => process.cwd(),
   environmentChildAgent: () =>
-    process.env.PI_SUBAGENT_CHILD_AGENT?.trim() || undefined,
+    process.env.PI_WORKFLOWS_CHILD_AGENT?.trim() || undefined,
   temporaryDirectory: tmpdir,
   tokensAreEqual,
 } as const satisfies SubagentChildRuntimeDependencies;

package/src/integrations/subagents/child-runtime-policy.ts

@@ -8,13 +8,7 @@ import type { ChildStepPolicy } from './child-policy-types.ts';
 export const childPolicyStep = (policy: ChildStepPolicy): WorkflowStep => ({
   title: policy.stepTitle,
   prompt: { inline: 'Delegated workflow step' },
-  subagent: {
-    agent: policy.agent,
-    context: 'fresh',
-    timeoutMs: 900_000,
-    artifacts: false,
-    retryToolFailures: false,
-  },
+  agent: { name: policy.agent },
   permissions: policy.permissions,
   requires: { tools: [], extensions: [], skills: [] },
   transitions: {},

package/src/integrations/subagents/child-runtime.ts

@@ -3,6 +3,7 @@ import type {
   InputEvent,
   InputEventResult,
 } from '@earendil-works/pi-coding-agent';
+import { Type } from 'typebox';
 import { invalidCompletionCallIds } from '../../policy/completion-batch.ts';
 import { freezeToolInput } from '../../policy/immutable-input.ts';
 import { authorizeToolCall, resolveActiveTools } from '../../policy/tools.ts';
@@ -24,7 +25,6 @@ import type {
 } from './child-runtime-types.ts';
 import { extractChildPolicy } from './child-policy-envelope.ts';
 import type { ChildStepPolicy } from './child-policy-types.ts';
-import { isSubagentRuntimeName } from './child-policy-validation.ts';
 
 export { CHILD_COMPLETION_TOOL } from './child-runtime-completion.ts';
 export type {
@@ -85,6 +85,21 @@ export const registerSubagentChildRuntime = (
   const childAgent = resolveChildAgent(options, dependencies);
   let state = INITIAL_STATE;
 
+  pi.registerTool({
+    name: CHILD_COMPLETION_TOOL,
+    label: 'Complete Workflow Step',
+    description: 'Return the one structured result for this workflow step',
+    parameters: Type.Object({ value: Type.Any() }),
+    executionMode: 'sequential',
+    execute: async () => ({
+      content: [
+        { type: 'text' as const, text: 'Captured workflow step result.' },
+      ],
+      details: {},
+      terminate: true,
+    }),
+  });
+
   pi.on('input', (event) => {
     let extracted;
     try {
@@ -104,11 +119,7 @@ export const registerSubagentChildRuntime = (
     }
 
     try {
-      if (!isSubagentRuntimeName(childAgent)) {
-        throw new Error(
-          'child agent does not match the delegated workflow policy',
-        );
-      }
+      if (!childAgent) throw new Error('workflow worker agent is unavailable');
       verifyChildWorkingDirectory(extracted.policy, dependencies);
       verifyChildCapability({
         policy: extracted.policy,
@@ -117,9 +128,7 @@ export const registerSubagentChildRuntime = (
       });
       const profileTools = new Set(pi.getActiveTools());
       if (!profileTools.has(CHILD_COMPLETION_TOOL)) {
-        throw new Error(
-          'pi-subagents structured_output completion is unavailable',
-        );
+        throw new Error('workflow worker completion tool is unavailable');
       }
       const effectiveTools = new Set(
         resolveActiveTools(