@lumenflow/cli 4.23.0 → 5.0.0

package/packs/agent-runtime/delegation-tree.ts

@@ -0,0 +1,328 @@
+// Copyright (c) 2026 Hellmai Ltd
+// SPDX-License-Identifier: AGPL-3.0-only
+
+/**
+ * Delegation Tree Builder (ADR-014 follow-up, WU-2763)
+ *
+ * Builds and formats delegation trees for visualization.
+ *
+ * Core now re-exports this module as a compatibility shim.
+ */
+
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { parse as parseYAML } from 'yaml';
+import { DelegationRegistryStore } from './delegation-registry-store.js';
+import {
+  DelegationStatus,
+  type DelegationOwnershipScope,
+  type DelegationRoleDescriptor,
+  type DelegationSchemaVersion,
+} from './delegation-registry-schema.js';
+
+interface RegistryRecord {
+  id: string;
+  parentWuId: string;
+  targetWuId: string;
+  lane: string;
+  status: string;
+  delegatedAt: string;
+  completedAt: string | null;
+  pickedUpAt?: string;
+  pickedUpBy?: string;
+  schemaVersion?: DelegationSchemaVersion;
+  requested_role?: DelegationRoleDescriptor;
+  actual_role?: DelegationRoleDescriptor;
+  capabilities?: string[];
+  ownership_scope?: DelegationOwnershipScope;
+}
+
+interface DelegationRecord {
+  id: string;
+  parentWuId: string;
+  targetWuId: string;
+  lane: string;
+  status: string;
+  delegatedAt: string;
+  completedAt: string | null;
+  pickedUpAt?: string;
+  pickedUpBy?: string;
+  schemaVersion?: DelegationSchemaVersion;
+  requested_role?: DelegationRoleDescriptor;
+  actual_role?: DelegationRoleDescriptor;
+  capabilities?: string[];
+  ownership_scope?: DelegationOwnershipScope;
+}
+
+interface DelegationTreeNode {
+  wuId: string;
+  delegationId: string | null;
+  status: string | null;
+  lane: string | null;
+  delegatedAt: string | null;
+  children: DelegationTreeNode[];
+  schemaVersion?: DelegationSchemaVersion;
+  requested_role?: DelegationRoleDescriptor;
+  actual_role?: DelegationRoleDescriptor;
+  capabilities?: string[];
+  ownership_scope?: DelegationOwnershipScope;
+}
+
+/**
+ * Status indicators for terminal output.
+ */
+export const STATUS_INDICATORS = Object.freeze({
+  [DelegationStatus.PENDING]: '\u25CB',
+  [DelegationStatus.COMPLETED]: '\u2713',
+  [DelegationStatus.TIMEOUT]: '\u23F1',
+  [DelegationStatus.CRASHED]: '\u2717',
+  [DelegationStatus.ESCALATED]: '!',
+});
+
+const TREE_CHARS = Object.freeze({
+  VERTICAL: '\u2502',
+  BRANCH: '\u251C',
+  LAST_BRANCH: '\u2514',
+  HORIZONTAL: '\u2500',
+});
+
+function getStatusIndicator(status: string | null): string {
+  switch (status) {
+    case DelegationStatus.PENDING:
+      return STATUS_INDICATORS[DelegationStatus.PENDING];
+    case DelegationStatus.COMPLETED:
+      return STATUS_INDICATORS[DelegationStatus.COMPLETED];
+    case DelegationStatus.TIMEOUT:
+      return STATUS_INDICATORS[DelegationStatus.TIMEOUT];
+    case DelegationStatus.CRASHED:
+      return STATUS_INDICATORS[DelegationStatus.CRASHED];
+    case DelegationStatus.ESCALATED:
+      return STATUS_INDICATORS[DelegationStatus.ESCALATED];
+    default:
+      return '?';
+  }
+}
+
+function toDelegationRecord(record: RegistryRecord): DelegationRecord {
+  return {
+    id: record.id,
+    parentWuId: record.parentWuId,
+    targetWuId: record.targetWuId,
+    lane: record.lane,
+    status: record.status,
+    delegatedAt: record.delegatedAt,
+    completedAt: record.completedAt,
+    pickedUpAt: record.pickedUpAt,
+    pickedUpBy: record.pickedUpBy,
+    schemaVersion: record.schemaVersion,
+    requested_role: record.requested_role,
+    actual_role: record.actual_role,
+    capabilities: record.capabilities,
+    ownership_scope: record.ownership_scope,
+  };
+}
+
+/**
+ * Builds a delegation tree from flat delegation events.
+ */
+export function buildDelegationTree(
+  delegations: DelegationRecord[],
+  rootWuId: string,
+): DelegationTreeNode {
+  const root: DelegationTreeNode = {
+    wuId: rootWuId,
+    delegationId: null,
+    status: null,
+    lane: null,
+    delegatedAt: null,
+    children: [],
+  };
+
+  if (delegations.length === 0) {
+    return root;
+  }
+
+  const delegationsByParent = new Map<string, DelegationRecord[]>();
+  for (const delegation of delegations) {
+    const existing = delegationsByParent.get(delegation.parentWuId) ?? [];
+    existing.push(delegation);
+    delegationsByParent.set(delegation.parentWuId, existing);
+  }
+
+  const buildChildren = (parentWuId: string): DelegationTreeNode[] => {
+    const childDelegations = delegationsByParent.get(parentWuId) ?? [];
+    return childDelegations.map((delegation) => ({
+      wuId: delegation.targetWuId,
+      delegationId: delegation.id,
+      status: delegation.status,
+      lane: delegation.lane,
+      delegatedAt: delegation.delegatedAt,
+      children: buildChildren(delegation.targetWuId),
+      schemaVersion: delegation.schemaVersion,
+      requested_role: delegation.requested_role,
+      actual_role: delegation.actual_role,
+      capabilities: delegation.capabilities,
+      ownership_scope: delegation.ownership_scope,
+    }));
+  };
+
+  root.children = buildChildren(rootWuId);
+  return root;
+}
+
+/**
+ * Formats a delegation tree for terminal display.
+ */
+export function formatDelegationTree(tree: DelegationTreeNode): string {
+  const lines: string[] = [];
+  lines.push(`${tree.wuId} (root)`);
+
+  if (tree.children.length === 0) {
+    lines.push('  (no delegations)');
+    return lines.join('\n');
+  }
+
+  const formatChildren = (children: DelegationTreeNode[], prefix: string): void => {
+    children.forEach((child, index) => {
+      const isLast = index === children.length - 1;
+      const branch = isLast
+        ? `${TREE_CHARS.LAST_BRANCH}${TREE_CHARS.HORIZONTAL}${TREE_CHARS.HORIZONTAL}`
+        : `${TREE_CHARS.BRANCH}${TREE_CHARS.HORIZONTAL}${TREE_CHARS.HORIZONTAL}`;
+      const indicator = getStatusIndicator(child.status);
+      const delegationInfo = child.delegationId ? ` [${child.delegationId}]` : '';
+      const laneInfo = child.lane ? ` (${child.lane})` : '';
+
+      lines.push(`${prefix}${branch} ${indicator} ${child.wuId}${delegationInfo}${laneInfo}`);
+
+      const childPrefix = prefix + (isLast ? '    ' : `${TREE_CHARS.VERTICAL}   `);
+      formatChildren(child.children, childPrefix);
+    });
+  };
+
+  formatChildren(tree.children, '');
+  return lines.join('\n');
+}
+
+/**
+ * Gets all delegations for a WU (direct + descendants).
+ */
+export async function getDelegationsByWU(
+  wuId: string,
+  baseDir: string,
+): Promise<DelegationRecord[]> {
+  const store = new DelegationRegistryStore(baseDir);
+
+  try {
+    await store.load();
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+
+  const allRecords = store.getAllDelegations();
+  if (allRecords.length === 0) {
+    return [];
+  }
+
+  const result: DelegationRecord[] = [];
+  const seenDelegationIds = new Set<string>();
+  const visitedWuIds = new Set<string>();
+  const queue = [wuId];
+
+  while (queue.length > 0) {
+    const currentWuId = queue.shift();
+    if (!currentWuId || visitedWuIds.has(currentWuId)) {
+      continue;
+    }
+
+    visitedWuIds.add(currentWuId);
+    const childRecords = store.getByParent(currentWuId) as RegistryRecord[];
+    for (const child of childRecords) {
+      if (!seenDelegationIds.has(child.id)) {
+        result.push(toDelegationRecord(child));
+        seenDelegationIds.add(child.id);
+      }
+      queue.push(child.targetWuId);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Gets all delegations for an initiative.
+ */
+export async function getDelegationsByInitiative(
+  initiativeId: string,
+  registryDir: string,
+  wuDir: string,
+): Promise<DelegationRecord[]> {
+  const initiativeWuIds = await getWUsForInitiative(initiativeId, wuDir);
+  if (initiativeWuIds.size === 0) {
+    return [];
+  }
+
+  const store = new DelegationRegistryStore(registryDir);
+  try {
+    await store.load();
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return [];
+    }
+    throw error;
+  }
+
+  return (store.getAllDelegations() as RegistryRecord[])
+    .filter((record) => initiativeWuIds.has(record.parentWuId))
+    .map(toDelegationRecord);
+}
+
+async function getWUsForInitiative(initiativeId: string, wuDir: string): Promise<Set<string>> {
+  const wuIds = new Set<string>();
+  let files: string[];
+
+  try {
+    files = await fs.readdir(wuDir);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      return wuIds;
+    }
+    throw error;
+  }
+
+  const wuFiles = files.filter((file) => file.startsWith('WU-') && file.endsWith('.yaml'));
+  for (const file of wuFiles) {
+    try {
+      const content = await fs.readFile(path.join(wuDir, file), 'utf-8');
+      const doc = parseYAML(content) as { initiative?: string; id?: string };
+      if (doc.initiative === initiativeId && typeof doc.id === 'string') {
+        wuIds.add(doc.id);
+      }
+    } catch {
+      continue;
+    }
+  }
+
+  return wuIds;
+}
+
+/**
+ * Converts a delegation tree to JSON.
+ */
+export function treeToJSON(tree: DelegationTreeNode): DelegationTreeNode {
+  return {
+    wuId: tree.wuId,
+    delegationId: tree.delegationId,
+    status: tree.status,
+    lane: tree.lane,
+    delegatedAt: tree.delegatedAt,
+    ...(tree.schemaVersion !== undefined ? { schemaVersion: tree.schemaVersion } : {}),
+    ...(tree.requested_role !== undefined ? { requested_role: tree.requested_role } : {}),
+    ...(tree.actual_role !== undefined ? { actual_role: tree.actual_role } : {}),
+    ...(tree.capabilities !== undefined ? { capabilities: tree.capabilities } : {}),
+    ...(tree.ownership_scope !== undefined ? { ownership_scope: tree.ownership_scope } : {}),
+    children: tree.children.map((child): DelegationTreeNode => treeToJSON(child)),
+  };
+}

package/packs/agent-runtime/index.ts

@@ -3,9 +3,18 @@
 
 export * from './constants.js';
 export * from './capability-factory.js';
+export * from './agent-heartbeat.js';
+export * from './auto-session-integration.js';
+export * from './delegation-registry-schema.js';
+export * from './delegation-registry-store.js';
+export * from './delegation-tree.js';
 export * from './manifest.js';
+export * from './memory-coordination-contract.js';
 export * from './orchestration.js';
 export * from './pack-registration.js';
 export * from './policy-factory.js';
+export * from './remote-controls/index.js';
+export * from './session-schema.js';
+export * from './turn-lifecycle-events.js';
 export * from './types.js';
 export * from './tools/index.js';

package/packs/agent-runtime/manifest.ts

@@ -24,11 +24,55 @@ import {
   AGENT_RUNTIME_TURN_STATUSES,
   type AgentRuntimeToolName,
 } from './types.js';
+import { AGENT_RUNTIME_EVENT_KIND_VALUES as AGENT_RUNTIME_EMITTED_EVENT_KIND_VALUES } from './turn-lifecycle-events.js';
+import {
+  AGENT_RUNTIME_REMOTE_CONTROL_APPROVALS,
+  AGENT_RUNTIME_REMOTE_CONTROL_APPROVAL_ID,
+  AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAMES,
+  AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAME_VALUES,
+  type AgentRuntimeRemoteControlToolName,
+} from './remote-controls/types.js';
 
 const EXECUTE_TURN_TOOL_ENTRY = 'tool-impl/agent-turn-tools.ts#agentExecuteTurnTool';
 const CAPABILITY_FACTORY_ENTRY = 'capability-factory.ts#createAgentRuntimeCapabilityFactory';
 const POLICY_FACTORY_ENTRY = 'policy-factory.ts#createAgentRuntimePolicyFactory';
 
+// WU-2733 (INIT-060 Phase 3, ADR-013 §1 + §6 governance): real
+// kernel-side entries. The tracer-bullet mock entries from WU-2732
+// (previously at tool-impl/remote-controls.mock.ts) are superseded;
+// mock exports remain in-tree only for contract-pin unit tests. Tool
+// names, permissions, scopes, approvals, and input schemas stay
+// identical — the wire contract is frozen.
+const REMOTE_CONTROL_TOOL_ENTRIES = {
+  [AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAMES.RESUME_WORKFLOW]:
+    'tool-impl/remote-controls.ts#resumeWorkflowTool',
+  [AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAMES.PAUSE_TURN]:
+    'tool-impl/remote-controls.ts#pauseTurnTool',
+  [AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAMES.ABORT_TURN]:
+    'tool-impl/remote-controls.ts#abortTurnTool',
+  [AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAMES.ELEVATE_AUTONOMY]:
+    'tool-impl/remote-controls.ts#elevateAutonomyTool',
+  [AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAMES.LOWER_AUTONOMY]:
+    'tool-impl/remote-controls.ts#lowerAutonomyTool',
+  [AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAMES.APPROVE_INFLIGHT]:
+    'tool-impl/remote-controls.ts#approveInflightTool',
+} as const satisfies Record<AgentRuntimeRemoteControlToolName, string>;
+
+const REMOTE_CONTROL_INPUT_SCHEMA: Record<string, unknown> = {
+  type: 'object',
+  properties: {
+    session_id: { type: 'string', minLength: 1 },
+    reason: { type: 'string', minLength: 1 },
+  },
+  additionalProperties: false,
+};
+
+const REMOTE_CONTROL_STORAGE_SCOPE = {
+  type: 'path',
+  pattern: AGENT_RUNTIME_STORAGE_PATTERN,
+  access: 'read',
+} as const;
+
 const EXECUTE_TURN_INPUT_SCHEMA: Record<string, unknown> = {
   type: 'object',
   properties: {
@@ -149,25 +193,48 @@ const EXECUTE_TURN_OUTPUT_SCHEMA: Record<string, unknown> = {
   additionalProperties: false,
 };
 
-const MANIFEST_TOOL_DEFINITIONS = [
-  {
-    name: AGENT_RUNTIME_TOOL_NAMES.EXECUTE_TURN,
-    entry: EXECUTE_TURN_TOOL_ENTRY,
+function buildRemoteControlToolDefinition(name: AgentRuntimeRemoteControlToolName): {
+  name: AgentRuntimeRemoteControlToolName;
+  entry: string;
+  permission: 'write';
+  required_scopes: readonly [typeof REMOTE_CONTROL_STORAGE_SCOPE];
+  required_approvals: readonly string[];
+  input_schema: Record<string, unknown>;
+} {
+  return {
+    name,
+    entry: REMOTE_CONTROL_TOOL_ENTRIES[name],
     permission: 'write',
-    required_scopes: [
-      { type: 'path', pattern: AGENT_RUNTIME_STORAGE_PATTERN, access: 'read' },
-      { type: 'path', pattern: AGENT_RUNTIME_STORAGE_PATTERN, access: 'write' },
-      {
-        type: 'network',
-        posture: 'allowlist',
-        allowlist_entries: [...AGENT_RUNTIME_STATIC_PROVIDER_ALLOWLIST],
-      },
-    ],
-    required_env: [AGENT_RUNTIME_API_KEY_ENV, AGENT_RUNTIME_BASE_URL_ENV],
-    input_schema: EXECUTE_TURN_INPUT_SCHEMA,
-    output_schema: EXECUTE_TURN_OUTPUT_SCHEMA,
-  },
-] as const;
+    required_scopes: [REMOTE_CONTROL_STORAGE_SCOPE],
+    required_approvals: [...AGENT_RUNTIME_REMOTE_CONTROL_APPROVALS[name]],
+    input_schema: REMOTE_CONTROL_INPUT_SCHEMA,
+  };
+}
+
+const EXECUTE_TURN_TOOL_DEFINITION = {
+  name: AGENT_RUNTIME_TOOL_NAMES.EXECUTE_TURN,
+  entry: EXECUTE_TURN_TOOL_ENTRY,
+  permission: 'write',
+  required_scopes: [
+    { type: 'path', pattern: AGENT_RUNTIME_STORAGE_PATTERN, access: 'read' },
+    { type: 'path', pattern: AGENT_RUNTIME_STORAGE_PATTERN, access: 'write' },
+    {
+      type: 'network',
+      posture: 'allowlist',
+      allowlist_entries: [...AGENT_RUNTIME_STATIC_PROVIDER_ALLOWLIST],
+    },
+  ],
+  required_env: [AGENT_RUNTIME_API_KEY_ENV, AGENT_RUNTIME_BASE_URL_ENV],
+  input_schema: EXECUTE_TURN_INPUT_SCHEMA,
+  output_schema: EXECUTE_TURN_OUTPUT_SCHEMA,
+} as const;
+
+const MANIFEST_TOOL_DEFINITIONS = [
+  EXECUTE_TURN_TOOL_DEFINITION,
+  ...AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAME_VALUES.map((name) =>
+    buildRemoteControlToolDefinition(name),
+  ),
+];
 
 export const AGENT_RUNTIME_MANIFEST = DomainPackManifestSchema.parse({
   id: AGENT_RUNTIME_PACK_ID,
@@ -187,6 +254,8 @@ export const AGENT_RUNTIME_MANIFEST = DomainPackManifestSchema.parse({
     },
   ],
   evidence_types: ['agent-runtime.turn', 'agent-runtime.provider-call'],
+  emitted_event_kinds: [...AGENT_RUNTIME_EMITTED_EVENT_KIND_VALUES],
+  required_approvals: [AGENT_RUNTIME_REMOTE_CONTROL_APPROVAL_ID],
   state_aliases: {
     paused: 'waiting',
   },
@@ -198,10 +267,25 @@ export type AgentRuntimeManifestTool = AgentRuntimePackManifest['tools'][number]
 
 export const AGENT_RUNTIME_MANIFEST_TOOL_NAMES = AGENT_RUNTIME_MANIFEST.tools.map(
   (tool) => tool.name,
-) as readonly AgentRuntimeToolName[];
+) as readonly (AgentRuntimeToolName | AgentRuntimeRemoteControlToolName)[];
 
 export function getAgentRuntimeManifestToolByName(
   name: string,
 ): AgentRuntimeManifestTool | undefined {
   return AGENT_RUNTIME_MANIFEST.tools.find((tool) => tool.name === name);
 }
+
+/**
+ * WU-2732 (INIT-060 Phase 3, ADR-013 §3 tool exposure): the 6
+ * remote-callable remote-control tools. The HTTP tool-api surface
+ * uses this list to build its allowlist so the set is the single
+ * source of truth (mirrors WU-2729 software-delivery precedent —
+ * no duplicate allowlist in surface code).
+ */
+export const AGENT_RUNTIME_REMOTE_CALLABLE_TOOLS = [
+  ...AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAME_VALUES,
+] as const satisfies readonly AgentRuntimeRemoteControlToolName[];
+
+export function getAgentRuntimeRemoteCallableToolNames(): AgentRuntimeRemoteControlToolName[] {
+  return [...AGENT_RUNTIME_REMOTE_CALLABLE_TOOLS];
+}

package/packs/agent-runtime/manifest.yaml

@@ -180,6 +180,120 @@ tools:
         - provider
         - finish_reason
       additionalProperties: false
+  # WU-2732 (INIT-060 Phase 3, ADR-013 §1 + §6): six remote-control tools
+  # with mock tracer-bullet implementations. Real impls replace the mock
+  # entries in WU-2733 without changing names, scopes, or approvals.
+  - name: agent-runtime:resume_workflow
+    entry: tool-impl/remote-controls.ts#resumeWorkflowTool
+    permission: write
+    required_scopes:
+      - type: path
+        pattern: .agent-runtime/**
+        access: read
+    required_approvals: []
+    input_schema:
+      type: object
+      properties:
+        session_id:
+          type: string
+          minLength: 1
+        reason:
+          type: string
+          minLength: 1
+      additionalProperties: false
+  - name: agent-runtime:pause_turn
+    entry: tool-impl/remote-controls.ts#pauseTurnTool
+    permission: write
+    required_scopes:
+      - type: path
+        pattern: .agent-runtime/**
+        access: read
+    required_approvals:
+      - agent-runtime:remote_control
+    input_schema:
+      type: object
+      properties:
+        session_id:
+          type: string
+          minLength: 1
+        reason:
+          type: string
+          minLength: 1
+      additionalProperties: false
+  - name: agent-runtime:abort_turn
+    entry: tool-impl/remote-controls.ts#abortTurnTool
+    permission: write
+    required_scopes:
+      - type: path
+        pattern: .agent-runtime/**
+        access: read
+    required_approvals:
+      - agent-runtime:remote_control
+    input_schema:
+      type: object
+      properties:
+        session_id:
+          type: string
+          minLength: 1
+        reason:
+          type: string
+          minLength: 1
+      additionalProperties: false
+  - name: agent-runtime:elevate_autonomy
+    entry: tool-impl/remote-controls.ts#elevateAutonomyTool
+    permission: write
+    required_scopes:
+      - type: path
+        pattern: .agent-runtime/**
+        access: read
+    required_approvals:
+      - agent-runtime:remote_control
+    input_schema:
+      type: object
+      properties:
+        session_id:
+          type: string
+          minLength: 1
+        reason:
+          type: string
+          minLength: 1
+      additionalProperties: false
+  - name: agent-runtime:lower_autonomy
+    entry: tool-impl/remote-controls.ts#lowerAutonomyTool
+    permission: write
+    required_scopes:
+      - type: path
+        pattern: .agent-runtime/**
+        access: read
+    required_approvals: []
+    input_schema:
+      type: object
+      properties:
+        session_id:
+          type: string
+          minLength: 1
+        reason:
+          type: string
+          minLength: 1
+      additionalProperties: false
+  - name: agent-runtime:approve_inflight
+    entry: tool-impl/remote-controls.ts#approveInflightTool
+    permission: write
+    required_scopes:
+      - type: path
+        pattern: .agent-runtime/**
+        access: read
+    required_approvals: []
+    input_schema:
+      type: object
+      properties:
+        session_id:
+          type: string
+          minLength: 1
+        reason:
+          type: string
+          minLength: 1
+      additionalProperties: false
 policies:
   - id: agent-runtime.policy.default
     trigger: on_tool_request
@@ -188,6 +302,24 @@ policies:
 evidence_types:
   - agent-runtime.turn
   - agent-runtime.provider-call
+required_approvals:
+  - agent-runtime:remote_control
+emitted_event_kinds:
+  - agent-runtime:turn_started
+  - agent-runtime:turn_completed
+  - agent-runtime:turn_aborted
+  - agent-runtime:tool_called
+  - agent-runtime:approval_required
+  - agent-runtime:workflow_node_started
+  - agent-runtime:workflow_node_completed
+  - agent-runtime:workflow_node_failed
+  - agent-runtime:workflow_paused
+  - agent-runtime:scheduled_wakeup_set
+  - agent-runtime:budget_threshold
+  - agent-runtime:agent_session_enrolled
+  - agent-runtime:agent_session_ended
+  - agent-runtime:agent_session_stalled
+  - agent-runtime:autonomy_changed
 state_aliases:
   paused: waiting
 lane_templates: []