@wichayutdew/pi-workflows 0.3.0 → 1.0.0

package/src/integrations/prompt-gate.ts

@@ -6,24 +6,31 @@ const PAUSE = 'Pause workflow';
 
 export type PromptGateReviewResult =
   | {
-      status: 'resolved';
-      approved: boolean;
-      feedback: string;
+      readonly status: 'resolved';
+      readonly approved: boolean;
+      readonly feedback: string;
     }
   | {
-      status: 'dismissed';
+      readonly status: 'dismissed';
     };
 
-export async function requestPromptGateReview(
+const selectionOptions = (
+  signal: AbortSignal | undefined,
+): Array<{ signal: AbortSignal }> => (signal ? [{ signal }] : []);
+
+/**
+ * Presents a local workflow gate and returns the reviewer's normalized choice.
+ */
+export const requestPromptGateReview = async (
   ui: ExtensionUIContext,
   title: string,
   artifact: string,
   signal?: AbortSignal,
-): Promise<PromptGateReviewResult> {
+): Promise<PromptGateReviewResult> => {
   const choice = await ui.select(
     `${title}\n\n${artifact}`,
     [APPROVE, REQUEST_CHANGES, PAUSE],
-    ...(signal ? [{ signal }] : []),
+    ...selectionOptions(signal),
   );
 
   if (choice === APPROVE) {
@@ -36,14 +43,14 @@ export async function requestPromptGateReview(
   let feedback = await ui.input(
     'Workflow review feedback',
     'Describe the required changes',
-    ...(signal ? [{ signal }] : []),
+    ...selectionOptions(signal),
   );
   while (feedback !== undefined && !feedback.trim()) {
     ui.notify('Feedback cannot be empty', 'warning');
     feedback = await ui.input(
       'Workflow review feedback',
       'Describe the required changes',
-      ...(signal ? [{ signal }] : []),
+      ...selectionOptions(signal),
     );
   }
   if (feedback === undefined) return { status: 'dismissed' };
@@ -52,4 +59,4 @@ export async function requestPromptGateReview(
     approved: false,
     feedback: feedback.trim(),
   };
-}
+};

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

@@ -0,0 +1,119 @@
+import { basename, dirname, resolve } from 'node:path';
+import { DEFAULT_CHILD_POLICY_ENVIRONMENT } from './child-policy-paths.ts';
+import type { ChildPolicyEnvironment } from './child-policy-paths.ts';
+import type {
+  ChildStepPolicy,
+  ExtractedChildPolicy,
+} from './child-policy-types.ts';
+import { parseChildPolicy } from './child-policy-validation.ts';
+
+const CHILD_POLICY_OPEN = '<pi-workflows-policy-v1>';
+const CHILD_POLICY_CLOSE = '</pi-workflows-policy-v1>';
+const UPSTREAM_TASK_PREFIX = 'Task: ';
+const UPSTREAM_TASK_FILE_OPEN = '<file name="';
+const UPSTREAM_TASK_FILE_HEADER_CLOSE = '">\n';
+const UPSTREAM_TASK_FILE_CLOSE = '\n</file>\n';
+const UPSTREAM_TASK_DIRECTORY_PREFIX = 'pi-subagent-';
+
+/**
+ * Encodes a validated child policy into the delegated task envelope.
+ */
+export const encodeChildPolicy = (policy: ChildStepPolicy): string => {
+  const encoded = Buffer.from(JSON.stringify(policy), 'utf8').toString(
+    'base64url',
+  );
+  return `${CHILD_POLICY_OPEN}${encoded}${CHILD_POLICY_CLOSE}`;
+};
+
+type UnwrapTaskFileOptions = {
+  readonly text: string;
+  readonly environment: ChildPolicyEnvironment;
+};
+
+const unwrapTaskFile = ({
+  text,
+  environment,
+}: UnwrapTaskFileOptions): string | undefined => {
+  if (
+    !text.startsWith(UPSTREAM_TASK_FILE_OPEN) ||
+    !text.endsWith(UPSTREAM_TASK_FILE_CLOSE)
+  ) {
+    return undefined;
+  }
+
+  const pathStart = UPSTREAM_TASK_FILE_OPEN.length;
+  const headerEnd = text.indexOf(UPSTREAM_TASK_FILE_HEADER_CLOSE, pathStart);
+  if (headerEnd === -1) return undefined;
+
+  const taskFilePath = text.slice(pathStart, headerEnd);
+  const taskDirectory = dirname(resolve(taskFilePath));
+  const isExpectedTaskFile =
+    basename(taskFilePath) === 'task.md' &&
+    basename(taskDirectory).startsWith(UPSTREAM_TASK_DIRECTORY_PREFIX) &&
+    dirname(taskDirectory) === resolve(environment.temporaryDirectory());
+  if (!isExpectedTaskFile) return undefined;
+
+  const bodyStart = headerEnd + UPSTREAM_TASK_FILE_HEADER_CLOSE.length;
+  const body = text.slice(bodyStart, -UPSTREAM_TASK_FILE_CLOSE.length);
+  if (!body.startsWith(`${UPSTREAM_TASK_PREFIX}${CHILD_POLICY_OPEN}`)) {
+    return undefined;
+  }
+  return body.slice(UPSTREAM_TASK_PREFIX.length);
+};
+
+type UnwrapUpstreamTaskOptions = {
+  readonly text: string;
+  readonly environment: ChildPolicyEnvironment;
+};
+
+const unwrapUpstreamTask = ({
+  text,
+  environment,
+}: UnwrapUpstreamTaskOptions): string | undefined => {
+  if (text.startsWith(CHILD_POLICY_OPEN)) return text;
+  if (text.startsWith(`${UPSTREAM_TASK_PREFIX}${CHILD_POLICY_OPEN}`)) {
+    return text.slice(UPSTREAM_TASK_PREFIX.length);
+  }
+  return unwrapTaskFile({ text, environment });
+};
+
+const decodePolicy = (encoded: string): unknown => {
+  try {
+    return JSON.parse(Buffer.from(encoded, 'base64url').toString('utf8'));
+  } catch {
+    throw new Error('delegated task child policy cannot be decoded');
+  }
+};
+
+/**
+ * Extracts and validates a child policy from a supported delegated task shape.
+ *
+ * @returns The validated policy and task, or `undefined` for ordinary input.
+ * @throws When a policy envelope is present but malformed.
+ */
+export const extractChildPolicy = (
+  text: string,
+  environment: ChildPolicyEnvironment = DEFAULT_CHILD_POLICY_ENVIRONMENT,
+): ExtractedChildPolicy | undefined => {
+  const taskWithPolicy = unwrapUpstreamTask({ text, environment });
+  if (taskWithPolicy === undefined) return undefined;
+
+  const payloadStart = CHILD_POLICY_OPEN.length;
+  const payloadEnd = taskWithPolicy.indexOf(CHILD_POLICY_CLOSE, payloadStart);
+  const hasNestedEnvelope =
+    taskWithPolicy.indexOf(CHILD_POLICY_OPEN, payloadStart) !== -1;
+  if (payloadEnd === -1 || hasNestedEnvelope) {
+    throw new Error('delegated task contains an invalid child policy envelope');
+  }
+
+  const encoded = taskWithPolicy.slice(payloadStart, payloadEnd);
+  const task = taskWithPolicy
+    .slice(payloadEnd + CHILD_POLICY_CLOSE.length)
+    .trim();
+  if (!task) throw new Error('delegated task is empty after policy extraction');
+
+  return {
+    policy: parseChildPolicy(decodePolicy(encoded), environment),
+    task,
+  };
+};

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

@@ -0,0 +1,66 @@
+import { tmpdir } from 'node:os';
+import { basename, dirname, relative, resolve } from 'node:path';
+
+const RESULT_FILE_NAME = 'result.json';
+const CAPABILITY_FILE_NAME = 'capability';
+const RESULT_DIRECTORY_PREFIX = 'pi-workflows-step-';
+
+export type ChildPolicyEnvironment = {
+  readonly temporaryDirectory: () => string;
+};
+
+export const DEFAULT_CHILD_POLICY_ENVIRONMENT = {
+  temporaryDirectory: tmpdir,
+} as const satisfies ChildPolicyEnvironment;
+
+type SafeStepFileOptions = {
+  readonly path: string;
+  readonly expectedName: string;
+  readonly environment: ChildPolicyEnvironment;
+};
+
+const isSafeStepFilePath = ({
+  path,
+  expectedName,
+  environment,
+}: SafeStepFileOptions): boolean => {
+  const temporaryRoot = resolve(environment.temporaryDirectory());
+  const candidate = resolve(path);
+  const relativePath = relative(temporaryRoot, candidate);
+
+  return (
+    relativePath !== '' &&
+    !relativePath.startsWith('..') &&
+    !relativePath.includes('\0') &&
+    basename(candidate) === expectedName &&
+    basename(dirname(candidate)).startsWith(RESULT_DIRECTORY_PREFIX)
+  );
+};
+
+/**
+ * Returns whether a delegated result path is confined to its temporary step
+ * directory.
+ */
+export const isSafeStepResultPath = (
+  path: string,
+  environment: ChildPolicyEnvironment = DEFAULT_CHILD_POLICY_ENVIRONMENT,
+): boolean =>
+  isSafeStepFilePath({
+    path,
+    expectedName: RESULT_FILE_NAME,
+    environment,
+  });
+
+/**
+ * Returns whether a delegated capability path is confined to its temporary
+ * step directory.
+ */
+export const isSafeStepCapabilityPath = (
+  path: string,
+  environment: ChildPolicyEnvironment = DEFAULT_CHILD_POLICY_ENVIRONMENT,
+): boolean =>
+  isSafeStepFilePath({
+    path,
+    expectedName: CAPABILITY_FILE_NAME,
+    environment,
+  });

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

@@ -0,0 +1,174 @@
+import { isAbsolute, resolve } from 'node:path';
+import type { StepPermissions } from '../../config/types.ts';
+import type { ChildStepPolicy } from './child-policy-types.ts';
+
+type PolicySections = Pick<
+  ChildStepPolicy,
+  | 'permissions'
+  | 'approvedBashCommands'
+  | 'repositoryCwd'
+  | 'bootstrapCwd'
+  | 'outcomes'
+  | 'pauseOutcomes'
+  | 'summaryMaxChars'
+  | 'gateSubmitOutcome'
+>;
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const isStringArray = (value: unknown): value is Array<string> =>
+  Array.isArray(value) && value.every((item) => typeof item === 'string');
+
+const isStepPermissions = (value: unknown): value is StepPermissions => {
+  if (!isRecord(value) || !isRecord(value.bash)) return false;
+
+  const bash = value.bash;
+  const bashRules = Array.isArray(bash.allow) ? bash.allow : undefined;
+  const isValidMode =
+    bash.mode === 'deny' ||
+    bash.mode === 'read-only' ||
+    bash.mode === 'allow-list' ||
+    bash.mode === 'unrestricted';
+  const hasValidRules =
+    bashRules !== undefined &&
+    bashRules.every(
+      (rule) =>
+        isRecord(rule) &&
+        typeof rule.executable === 'string' &&
+        isStringArray(rule.argsPrefix),
+    );
+  const hasValidApprovedSources =
+    bash.approvedSources === undefined ||
+    (isStringArray(bash.approvedSources) &&
+      new Set(bash.approvedSources).size === bash.approvedSources.length &&
+      bash.approvedSources.every(
+        (source) =>
+          source === 'verification-worker' ||
+          source === 'verification-reviewer' ||
+          source === 'remote-actions',
+      ));
+  const hasValidApprovalShape =
+    bash.mode === 'allow-list'
+      ? (bashRules?.length ?? 0) > 0 ||
+        (Array.isArray(bash.approvedSources) && bash.approvedSources.length > 0)
+      : bash.approvedSources === undefined;
+
+  return (
+    isStringArray(value.tools) &&
+    isStringArray(value.mcp) &&
+    isStringArray(value.extensions) &&
+    isStringArray(value.skills) &&
+    isValidMode &&
+    hasValidRules &&
+    hasValidApprovedSources &&
+    hasValidApprovalShape
+  );
+};
+
+const parsePermissions = (
+  value: Readonly<Record<string, unknown>>,
+): Pick<PolicySections, 'permissions' | 'approvedBashCommands'> => {
+  if (!isStepPermissions(value.permissions)) {
+    throw new Error('child policy permissions are invalid');
+  }
+  const approvedBashCommands = value.approvedBashCommands;
+  if (
+    approvedBashCommands !== undefined &&
+    (!isStringArray(approvedBashCommands) ||
+      new Set(approvedBashCommands).size !== approvedBashCommands.length)
+  ) {
+    throw new Error('child policy approved Bash commands are invalid');
+  }
+  return {
+    permissions: value.permissions,
+    ...(approvedBashCommands === undefined ? {} : { approvedBashCommands }),
+  };
+};
+
+const parseRepositoryPaths = (
+  value: Readonly<Record<string, unknown>>,
+): Pick<PolicySections, 'repositoryCwd' | 'bootstrapCwd'> => {
+  const repositoryCwd = value.repositoryCwd;
+  const bootstrapCwd = value.bootstrapCwd;
+  if (
+    repositoryCwd !== undefined &&
+    (typeof repositoryCwd !== 'string' ||
+      !isAbsolute(repositoryCwd) ||
+      repositoryCwd.includes('\0'))
+  ) {
+    throw new Error('child policy repository cwd is invalid');
+  }
+  if (
+    bootstrapCwd !== undefined &&
+    (typeof bootstrapCwd !== 'string' ||
+      !isAbsolute(bootstrapCwd) ||
+      bootstrapCwd.includes('\0') ||
+      typeof repositoryCwd !== 'string' ||
+      resolve(bootstrapCwd) === resolve(repositoryCwd))
+  ) {
+    throw new Error('child policy bootstrap cwd is invalid');
+  }
+  return {
+    ...(repositoryCwd === undefined ? {} : { repositoryCwd }),
+    ...(bootstrapCwd === undefined ? {} : { bootstrapCwd }),
+  };
+};
+
+const parseOutcomes = (
+  value: Readonly<Record<string, unknown>>,
+): Pick<
+  PolicySections,
+  'outcomes' | 'pauseOutcomes' | 'summaryMaxChars' | 'gateSubmitOutcome'
+> => {
+  const outcomes = value.outcomes;
+  if (
+    !isStringArray(outcomes) ||
+    outcomes.length === 0 ||
+    new Set(outcomes).size !== outcomes.length
+  ) {
+    throw new Error('child policy outcomes are invalid');
+  }
+  const pauseOutcomes = value.pauseOutcomes;
+  if (
+    !isStringArray(pauseOutcomes) ||
+    new Set(pauseOutcomes).size !== pauseOutcomes.length ||
+    pauseOutcomes.some((outcome) => !outcomes.includes(outcome))
+  ) {
+    throw new Error('child policy pause outcomes are invalid');
+  }
+  const summaryMaxChars = value.summaryMaxChars;
+  if (
+    typeof summaryMaxChars !== 'number' ||
+    !Number.isInteger(summaryMaxChars) ||
+    summaryMaxChars < 100 ||
+    summaryMaxChars > 50_000
+  ) {
+    throw new Error('child policy summaryMaxChars is invalid');
+  }
+  const gateSubmitOutcome = value.gateSubmitOutcome;
+  if (
+    gateSubmitOutcome !== undefined &&
+    (typeof gateSubmitOutcome !== 'string' ||
+      !outcomes.includes(gateSubmitOutcome))
+  ) {
+    throw new Error('child policy gate outcome is invalid');
+  }
+  return {
+    outcomes,
+    pauseOutcomes,
+    summaryMaxChars,
+    ...(gateSubmitOutcome === undefined ? {} : { gateSubmitOutcome }),
+  };
+};
+
+/**
+ * Parses permission, repository, and outcome sections of a child policy.
+ */
+export const parseChildPolicySections = (
+  value: Readonly<Record<string, unknown>>,
+): PolicySections => ({
+  ...parsePermissions(value),
+  ...parseRepositoryPaths(value),
+  ...parseOutcomes(value),
+});

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

@@ -0,0 +1,32 @@
+import type { StepPermissions } from '../../config/types.ts';
+
+export type ChildStepPolicy = {
+  readonly version: 1;
+  readonly requestId: string;
+  readonly agent: string;
+  readonly workflowId: string;
+  readonly runId: string;
+  readonly stepId: string;
+  readonly stepTitle: string;
+  readonly policyDigest: string;
+  readonly capabilityPath: string;
+  readonly capabilityToken: string;
+  readonly resultPath: string;
+  readonly permissions: StepPermissions;
+  /** Exact Bash command strings extracted from a reviewed gate artifact. */
+  readonly approvedBashCommands?: ReadonlyArray<string>;
+  /** Reviewed repository root that file mutations must remain inside. */
+  readonly repositoryCwd?: string;
+  /** Existing reviewed source directory used only to bootstrap repositoryCwd. */
+  readonly bootstrapCwd?: string;
+  readonly outcomes: ReadonlyArray<string>;
+  /** Outcomes that pause instead of advancing to another workflow step. */
+  readonly pauseOutcomes: ReadonlyArray<string>;
+  readonly summaryMaxChars: number;
+  readonly gateSubmitOutcome?: string;
+};
+
+export type ExtractedChildPolicy = {
+  readonly policy: ChildStepPolicy;
+  readonly task: string;
+};

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

@@ -0,0 +1,163 @@
+import { dirname, resolve } from 'node:path';
+import { SUBAGENT_RUNTIME_NAME_PATTERN } from '../../config/types.ts';
+import {
+  DEFAULT_CHILD_POLICY_ENVIRONMENT,
+  isSafeStepCapabilityPath,
+  isSafeStepResultPath,
+} from './child-policy-paths.ts';
+import type { ChildPolicyEnvironment } from './child-policy-paths.ts';
+import { parseChildPolicySections } from './child-policy-sections.ts';
+import type { ChildStepPolicy } from './child-policy-types.ts';
+
+const POLICY_DIGEST_PATTERN = /^[a-f0-9]{64}$/;
+const CAPABILITY_TOKEN_PATTERN = /^[a-f0-9]{64}$/;
+const POLICY_KEYS: ReadonlySet<string> = new Set([
+  'version',
+  'requestId',
+  'agent',
+  'workflowId',
+  'runId',
+  'stepId',
+  'stepTitle',
+  'policyDigest',
+  'capabilityPath',
+  'capabilityToken',
+  'resultPath',
+  'permissions',
+  'approvedBashCommands',
+  'repositoryCwd',
+  'bootstrapCwd',
+  'outcomes',
+  'pauseOutcomes',
+  'summaryMaxChars',
+  'gateSubmitOutcome',
+]);
+
+type RequiredStringField =
+  | 'requestId'
+  | 'agent'
+  | 'workflowId'
+  | 'runId'
+  | 'stepId'
+  | 'stepTitle'
+  | 'policyDigest'
+  | 'capabilityPath'
+  | 'capabilityToken'
+  | 'resultPath';
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+const requiredString = (
+  value: Readonly<Record<string, unknown>>,
+  field: RequiredStringField,
+): string => {
+  const candidate = value[field];
+  if (typeof candidate !== 'string' || !candidate) {
+    throw new Error(`child policy ${field} must be a non-empty string`);
+  }
+  return candidate;
+};
+
+/**
+ * Returns whether a name follows the runtime naming contract used by
+ * pi-subagents.
+ */
+export const isSubagentRuntimeName = (
+  name: string | undefined,
+): name is string => Boolean(name && SUBAGENT_RUNTIME_NAME_PATTERN.test(name));
+
+const rejectUnknownProperties = (
+  value: Readonly<Record<string, unknown>>,
+): void => {
+  const unknownKey = Object.keys(value).find((key) => !POLICY_KEYS.has(key));
+  if (unknownKey) {
+    throw new Error(`child policy has unknown property "${unknownKey}"`);
+  }
+};
+
+type IdentityAndPaths = Pick<
+  ChildStepPolicy,
+  | 'version'
+  | 'requestId'
+  | 'agent'
+  | 'workflowId'
+  | 'runId'
+  | 'stepId'
+  | 'stepTitle'
+  | 'policyDigest'
+  | 'capabilityPath'
+  | 'capabilityToken'
+  | 'resultPath'
+>;
+
+const parseIdentityAndPaths = (
+  value: Readonly<Record<string, unknown>>,
+  environment: ChildPolicyEnvironment,
+): IdentityAndPaths => {
+  const requestId = requiredString(value, 'requestId');
+  const agent = requiredString(value, 'agent');
+  const workflowId = requiredString(value, 'workflowId');
+  const runId = requiredString(value, 'runId');
+  const stepId = requiredString(value, 'stepId');
+  const stepTitle = requiredString(value, 'stepTitle');
+  const policyDigest = requiredString(value, 'policyDigest');
+  const capabilityPath = requiredString(value, 'capabilityPath');
+  const capabilityToken = requiredString(value, 'capabilityToken');
+  const resultPath = requiredString(value, 'resultPath');
+
+  if (value.version !== 1) throw new Error('unsupported child policy version');
+  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 (!CAPABILITY_TOKEN_PATTERN.test(capabilityToken)) {
+    throw new Error('child policy capability token is invalid');
+  }
+  if (!isSafeStepCapabilityPath(capabilityPath, environment)) {
+    throw new Error(
+      'child policy capability path is outside its temporary directory',
+    );
+  }
+  if (!isSafeStepResultPath(resultPath, environment)) {
+    throw new Error(
+      'child policy result path is outside its temporary directory',
+    );
+  }
+  if (dirname(resolve(capabilityPath)) !== dirname(resolve(resultPath))) {
+    throw new Error('child policy files must share one temporary directory');
+  }
+  return {
+    version: 1,
+    requestId,
+    agent,
+    workflowId,
+    runId,
+    stepId,
+    stepTitle,
+    policyDigest,
+    capabilityPath,
+    capabilityToken,
+    resultPath,
+  };
+};
+
+/**
+ * Validates untrusted delegated policy data and returns its narrow domain type.
+ *
+ * @throws When the value does not satisfy the child policy contract.
+ */
+export const parseChildPolicy = (
+  value: unknown,
+  environment: ChildPolicyEnvironment = DEFAULT_CHILD_POLICY_ENVIRONMENT,
+): ChildStepPolicy => {
+  if (!isRecord(value)) throw new Error('child policy must be an object');
+
+  rejectUnknownProperties(value);
+  return {
+    ...parseIdentityAndPaths(value, environment),
+    ...parseChildPolicySections(value),
+  };
+};

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

@@ -0,0 +1,56 @@
+import { parseDelegatedStepResult } from './delegated-result.ts';
+import type { ChildStepPolicy } from './child-policy-types.ts';
+
+export const CHILD_COMPLETION_TOOL = 'structured_output';
+export const CHILD_COORDINATION_TOOLS: ReadonlySet<string> = new Set([
+  'contact_supervisor',
+  'subagent_supervisor',
+  'intercom',
+]);
+
+const STRUCTURED_RESULT_KEYS: ReadonlySet<string> = new Set([
+  'outcome',
+  'summary',
+  'artifact',
+]);
+
+const isRecord = (value: unknown): value is Record<string, unknown> =>
+  value !== null && typeof value === 'object' && !Array.isArray(value);
+
+/**
+ * Validates and unwraps a structured-output tool input for a child policy.
+ */
+export const parseChildStructuredResult = ({
+  input,
+  policy,
+}: {
+  readonly input: unknown;
+  readonly policy: ChildStepPolicy;
+}): ReturnType<typeof parseDelegatedStepResult> => {
+  if (!isRecord(input)) {
+    throw new Error('structured_output input must be an object');
+  }
+  if (Object.keys(input).length !== 1 || !Object.hasOwn(input, 'value')) {
+    throw new Error('structured_output input must contain only value');
+  }
+  if (!isRecord(input.value)) {
+    throw new Error('structured_output value must be an object');
+  }
+
+  const unknownKey = Object.keys(input.value).find(
+    (key) => !STRUCTURED_RESULT_KEYS.has(key),
+  );
+  if (unknownKey) {
+    throw new Error(
+      `structured_output value has unknown property "${unknownKey}"`,
+    );
+  }
+  return parseDelegatedStepResult(
+    {
+      version: 1,
+      policyDigest: policy.policyDigest,
+      ...input.value,
+    },
+    policy,
+  );
+};