@lumenflow/cli 5.5.0 → 5.7.12

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

@@ -1,328 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-/**
- * 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

@@ -1,20 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-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

@@ -1,348 +0,0 @@
-// Copyright (c) 2026 Hellmai Ltd
-// SPDX-License-Identifier: LicenseRef-LumenFlow-Proprietary
-
-import {
-  DomainPackManifestSchema,
-  POLICY_TRIGGERS,
-  type DomainPackManifest,
-} from '@lumenflow/kernel';
-import {
-  AGENT_RUNTIME_API_KEY_ENV,
-  AGENT_RUNTIME_BASE_URL_ENV,
-  AGENT_RUNTIME_CONFIG_KEY,
-  AGENT_RUNTIME_CONFIG_SCHEMA_FILE,
-  AGENT_RUNTIME_PACK_ID,
-  AGENT_RUNTIME_PACK_VERSION,
-  AGENT_RUNTIME_POLICY_ID_PREFIX,
-  AGENT_RUNTIME_STATIC_PROVIDER_ALLOWLIST,
-  AGENT_RUNTIME_STATIC_PROVIDER_URLS,
-  AGENT_RUNTIME_STORAGE_PATTERN,
-} from './constants.js';
-import {
-  AGENT_RUNTIME_PROVIDER_KINDS,
-  AGENT_RUNTIME_TOOL_NAMES,
-  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>;
-
-/**
- * WU-2829 (INIT-062 WU-C): per-tool input schemas for the six
- * remote-control tools. The previous single shared placeholder forced
- * every tool to accept `reason` even when its real implementation did
- * not read it. Cloud now gets schema-level precision: tools that do
- * not consume `reason` declare only `session_id`; tools that do
- * surface `reason` as an optional operator-supplied rationale.
- *
- * - session_id is required for every tool (ADR-013 §1 + §6 contract).
- * - `reason` is only declared on tools whose operations.ts impl
- *   surfaces it on the emitted event or state store.
- */
-const REMOTE_CONTROL_SESSION_ID_PROPERTY = {
-  session_id: { type: 'string', minLength: 1 },
-} as const;
-
-const REMOTE_CONTROL_REASON_PROPERTY = {
-  reason: { type: 'string', minLength: 1 },
-} as const;
-
-const REMOTE_CONTROL_SESSION_ONLY_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  properties: { ...REMOTE_CONTROL_SESSION_ID_PROPERTY },
-  required: ['session_id'],
-  additionalProperties: false,
-};
-
-const REMOTE_CONTROL_SESSION_AND_REASON_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  properties: {
-    ...REMOTE_CONTROL_SESSION_ID_PROPERTY,
-    ...REMOTE_CONTROL_REASON_PROPERTY,
-  },
-  required: ['session_id'],
-  additionalProperties: false,
-};
-
-const REMOTE_CONTROL_INPUT_SCHEMAS: Record<
-  AgentRuntimeRemoteControlToolName,
-  Record<string, unknown>
-> = {
-  // resume_workflow: clears the pause marker; operations.ts does not
-  // read `reason`.
-  [AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAMES.RESUME_WORKFLOW]: REMOTE_CONTROL_SESSION_ONLY_SCHEMA,
-  // pause_turn: stores `reason` on the pause marker.
-  [AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAMES.PAUSE_TURN]: REMOTE_CONTROL_SESSION_AND_REASON_SCHEMA,
-  // abort_turn: records `reason` on the abort state (default
-  // "operator-requested" when omitted).
-  [AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAMES.ABORT_TURN]: REMOTE_CONTROL_SESSION_AND_REASON_SCHEMA,
-  // elevate_autonomy: surfaces `reason` on the autonomy_changed event.
-  [AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAMES.ELEVATE_AUTONOMY]:
-    REMOTE_CONTROL_SESSION_AND_REASON_SCHEMA,
-  // lower_autonomy: surfaces `reason` on the autonomy_changed event.
-  [AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAMES.LOWER_AUTONOMY]:
-    REMOTE_CONTROL_SESSION_AND_REASON_SCHEMA,
-  // approve_inflight: pops the oldest pending approval; operations.ts
-  // does not read `reason`.
-  [AGENT_RUNTIME_REMOTE_CONTROL_TOOL_NAMES.APPROVE_INFLIGHT]: REMOTE_CONTROL_SESSION_ONLY_SCHEMA,
-};
-
-const REMOTE_CONTROL_READ_SCOPE = {
-  type: 'path',
-  pattern: AGENT_RUNTIME_STORAGE_PATTERN,
-  access: 'read',
-} as const;
-
-const REMOTE_CONTROL_WRITE_SCOPE = {
-  type: 'path',
-  pattern: AGENT_RUNTIME_STORAGE_PATTERN,
-  access: 'write',
-} as const;
-
-const EXECUTE_TURN_INPUT_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  properties: {
-    session_id: { type: 'string', minLength: 1 },
-    model_profile: { type: 'string', minLength: 1 },
-    url: {
-      type: 'string',
-      enum: [...AGENT_RUNTIME_STATIC_PROVIDER_URLS],
-    },
-    stream: {
-      type: 'boolean',
-    },
-    messages: {
-      type: 'array',
-      minItems: 1,
-      items: {
-        type: 'object',
-        properties: {
-          role: {
-            type: 'string',
-            enum: ['system', 'user', 'assistant', 'tool'],
-          },
-          content: { type: 'string' },
-          tool_name: { type: 'string' },
-          tool_call_id: { type: 'string' },
-        },
-        required: ['role', 'content'],
-        additionalProperties: false,
-      },
-    },
-    tool_catalog: {
-      type: 'array',
-      items: {
-        type: 'object',
-        properties: {
-          name: { type: 'string', minLength: 1 },
-          description: { type: 'string', minLength: 1 },
-          input_schema: {
-            type: 'object',
-            additionalProperties: true,
-          },
-        },
-        required: ['name', 'description'],
-        additionalProperties: false,
-      },
-    },
-    intent_catalog: {
-      type: 'array',
-      items: {
-        type: 'object',
-        properties: {
-          id: { type: 'string', minLength: 1 },
-          description: { type: 'string', minLength: 1 },
-        },
-        required: ['id', 'description'],
-        additionalProperties: false,
-      },
-    },
-    limits: {
-      type: 'object',
-      properties: {
-        max_turns_per_session: { type: 'integer', minimum: 1 },
-        max_tool_calls_per_session: { type: 'integer', minimum: 1 },
-        max_input_bytes: { type: 'integer', minimum: 1 },
-      },
-      additionalProperties: false,
-    },
-  },
-  required: ['session_id', 'model_profile', 'url', 'messages'],
-  additionalProperties: false,
-};
-
-const EXECUTE_TURN_OUTPUT_SCHEMA: Record<string, unknown> = {
-  type: 'object',
-  properties: {
-    status: {
-      type: 'string',
-      enum: Object.values(AGENT_RUNTIME_TURN_STATUSES),
-    },
-    intent: { type: 'string', minLength: 1 },
-    assistant_message: { type: 'string' },
-    requested_tool: {
-      type: 'object',
-      properties: {
-        name: { type: 'string', minLength: 1 },
-        input: {
-          type: 'object',
-          additionalProperties: true,
-        },
-      },
-      required: ['name', 'input'],
-      additionalProperties: false,
-    },
-    provider: {
-      type: 'object',
-      properties: {
-        kind: {
-          type: 'string',
-          enum: Object.values(AGENT_RUNTIME_PROVIDER_KINDS),
-        },
-        model: { type: 'string', minLength: 1 },
-      },
-      required: ['kind', 'model'],
-      additionalProperties: false,
-    },
-    usage: {
-      type: 'object',
-      properties: {
-        input_tokens: { type: 'integer', minimum: 0 },
-        output_tokens: { type: 'integer', minimum: 0 },
-        total_tokens: { type: 'integer', minimum: 0 },
-      },
-      additionalProperties: false,
-    },
-    finish_reason: { type: 'string', minLength: 1 },
-  },
-  required: ['status', 'intent', 'assistant_message', 'provider', 'finish_reason'],
-  additionalProperties: false,
-};
-
-function buildRemoteControlToolDefinition(name: AgentRuntimeRemoteControlToolName): {
-  name: AgentRuntimeRemoteControlToolName;
-  entry: string;
-  permission: 'write';
-  required_scopes: readonly [typeof REMOTE_CONTROL_READ_SCOPE, typeof REMOTE_CONTROL_WRITE_SCOPE];
-  required_approvals: readonly string[];
-  input_schema: Record<string, unknown>;
-} {
-  return {
-    name,
-    entry: REMOTE_CONTROL_TOOL_ENTRIES[name],
-    permission: 'write',
-    required_scopes: [REMOTE_CONTROL_READ_SCOPE, REMOTE_CONTROL_WRITE_SCOPE],
-    required_approvals: [...AGENT_RUNTIME_REMOTE_CONTROL_APPROVALS[name]],
-    input_schema: REMOTE_CONTROL_INPUT_SCHEMAS[name],
-  };
-}
-
-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,
-  version: AGENT_RUNTIME_PACK_VERSION,
-  config_key: AGENT_RUNTIME_CONFIG_KEY,
-  config_schema: AGENT_RUNTIME_CONFIG_SCHEMA_FILE,
-  capability_factory: CAPABILITY_FACTORY_ENTRY,
-  policy_factory: POLICY_FACTORY_ENTRY,
-  task_types: ['agent-session'],
-  tools: MANIFEST_TOOL_DEFINITIONS,
-  policies: [
-    {
-      id: `${AGENT_RUNTIME_POLICY_ID_PREFIX}.default`,
-      trigger: POLICY_TRIGGERS.ON_TOOL_REQUEST,
-      decision: 'allow',
-      reason: 'Pack baseline allow; dynamic intent gating is applied by the pack policy factory.',
-    },
-  ],
-  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',
-  },
-  lane_templates: [],
-}) satisfies DomainPackManifest;
-
-export type AgentRuntimePackManifest = typeof AGENT_RUNTIME_MANIFEST;
-export type AgentRuntimeManifestTool = AgentRuntimePackManifest['tools'][number];
-
-export const AGENT_RUNTIME_MANIFEST_TOOL_NAMES = AGENT_RUNTIME_MANIFEST.tools.map(
-  (tool) => tool.name,
-) 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];
-}