@fitlab-ai/agent-infra 0.9.7 → 0.9.9

package/lib/server/process-state.ts

@@ -9,6 +9,9 @@ export type ProcessIdentity = Readonly<{
   startTime: ProcessStartTime;
 }>;
 
+export type ProcessIdentityState = 'alive' | 'dead' | 'unknown';
+export type ProcessIdentityProbe = (identity: ProcessIdentity) => ProcessIdentityState;
+
 export type PidRecord = ProcessIdentity & {
   version: 2;
 };
@@ -127,6 +130,50 @@ export function getProcessStartTime(
   }
 }
 
+export function getProcessIdentityState(
+  identity: ProcessIdentity,
+  platform: NodeJS.Platform = process.platform
+): ProcessIdentityState {
+  if (!Number.isInteger(identity.pid) || identity.pid <= 0 || !Number.isSafeInteger(identity.startTime)) {
+    return 'dead';
+  }
+  if (platform === 'linux') {
+    try {
+      const stat = parseLinuxProcessStat(fs.readFileSync(`/proc/${identity.pid}/stat`, 'utf8'));
+      if (stat === null) return 'unknown';
+      if (stat.state === 'Z') return 'dead';
+      return stat.startTime === identity.startTime ? 'alive' : 'dead';
+    } catch (error) {
+      return (error as NodeJS.ErrnoException).code === 'ENOENT' ? 'dead' : 'unknown';
+    }
+  }
+  try {
+    process.kill(identity.pid, 0);
+  } catch (error) {
+    const code = (error as NodeJS.ErrnoException).code;
+    if (code === 'ESRCH') return 'dead';
+    if (code !== 'EPERM') return 'unknown';
+  }
+  const query = buildProcessStartTimeQuery(identity.pid, platform);
+  if (query === null) return 'unknown';
+  try {
+    const output = execFileSync(query.command, query.args, {
+      encoding: 'utf8',
+      env: platform === 'darwin' ? { ...process.env, LC_ALL: 'C', LANG: 'C', TZ: 'UTC' } : process.env
+    }).trim();
+    if (output.length === 0) return 'unknown';
+    const startTime = platform === 'win32'
+      ? new Date(output).getTime()
+      : platform === 'darwin'
+        ? parseDarwinStartTime(output)
+        : null;
+    if (startTime === null || Number.isNaN(startTime)) return 'unknown';
+    return startTime === identity.startTime ? 'alive' : 'dead';
+  } catch {
+    return 'unknown';
+  }
+}
+
 function parsePidRecord(
   raw: string
 ):
@@ -234,5 +281,5 @@ export function removePidRecordIfMatches(pidFile: string, expected: PidRecord):
 }
 
 export function processIdentityMatches(identity: ProcessIdentity): boolean {
-  return getProcessStartTime(identity.pid) === identity.startTime;
+  return getProcessIdentityState(identity) === 'alive';
 }

package/lib/task/activity-intent.ts

@@ -14,6 +14,7 @@ import { TaskExecutionLockError, withTaskExecutionLock } from './task-execution-
 import type { TaskExecutionLockOptions } from './task-execution-lock.ts';
 import { captureTaskWriteMetadata, writeTask } from './write.ts';
 import type { TaskMutation, TaskOperationSummary, TaskWriteOptions } from './write.ts';
+import { allowsManualOverride } from './guard-override.ts';
 
 type PrReviewVerdict = 'approved' | 'changes-requested' | 'commented';
 type PrReviewOutcome = 'aborted' | 'superseded';
@@ -95,7 +96,7 @@ export type PrReviewInspectionResult = {
   error: { code: string; message: string } | null;
 };
 
-type ActivityIntentOptions = TaskWriteOptions & { lockOptions?: TaskExecutionLockOptions };
+type ActivityIntentOptions = TaskWriteOptions & { lockOptions?: TaskExecutionLockOptions; lockAlreadyHeld?: boolean };
 type ArtifactRecord = { identity: ArtifactIdentity; head: string; status: PrReviewArtifactStatus };
 type RoundState = ArtifactRecord & {
   startedAgent: string | null;
@@ -397,9 +398,10 @@ export function applyPrReviewActivityIntent(intent: PrReviewActivityIntent, opti
   if ('code' in validated) return failed(intent, validated.code, validated.message);
   const resolved = resolveTaskRef(intent.taskRef, { repoRoot: options.repoRoot });
   if (!resolved.ok) return failed(intent, resolved.code, resolved.message, resolved.taskId);
-  if (resolved.state !== 'active') {
+  if (resolved.state !== 'active' && !allowsManualOverride(options.manualOverride, 'activity-intent', 'TASK_STATE_MISMATCH')) {
     return failed(intent, 'TASK_STATE_MISMATCH', `task ${resolved.taskId} is ${resolved.state}, expected active`, resolved.taskId);
   }
+  if (options.lockAlreadyHeld) return applyLocked(intent, validated.agent, { ...options, repoRoot: resolved.repoRoot });
   try {
     return withTaskExecutionLock(
       resolved.repoRoot,

package/lib/task/codex-orchestration.ts

@@ -1,5 +1,3 @@
-import fs from 'node:fs';
-
 import {
   preflightCodexLifecycleEvidence,
   resolveCodexSpawnedChild,
@@ -7,16 +5,22 @@ import {
   resolveCodexThread
 } from '../agent-clients/adapters/codex-lifecycle/app-server.ts';
 import { createCodexLifecycleStore } from '../agent-clients/adapters/codex-lifecycle/store.ts';
-import { createCodexCapabilityStore } from '../agent-clients/adapters/codex-lifecycle/capability-store.ts';
+import {
+  createCodexCapabilityStore,
+  isCodexCapabilityProvenanceDetail
+} from '../agent-clients/adapters/codex-lifecycle/capability-store.ts';
+import type { CodexCapabilityProvenanceDetail } from '../agent-clients/adapters/codex-lifecycle/capability-store.ts';
 import { computeLifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.ts';
 import type { LifecycleBuildIdentity } from '../agent-clients/adapters/codex-lifecycle/build-identity.ts';
 import { verifyCodexSandboxControllerContext } from '../agent-clients/adapters/codex-lifecycle/sandbox-controller.ts';
+import { verifyCodexSandboxControllerContext as verifyControllerContextFile } from '../agent-clients/adapters/codex-lifecycle/controller-context.ts';
 import type { AgentClientId } from '../agent-clients/types.ts';
 import { resolveTaskRef } from './resolve-ref.ts';
 import {
   activateMatchingOrchestrationDelegation,
   hasActivatableOrchestrationDelegation,
   hasSealableOrchestrationDelegation,
+  OrchestrationStateError,
   pauseMatchingOrchestrationDelegation,
   prepareOrchestrationDelegation,
   reconcileMatchingOrchestrationDelegation,
@@ -52,10 +56,27 @@ function coreOptions(options: CodexBridgeOptions): OrchestrationOptions {
   return { ...options.orchestrationOptions, repoRoot: options.repoRoot ?? options.orchestrationOptions?.repoRoot };
 }
 
-function bridgeFailure(code: string, message: string): OrchestrationResult {
+function bridgeFailure(code: string, message: string, detail?: CodexCapabilityProvenanceDetail): OrchestrationResult {
   return {
     status: 'failed', changed: false, taskId: null, run: null, next: null,
-    error: { code, message }
+    error: { code, message, ...(detail ? { detail } : {}) }
+  };
+}
+
+function capabilityFailure(error: unknown): NonNullable<OrchestrationResult['error']> {
+  const detailValue = error instanceof Error
+    ? (error as Error & { detail?: unknown }).detail
+    : undefined;
+  return {
+    code: error instanceof Error && error.name.startsWith('CODEX_CAPABILITY_')
+      ? error.name
+      : 'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED',
+    message: error instanceof Error ? error.message : String(error),
+    ...(error instanceof Error
+      && error.name === 'CODEX_CAPABILITY_PROVENANCE_MISMATCH'
+      && isCodexCapabilityProvenanceDetail(detailValue)
+      ? { detail: detailValue }
+      : {})
   };
 }
 
@@ -71,11 +92,54 @@ function requiredStore(options: CodexBridgeOptions): LifecycleStore {
   return options.store;
 }
 
-function controllerContext(taskId: string, repoRoot: string) {
+function controllerContext(
+  repoRoot: string,
+  brokerController: Readonly<{ instanceDigest: string; controlGeneration: string }> | null
+) {
   const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
-  return contextPath
-    ? verifyCodexSandboxControllerContext(contextPath, taskId, { repoRoot })
-    : null;
+  if (!contextPath) return null;
+  if (brokerController) {
+    return verifyControllerContextFile(contextPath, {
+      repoRoot,
+      generation: process.env.AGENT_INFRA_CONTROL_GENERATION ?? brokerController.controlGeneration
+    });
+  }
+  return verifyCodexSandboxControllerContext(contextPath, { repoRoot });
+}
+
+function brokerBindingConflictsWithContext(
+  repoRoot: string,
+  brokerController: Readonly<{ instanceDigest: string; controlGeneration: string }> | null
+): boolean {
+  const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
+  if (!contextPath || !brokerController) return false;
+  const context = verifyControllerContextFile(contextPath, {
+    repoRoot,
+    generation: process.env.AGENT_INFRA_CONTROL_GENERATION ?? brokerController.controlGeneration
+  });
+  return context.controllerInstanceDigest !== brokerController.instanceDigest
+    || context.controlGeneration !== brokerController.controlGeneration;
+}
+
+function brokerControllerBinding(): Readonly<{ instanceDigest: string; controlGeneration: string }> | null {
+  const raw = process.env.AGENT_INFRA_CONTROL_CONTROLLER_BINDING;
+  if (!raw) return null;
+  let value: unknown;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_BINDING_INVALID');
+  }
+  if (!value || typeof value !== 'object' || Array.isArray(value)) {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_BINDING_INVALID');
+  }
+  const binding = value as Record<string, unknown>;
+  if (Object.keys(binding).sort().join(',') !== 'controlGeneration,instanceDigest'
+    || typeof binding.instanceDigest !== 'string' || !/^[a-f0-9]{64}$/u.test(binding.instanceDigest)
+    || typeof binding.controlGeneration !== 'string' || binding.controlGeneration.length === 0) {
+    throw new Error('CODEX_SANDBOX_CONTROLLER_BINDING_INVALID');
+  }
+  return binding as { instanceDigest: string; controlGeneration: string };
 }
 
 async function prepareCodexOrchestrationDelegation(
@@ -101,36 +165,101 @@ async function prepareCodexOrchestrationDelegation(
       );
     }
     const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
-    const controller = controllerContext(resolved.taskId, repoRoot);
+    const brokerController = brokerControllerBinding();
+    if (brokerBindingConflictsWithContext(repoRoot, brokerController)) {
+      return bridgeFailure(
+        'CODEX_SANDBOX_CONTROLLER_BINDING_MISMATCH',
+        'broker and local controller bindings do not match'
+      );
+    }
+    const localController = controllerContext(repoRoot, brokerController);
+    if (localController && brokerController
+      && (localController.controllerInstanceDigest !== brokerController.instanceDigest
+        || localController.controlGeneration !== brokerController.controlGeneration)) {
+      return bridgeFailure(
+        'CODEX_SANDBOX_CONTROLLER_BINDING_MISMATCH',
+        'broker and local controller bindings do not match'
+      );
+    }
+    const controller = brokerController ?? (localController ? {
+      instanceDigest: localController.controllerInstanceDigest,
+      controlGeneration: localController.controlGeneration
+    } : null);
     const capabilityStore = options.capabilityStore ?? createCodexCapabilityStore();
-    const consumed = capabilityStore.consume(input.capabilityToken, {
+    const attested = capabilityStore.inspect(input.capabilityToken);
+    const lifecycleProvenance = {
+      ...attested.buildIdentity,
+      hookDefinitionHash: preflight.hookDefinitionHash,
+      ...preflight.hookProvenance,
+      capabilitySessionId: attested.sessionId!,
+      capabilityTurnId: attested.turnId!,
+      capabilityToolUseId: attested.toolUseId!,
+      controllerInstanceDigest: controller?.instanceDigest ?? null,
+      controlGeneration: controller?.controlGeneration ?? null
+    };
+    const capabilityExpected = {
       taskId: resolved.taskId,
       hookDefinitionHash: preflight.hookDefinitionHash,
       buildIdentity,
       ...(controller ? { controller: {
-        instanceDigest: controller.controllerInstanceDigest,
+        instanceDigest: controller.instanceDigest,
         controlGeneration: controller.controlGeneration
       } } : {})
-    });
+    };
     return prepareOrchestrationDelegation(taskRef, {
       ...input,
-      lifecycleProvenance: {
-        ...consumed.buildIdentity,
-        hookDefinitionHash: preflight.hookDefinitionHash,
-        ...preflight.hookProvenance,
-        capabilitySessionId: consumed.sessionId!,
-        capabilityTurnId: consumed.turnId!,
-        capabilityToolUseId: consumed.toolUseId!,
-        controllerInstanceDigest: controller?.controllerInstanceDigest ?? null,
-        controlGeneration: controller?.controlGeneration ?? null
+      lifecycleProvenance
+    }, {
+      ...coreOptions(options),
+      validateLifecycleCapability: () => {
+        try {
+          const validated = capabilityStore.validate(input.capabilityToken!, capabilityExpected);
+          if (validated.sessionId !== attested.sessionId
+            || validated.turnId !== attested.turnId
+            || validated.toolUseId !== attested.toolUseId) {
+            return {
+              code: 'CODEX_CAPABILITY_IDENTITY_CHANGED',
+              message: 'capability identity changed during validation'
+            };
+          }
+          return null;
+        } catch (error) {
+          return capabilityFailure(error);
+        }
+      },
+      consumeLifecycleCapability: () => {
+        try {
+          const consumed = capabilityStore.consume(input.capabilityToken!, capabilityExpected);
+          if (consumed.sessionId !== attested.sessionId
+            || consumed.turnId !== attested.turnId
+            || consumed.toolUseId !== attested.toolUseId) {
+            return {
+              code: 'CODEX_CAPABILITY_IDENTITY_CHANGED',
+              message: 'capability identity changed during consumption'
+            };
+          }
+          return null;
+        } catch (error) {
+          return capabilityFailure(error);
+        }
       }
-    }, coreOptions(options));
+    });
   } catch (error) {
+    if (error instanceof OrchestrationStateError) return bridgeFailure(error.code, error.message);
+    const detailValue = error instanceof Error
+      ? (error as Error & { detail?: unknown }).detail
+      : undefined;
+    const detail = error instanceof Error
+      && error.name === 'CODEX_CAPABILITY_PROVENANCE_MISMATCH'
+      && isCodexCapabilityProvenanceDetail(detailValue)
+      ? detailValue
+      : undefined;
     return bridgeFailure(
       error instanceof Error && error.name.startsWith('CODEX_CAPABILITY_')
         ? error.name
         : 'ORCHESTRATION_CLIENT_PREFLIGHT_FAILED',
-      error instanceof Error ? error.message : String(error)
+      error instanceof Error ? error.message : String(error),
+      detail
     );
   }
 }
@@ -161,14 +290,8 @@ async function activateCodexOrchestrationDelegation(
     });
     const buildIdentity = options.buildIdentity ?? computeLifecycleBuildIdentity(repoRoot);
     const contextPath = process.env.AGENT_INFRA_CODEX_CONTROLLER_CONTEXT;
-    const contextTaskId = contextPath
-      ? (JSON.parse(fs.readFileSync(contextPath, 'utf8')) as { taskId?: unknown }).taskId
-      : null;
-    if (contextPath && typeof contextTaskId !== 'string') {
-      throw new Error('CODEX_SANDBOX_CONTROLLER_CONTEXT_INVALID');
-    }
     const controller = contextPath
-      ? verifyCodexSandboxControllerContext(contextPath, contextTaskId as string, { repoRoot })
+      ? verifyCodexSandboxControllerContext(contextPath, { repoRoot })
       : null;
     return activateMatchingOrchestrationDelegation('codex', {
       nativeAgent: evidence.nativeAgent,
@@ -196,6 +319,7 @@ async function activateCodexOrchestrationDelegation(
       }
     }, coreOptions(options));
   } catch (error) {
+    if (error instanceof OrchestrationStateError) return bridgeFailure(error.code, error.message);
     return pauseBridge('ORCHESTRATION_CODEX_START_FAILED', error instanceof Error ? error.message : String(error), options);
   }
 }
@@ -223,6 +347,7 @@ async function activateCodexSpawnDelegation(
       resolveThread: async () => resolved
     });
   } catch (error) {
+    if (error instanceof OrchestrationStateError) return bridgeFailure(error.code, error.message);
     return pauseBridge('ORCHESTRATION_CODEX_START_FAILED', error instanceof Error ? error.message : String(error), options);
   }
 }
@@ -238,7 +363,11 @@ async function sealCodexOrchestrationDelegation(
     const store = requiredStore(options);
     const existing = store.read(childThreadId);
     if (!existing.consumer) {
-      store.apply(await (options.resolveTerminal ?? resolveCodexTerminal)(childThreadId));
+      const stopTurnId = existing.state.stop?.turnId;
+      if (!stopTurnId) {
+        return pauseBridge('ORCHESTRATION_CODEX_STOP_EVIDENCE_INVALID', 'Codex lifecycle stop hook is not available', options);
+      }
+      store.apply(await (options.resolveTerminal ?? resolveCodexTerminal)(childThreadId, stopTurnId));
     }
     const record = store.read(childThreadId);
     const evidence = record.state.stopEvidence;
@@ -259,6 +388,7 @@ async function sealCodexOrchestrationDelegation(
       coreOptions(options)
     );
   } catch (error) {
+    if (error instanceof OrchestrationStateError) return bridgeFailure(error.code, error.message);
     return pauseBridge('ORCHESTRATION_CODEX_STOP_FAILED', error instanceof Error ? error.message : String(error), options);
   }
 }
@@ -280,7 +410,10 @@ async function sealCodexParentDelegation(
     const start = active.state.startEvidence!;
     const child = active.state.child!;
     if (!active.state.terminal) {
-      store.apply(await (options.resolveTerminal ?? resolveCodexTerminal)(start.childThreadId));
+      const resolveTerminal = options.resolveTerminal ?? resolveCodexTerminal;
+      store.apply(active.state.stop
+        ? await resolveTerminal(start.childThreadId, active.state.stop.turnId)
+        : await resolveTerminal(start.childThreadId));
     }
     if (!store.read(start.childThreadId).state.stop) {
       store.apply({
@@ -294,6 +427,7 @@ async function sealCodexParentDelegation(
     }
     return sealCodexOrchestrationDelegation(start.childThreadId, options);
   } catch (error) {
+    if (error instanceof OrchestrationStateError) return bridgeFailure(error.code, error.message);
     if (error instanceof Error && error.message === 'CODEX_TURN_NOT_TERMINAL') {
       return bridgeFailure('ORCHESTRATION_DELEGATION_MISSING', 'The matching Codex child has not completed');
     }

package/lib/task/commands/status.ts

@@ -9,6 +9,8 @@ import { parseTaskFrontmatter, extractTitle, type Frontmatter } from '../frontma
 import { loadShortIdByTaskId } from '../short-id.ts';
 import { getOpenWorkflowWarnings, formatWorkflowWarningSummary, type WorkflowWarning } from '../workflow-warnings.ts';
 import { parseActivityLog, pairEntries } from '../activity-log.ts';
+import { readRun, type OrchestrationRun } from '../orchestration.ts';
+import type { DelegationReceipt } from '../delegation-receipts.ts';
 import { statusCard, type DisplayMessage } from '../../server/display.ts';
 
 const USAGE = `Usage: ai task status [<N | TASK-id> | --task <ref> | -t <ref>]
@@ -219,6 +221,19 @@ type RuntimeInfo = {
   log: string;
 };
 
+type PendingDelegationInfo = Readonly<Pick<
+  DelegationReceipt,
+  'id' | 'role' | 'stage' | 'round' | 'artifact' | 'client' | 'status'
+>>;
+
+type OrchestrationInfo = Readonly<{
+  status: 'absent' | OrchestrationRun['status'];
+  runId: string;
+  nextStage: string;
+  pause: Readonly<{ code: string; message: string; recoverable: boolean }> | null;
+  pendingDelegation: PendingDelegationInfo | null;
+}>;
+
 type ManagedRunRecord = {
   run_id: string;
   engine: string;
@@ -323,6 +338,39 @@ function collectRuntime(taskDir: string, workflow: WorkflowInfo, run: Runner): R
   };
 }
 
+function pendingDelegationInfo(receipt: DelegationReceipt | null): PendingDelegationInfo | null {
+  if (!receipt) return null;
+  return {
+    id: receipt.id,
+    role: receipt.role,
+    stage: receipt.stage,
+    round: receipt.round,
+    artifact: receipt.artifact,
+    client: receipt.client,
+    status: receipt.status
+  };
+}
+
+function collectOrchestration(taskDir: string): OrchestrationInfo {
+  const run = readRun(taskDir);
+  if (!run) {
+    return {
+      status: 'absent',
+      runId: DASH,
+      nextStage: DASH,
+      pause: null,
+      pendingDelegation: null
+    };
+  }
+  return {
+    status: run.status,
+    runId: run.runId,
+    nextStage: run.nextStage ?? DASH,
+    pause: run.pause,
+    pendingDelegation: pendingDelegationInfo(run.pendingDelegation)
+  };
+}
+
 type StatusModel = {
   taskId: string;
   shortId: string;
@@ -332,6 +380,7 @@ type StatusModel = {
   artifacts: { count: number; groups: { stage: string; files: string[] }[] };
   workflow: WorkflowInfo;
   runtime: RuntimeInfo;
+  orchestration: OrchestrationInfo;
   git: GitInfo;
 };
 
@@ -380,6 +429,26 @@ function renderStatus(model: StatusModel): string[] {
     lines.push(...renderPairs(model.artifacts.groups.map((group) => [group.stage, group.files.join(', ')])));
   }
 
+  lines.push(
+    '',
+    'Orchestration',
+    ...renderPairs([
+      ['status', model.orchestration.status],
+      ['run_id', model.orchestration.runId],
+      ['next_stage', model.orchestration.nextStage],
+      ['pause_code', model.orchestration.pause?.code ?? DASH],
+      ['pause_message', model.orchestration.pause?.message ?? DASH],
+      ['recoverable', model.orchestration.pause ? String(model.orchestration.pause.recoverable) : DASH],
+      ['pending_id', model.orchestration.pendingDelegation?.id ?? DASH],
+      ['pending_role', model.orchestration.pendingDelegation?.role ?? DASH],
+      ['pending_stage', model.orchestration.pendingDelegation?.stage ?? DASH],
+      ['pending_round', model.orchestration.pendingDelegation ? String(model.orchestration.pendingDelegation.round) : DASH],
+      ['pending_artifact', model.orchestration.pendingDelegation?.artifact ?? DASH],
+      ['pending_client', model.orchestration.pendingDelegation?.client ?? DASH],
+      ['pending_status', model.orchestration.pendingDelegation?.status ?? DASH]
+    ])
+  );
+
   lines.push(
     '',
     'Workflow',
@@ -425,6 +494,9 @@ function renderStatus(model: StatusModel): string[] {
 }
 
 function modelTone(model: StatusModel): 'info' | 'success' | 'warning' | 'danger' | 'running' {
+  if (model.orchestration.status === 'paused') return 'warning';
+  if (model.orchestration.status === 'running') return 'running';
+  if (model.orchestration.status === 'completed') return 'success';
   if (model.workflow.state === 'in-progress') return model.workflow.stale === 'yes' ? 'warning' : 'running';
   if (model.metadata.some(([key, value]) => key === 'status' && value === 'completed')) return 'success';
   if (model.metadata.some(([key, value]) => key === 'status' && (value === 'blocked' || value === 'cancelled'))) {
@@ -449,6 +521,7 @@ function buildFromResolved(input: BuildStatusModelInput): StatusModel {
     artifacts: { count: artifacts.length, groups: groupArtifacts(artifacts) },
     workflow,
     runtime: collectRuntime(input.taskDir, workflow, run),
+    orchestration: collectOrchestration(input.taskDir),
     git: collectGit(fm.branch ?? '', run)
   };
 }
@@ -483,6 +556,9 @@ function statusModelToDisplay(model: StatusModel): DisplayMessage {
     `Task ${model.taskId} (${model.shortId})`,
     modelTone(model),
     [
+      ['orchestration', model.orchestration.status],
+      ['run', model.orchestration.runId],
+      ['next', model.orchestration.nextStage],
       ['workflow', model.workflow.state],
       ['step', model.workflow.step],
       ['runtime', model.runtime.status],
@@ -530,8 +606,9 @@ export {
   collectGit,
   collectWorkflow,
   collectRuntime,
+  collectOrchestration,
   renderStatus,
   statusModelToDisplay,
   METADATA_KEYS
 };
-export type { Runner, GitInfo, WorkflowInfo, RuntimeInfo, StatusModel, BuildStatusModelInput };
+export type { Runner, GitInfo, WorkflowInfo, RuntimeInfo, OrchestrationInfo, PendingDelegationInfo, StatusModel, BuildStatusModelInput };