@moretea-labs/forge 1.7.2 → 1.8.1

package/src/runtime/platform/service-manager.ts

@@ -0,0 +1,146 @@
+import { spawn, spawnSync } from 'child_process';
+import { closeSync, mkdirSync, openSync } from 'fs';
+import { dirname } from 'path';
+import {
+  bootstrapLaunchAgentWithRetryV2,
+  bootoutLaunchAgentWithRetryV2,
+  currentUserLaunchdDomain,
+  installLaunchAgent,
+  launchAgentPath,
+  retireConflictingForgeLaunchAgents,
+  retireLaunchAgentExact,
+  type ExactLaunchAgentRetirementResult,
+} from '../../cli/controller/launch-agents';
+import {
+  installSystemdUserUnit,
+  renderSystemdUserUnit,
+  systemdUserAvailable,
+  writeSystemdUserUnit,
+  systemdUserInstallCommands,
+  retireSystemdUserUnitExact,
+  type ExactSystemdUserUnitRetirementResult,
+  type SystemdUserUnitInput,
+} from '../../cli/controller/systemd-user';
+
+export type { SystemdUserUnitInput } from '../../cli/controller/systemd-user';
+
+export type PlatformServiceManagerKind = 'launchd' | 'systemd-user' | 'portable';
+
+export interface PlatformServiceManagerSelection {
+  kind: PlatformServiceManagerKind;
+  persistent: boolean;
+  reason: string;
+}
+
+export interface PlatformDetachedProcessInput {
+  executable: string;
+  args: string[];
+  environment: NodeJS.ProcessEnv;
+  stdoutPath: string;
+  stderrPath: string;
+  errorCode: string;
+}
+
+export interface PlatformServiceManagerHost {
+  selection: PlatformServiceManagerSelection;
+  renderSystemdUserUnit(input: SystemdUserUnitInput): string;
+  installSystemdUserUnit(input: { unitName: string; unit: SystemdUserUnitInput; env?: NodeJS.ProcessEnv; errorPrefix: string }): string;
+  writeSystemdUserUnit(unitName: string, unit: SystemdUserUnitInput, env?: NodeJS.ProcessEnv): string;
+  systemdUserInstallCommands(unitName: string): string[][];
+  launchdInstalledPath(label: string, accountHome?: string): string;
+  installLaunchd(sourcePath: string, label: string): void;
+  bootstrapLaunchd(input: { label: string; plistPath: string }): Promise<{ ok: boolean; diagnostics: string[] }>;
+  bootoutLaunchd(input: { label: string; plistPath: string }): Promise<{ ok: boolean; diagnostics: string[] }>;
+  retireConflictingLaunchd(input: Parameters<typeof retireConflictingForgeLaunchAgents>[0]): ReturnType<typeof retireConflictingForgeLaunchAgents>;
+  retireLaunchdExact(input: { label: string; accountHome?: string }): Promise<ExactLaunchAgentRetirementResult>;
+  retireSystemdUserExact(input: { unitName: string; env?: NodeJS.ProcessEnv }): ExactSystemdUserUnitRetirementResult;
+  launchdDomain(): string;
+  detachLaunchdBootout(label: string): void;
+  startDetached(input: PlatformDetachedProcessInput): number;
+}
+
+/** Pure product-level selection. Platform adapters own probing/install mechanics. */
+export function resolvePlatformServiceManager(input: {
+  platform: NodeJS.Platform;
+  forcePortable?: boolean;
+  systemdUserAvailable?: boolean;
+}): PlatformServiceManagerSelection {
+  if (input.forcePortable === true) {
+    return { kind: 'portable', persistent: false, reason: 'portable_explicitly_requested' };
+  }
+  if (input.platform === 'darwin') {
+    return { kind: 'launchd', persistent: true, reason: 'macos_launchd_available' };
+  }
+  if (input.platform === 'linux' && input.systemdUserAvailable === true) {
+    return { kind: 'systemd-user', persistent: true, reason: 'linux_systemd_user_available' };
+  }
+  if (input.platform === 'linux') {
+    return { kind: 'portable', persistent: false, reason: 'linux_systemd_user_unavailable' };
+  }
+  if (input.platform === 'win32') {
+    return { kind: 'portable', persistent: false, reason: 'windows_native_persistence_preview' };
+  }
+  return { kind: 'portable', persistent: false, reason: 'platform_service_manager_unsupported' };
+}
+
+export function createPlatformServiceManagerHost(input: {
+  platform?: NodeJS.Platform;
+  env?: NodeJS.ProcessEnv;
+  forcePortable?: boolean;
+  systemdUserAvailable?: boolean;
+} = {}): PlatformServiceManagerHost {
+  const platform = input.platform ?? process.platform;
+  const env = input.env ?? process.env;
+  const systemdAvailable = input.systemdUserAvailable ?? (platform === 'linux' ? systemdUserAvailable(env) : false);
+  const selection = resolvePlatformServiceManager({ platform, forcePortable: input.forcePortable, systemdUserAvailable: systemdAvailable });
+  return {
+    selection,
+    renderSystemdUserUnit,
+    installSystemdUserUnit,
+    writeSystemdUserUnit,
+    systemdUserInstallCommands,
+    launchdInstalledPath: launchAgentPath,
+    installLaunchd: installLaunchAgent,
+    bootstrapLaunchd: bootstrapLaunchAgentWithRetryV2,
+    bootoutLaunchd: bootoutLaunchAgentWithRetryV2,
+    retireConflictingLaunchd: retireConflictingForgeLaunchAgents,
+    retireLaunchdExact: retireLaunchAgentExact,
+    retireSystemdUserExact: retireSystemdUserUnitExact,
+    launchdDomain: currentUserLaunchdDomain,
+    detachLaunchdBootout(label: string): void {
+      if (platform !== 'darwin') return;
+      const child = spawn('/bin/launchctl', ['bootout', `${currentUserLaunchdDomain()}/${label}`], {
+        detached: true, stdio: 'ignore', env: { PATH: '/usr/bin:/bin:/usr/sbin:/sbin' },
+      });
+      child.unref();
+    },
+    startDetached(processInput: PlatformDetachedProcessInput): number {
+      mkdirSync(dirname(processInput.stdoutPath), { recursive: true, mode: 0o700 });
+      const stdout = openSync(processInput.stdoutPath, 'a', 0o600);
+      const stderr = openSync(processInput.stderrPath, 'a', 0o600);
+      try {
+        const child = spawn(processInput.executable, processInput.args, {
+          detached: true, stdio: ['ignore', stdout, stderr], env: processInput.environment,
+        });
+        if (!child.pid) throw new Error(`${processInput.errorCode}: child pid unavailable`);
+        child.unref();
+        return child.pid;
+      } finally {
+        closeSync(stdout);
+        closeSync(stderr);
+      }
+    },
+  };
+}
+
+export function platformLaunchdInstalledPath(label: string, accountHome?: string): string {
+  return launchAgentPath(label, accountHome);
+}
+
+export function probeSystemdUserAvailable(env: NodeJS.ProcessEnv = process.env): boolean {
+  return systemdUserAvailable(env);
+}
+
+export function probeSystemdUserAvailableDirect(env: NodeJS.ProcessEnv = process.env): boolean {
+  return spawnSync('systemctl', ['--user', 'show-environment'], { encoding: 'utf8', env, timeout: 30_000 }).status === 0;
+}

package/src/runtime/platform/windows-host-discovery.ts

@@ -0,0 +1,118 @@
+import { spawnSync } from 'child_process';
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+
+export interface WindowsHostEnvironment {
+  commandExecutable: string;
+  userProfileWindows: string;
+  userProfile: string;
+  localAppDataWindows?: string;
+  localAppData?: string;
+  programFilesWindows: string[];
+  programFiles: string[];
+  programDataWindows?: string;
+  programData?: string;
+  systemRootWindows?: string;
+  systemRoot?: string;
+  driveMounts: Readonly<Record<string, string>>;
+}
+
+export interface WindowsHostDiscoveryOptions {
+  fileExists?: typeof existsSync;
+  readText?: (path: string) => string;
+  commandCandidates?: readonly string[];
+  runCommand?: (executable: string, args: readonly string[]) => { status: number | null; stdout: string };
+  mountTable?: string;
+}
+
+function unescapeMount(value: string): string {
+  return value.replace(/\\040/g, ' ').replace(/\\011/g, '\t').replace(/\\134/g, '\\');
+}
+
+export function discoverWslWindowsDriveMounts(mountTable: string): Record<string, string> {
+  const mounts: Record<string, string> = {};
+  for (const line of mountTable.split(/\r?\n/)) {
+    if (!line.trim()) continue;
+    const fields = line.split(' ');
+    const source = unescapeMount(fields[0] ?? '');
+    const mountPoint = unescapeMount(fields[1] ?? '');
+    const fsType = fields[2] ?? '';
+    const sourceDrive = /^([A-Za-z]):(?:\\|$)/.exec(source)?.[1]?.toLowerCase();
+    const optionDrive = /(?:^|,)aname=drvfs;path=([A-Za-z]):(?:\\|,|$)/.exec(fields.slice(3).join(' '))?.[1]?.toLowerCase();
+    const drive = sourceDrive ?? optionDrive;
+    if (drive && mountPoint.startsWith('/') && (fsType === '9p' || fsType === 'drvfs')) mounts[drive] = mountPoint;
+  }
+  return mounts;
+}
+
+export function windowsPathToHostPath(value: string, driveMounts: Readonly<Record<string, string>>): string | undefined {
+  if (value.startsWith('/')) return value;
+  const normalized = value.trim().replace(/^"|"$/g, '').replace(/\\/g, '/');
+  const match = /^([A-Za-z]):\/(.*)$/.exec(normalized);
+  if (!match) return undefined;
+  const mount = driveMounts[match[1]!.toLowerCase()];
+  return mount ? join(mount, match[2]!) : undefined;
+}
+
+
+export function hostPathToWindowsPath(value: string, driveMounts: Readonly<Record<string, string>>): string | undefined {
+  const normalized = value.replace(/\\/g, '/');
+  const entries = Object.entries(driveMounts).sort((left, right) => right[1].length - left[1].length);
+  for (const [drive, mountRoot] of entries) {
+    const root = mountRoot.endsWith('/') ? mountRoot.slice(0, -1) : mountRoot;
+    if (normalized === root) return `${drive.toUpperCase()}:\\`;
+    if (normalized.startsWith(`${root}/`)) return `${drive.toUpperCase()}:\\${normalized.slice(root.length + 1).replace(/\//g, '\\')}`;
+  }
+  return undefined;
+}
+
+function parseEnvironment(stdout: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  for (const line of stdout.split(/\r?\n/)) {
+    const match = /^FORGE_([A-Z0-9_]+)=(.*)$/.exec(line.trim());
+    if (match && match[2]!.trim() && !/%[^%]+%/.test(match[2]!)) result[match[1]!] = match[2]!.trim();
+  }
+  return result;
+}
+
+export function discoverWslWindowsHostEnvironment(options: WindowsHostDiscoveryOptions = {}): WindowsHostEnvironment | undefined {
+  const fileExists = options.fileExists ?? existsSync;
+  const readText = options.readText ?? ((path: string) => readFileSync(path, 'utf8'));
+  let mountTable = options.mountTable;
+  if (mountTable === undefined) {
+    try { mountTable = readText('/proc/mounts'); } catch { mountTable = ''; }
+  }
+  const driveMounts = discoverWslWindowsDriveMounts(mountTable);
+  const discoveredCmd = Object.entries(driveMounts)
+    .map(([, root]) => join(root, 'Windows', 'System32', 'cmd.exe'))
+    .find(fileExists);
+  const commandExecutable = options.commandCandidates?.find(fileExists) ?? discoveredCmd;
+  if (!commandExecutable) return undefined;
+  const runCommand = options.runCommand ?? ((executable: string, args: readonly string[]) => {
+    const result = spawnSync(executable, [...args], { encoding: 'utf8', windowsHide: true, timeout: 5_000 });
+    return { status: result.status, stdout: result.stdout ?? '' };
+  });
+  const observed = runCommand(commandExecutable, ['/d', '/s', '/c', 'echo FORGE_USERPROFILE=%USERPROFILE%&&echo FORGE_LOCALAPPDATA=%LOCALAPPDATA%&&echo FORGE_PROGRAMFILES=%ProgramFiles%&&echo FORGE_PROGRAMFILES_X86=%ProgramFiles(x86)%&&echo FORGE_PROGRAMDATA=%ProgramData%&&echo FORGE_SYSTEMROOT=%SystemRoot%']);
+  if (observed.status !== 0) return undefined;
+  const env = parseEnvironment(observed.stdout);
+  const userProfileWindows = env.USERPROFILE;
+  if (!userProfileWindows) return undefined;
+  const userProfile = windowsPathToHostPath(userProfileWindows, driveMounts);
+  if (!userProfile) return undefined;
+  const localAppDataWindows = env.LOCALAPPDATA;
+  const localAppData = localAppDataWindows ? windowsPathToHostPath(localAppDataWindows, driveMounts) : undefined;
+  const programFilesWindows = [env.PROGRAMFILES, env.PROGRAMFILES_X86].filter((value): value is string => Boolean(value));
+  const programFiles = programFilesWindows.map((value) => windowsPathToHostPath(value, driveMounts)).filter((value): value is string => Boolean(value));
+  const programDataWindows = env.PROGRAMDATA;
+  const programData = programDataWindows ? windowsPathToHostPath(programDataWindows, driveMounts) : undefined;
+  const systemRootWindows = env.SYSTEMROOT;
+  const systemRoot = systemRootWindows ? windowsPathToHostPath(systemRootWindows, driveMounts) : undefined;
+  return {
+    commandExecutable, userProfileWindows, userProfile,
+    ...(localAppDataWindows ? { localAppDataWindows } : {}), ...(localAppData ? { localAppData } : {}),
+    programFilesWindows, programFiles,
+    ...(programDataWindows ? { programDataWindows } : {}), ...(programData ? { programData } : {}),
+    ...(systemRootWindows ? { systemRootWindows } : {}), ...(systemRoot ? { systemRoot } : {}),
+    driveMounts,
+  };
+}

package/src/runtime/platform/windows-recovery-deployment.ts

@@ -0,0 +1,67 @@
+import { join, resolve } from 'path';
+import {
+  hostPathToWindowsPath,
+  windowsPathToHostPath,
+  type WindowsHostEnvironment,
+} from './windows-host-discovery';
+
+export interface WindowsRecoveryDeploymentBinding {
+  schemaVersion: 1;
+  rescueRoot: string;
+  recoveryScriptHostPath: string;
+  recoveryScriptWindowsPath: string;
+  powershellHostPath: string;
+  powershellWindowsPath: string;
+  source: 'discovered' | 'override';
+}
+
+function pair(input: {
+  hostPath?: string;
+  windowsPath?: string;
+  defaultHostPath?: string;
+  defaultWindowsPath?: string;
+  host?: WindowsHostEnvironment;
+  code: string;
+}): { hostPath: string; windowsPath: string; overridden: boolean } {
+  const hostPath = input.hostPath?.trim() || input.defaultHostPath;
+  const windowsPath = input.windowsPath?.trim() || input.defaultWindowsPath;
+  const resolvedHost = hostPath || (windowsPath && input.host ? windowsPathToHostPath(windowsPath, input.host.driveMounts) : undefined);
+  const resolvedWindows = windowsPath || (hostPath && input.host ? hostPathToWindowsPath(hostPath, input.host.driveMounts) : undefined);
+  if (!resolvedHost || !resolvedWindows) throw new Error(`${input.code}: explicit host/windows path pair or discoverable Windows host binding is required`);
+  return { hostPath: resolve(resolvedHost), windowsPath: resolvedWindows, overridden: Boolean(input.hostPath || input.windowsPath) };
+}
+
+export function resolveWindowsRecoveryDeployment(input: {
+  rescueRoot: string;
+  host?: WindowsHostEnvironment;
+  recoveryScriptHostPath?: string;
+  recoveryScriptWindowsPath?: string;
+  powershellHostPath?: string;
+  powershellWindowsPath?: string;
+}): WindowsRecoveryDeploymentBinding {
+  const recovery = pair({
+    hostPath: input.recoveryScriptHostPath,
+    windowsPath: input.recoveryScriptWindowsPath,
+    defaultHostPath: input.host?.programData ? join(input.host.programData, 'ForgeRecovery', 'ForgeRecovery.ps1') : undefined,
+    defaultWindowsPath: input.host?.programDataWindows ? `${input.host.programDataWindows}\\ForgeRecovery\\ForgeRecovery.ps1` : undefined,
+    host: input.host,
+    code: 'WINDOWS_RECOVERY_SCRIPT_DEPLOYMENT_UNRESOLVED',
+  });
+  const powershell = pair({
+    hostPath: input.powershellHostPath,
+    windowsPath: input.powershellWindowsPath,
+    defaultHostPath: input.host?.systemRoot ? join(input.host.systemRoot, 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe') : undefined,
+    defaultWindowsPath: input.host?.systemRootWindows ? `${input.host.systemRootWindows}\\System32\\WindowsPowerShell\\v1.0\\powershell.exe` : undefined,
+    host: input.host,
+    code: 'WINDOWS_RECOVERY_POWERSHELL_DEPLOYMENT_UNRESOLVED',
+  });
+  return {
+    schemaVersion: 1,
+    rescueRoot: resolve(input.rescueRoot),
+    recoveryScriptHostPath: recovery.hostPath,
+    recoveryScriptWindowsPath: recovery.windowsPath,
+    powershellHostPath: powershell.hostPath,
+    powershellWindowsPath: powershell.windowsPath,
+    source: recovery.overridden || powershell.overridden ? 'override' : 'discovered',
+  };
+}

package/src/runtime/plugins/action-application.ts

@@ -0,0 +1,192 @@
+import { MAX_PLUGIN_ACTION_TIMEOUT_MS } from '../../../packages/plugin-runtime/external/index';
+import type { RepositoryRecord } from '../../cli/repositories/types';
+import type { ProcessHandle } from '../execution/process-runtime/types';
+import {
+  startManagedControllerPluginAction,
+  startManagedPluginAction,
+  waitManagedControllerPluginAction,
+  waitManagedPluginAction,
+} from './lightweight-action';
+import {
+  executeAssistantPluginDirectNonPersistent,
+  executeAssistantPluginReadDirect,
+  executeControllerPluginDirectNonPersistent,
+  executeControllerPluginReadDirect,
+  getAssistantPluginManifest,
+  getControllerPluginManifest,
+  isDirectNonPersistentPluginAction,
+  isDirectPluginReadAction,
+  submitAssistantPluginAction,
+  submitControllerPluginAction,
+} from './store';
+import type {
+  AssistantPluginActionDescriptor,
+  AssistantPluginActionRequest,
+  AssistantPluginManifest,
+} from './types';
+
+export const PLUGIN_ACTION_SIDECAR_SETTLEMENT_GRACE_MS = 30_000;
+
+export function pluginActionSidecarTimeoutMs(providerTimeoutMs: number): number {
+  return providerTimeoutMs + PLUGIN_ACTION_SIDECAR_SETTLEMENT_GRACE_MS;
+}
+
+export type AssistantPluginActionApplicationResult =
+  | {
+      kind: 'direct_read';
+      manifest: AssistantPluginManifest;
+      action: AssistantPluginActionDescriptor;
+      result: Record<string, unknown>;
+      receipt: Awaited<ReturnType<typeof executeAssistantPluginReadDirect>>['receipt'];
+    }
+  | {
+      kind: 'direct_non_persistent';
+      manifest: AssistantPluginManifest;
+      action: AssistantPluginActionDescriptor;
+      result: Record<string, unknown>;
+    }
+  | {
+      kind: 'managed_running';
+      manifest: AssistantPluginManifest;
+      action?: AssistantPluginActionDescriptor;
+      requestId: string;
+      process: ProcessHandle;
+    }
+  | {
+      kind: 'managed_failed';
+      manifest: AssistantPluginManifest;
+      action?: AssistantPluginActionDescriptor;
+      requestId: string;
+      process: ProcessHandle;
+    }
+  | {
+      kind: 'submitted';
+      submitted: Awaited<ReturnType<typeof submitAssistantPluginAction>>;
+    };
+
+/**
+ * Canonical plugin execution-path coordinator.
+ *
+ * MCP/CLI adapters translate transport inputs and render results. They do not
+ * decide whether an action executes inline, through the lightweight Process
+ * Runtime, or through the deterministic receipt path.
+ */
+export async function executeAssistantPluginActionApplication(input: {
+  controllerHome: string;
+  scope: { kind: 'controller' } | { kind: 'repository'; repository: RepositoryRecord };
+  request: AssistantPluginActionRequest;
+  interactiveWaitMs?: number;
+  wait?: boolean;
+  waitMs?: number;
+}): Promise<AssistantPluginActionApplicationResult> {
+  const manifest = input.scope.kind === 'controller'
+    ? getControllerPluginManifest(input.controllerHome, input.request.pluginId)
+    : getAssistantPluginManifest(input.controllerHome, input.scope.repository, input.request.pluginId);
+  const action = manifest.actions.find((entry) => entry.actionId === input.request.actionId);
+
+  if (action && isDirectPluginReadAction(action)) {
+    const direct = input.scope.kind === 'controller'
+      ? await executeControllerPluginReadDirect(input.controllerHome, input.request)
+      : await executeAssistantPluginReadDirect(input.controllerHome, input.scope.repository, input.request);
+    return {
+      kind: 'direct_read',
+      manifest: direct.manifest,
+      action: direct.action,
+      result: direct.result,
+      receipt: direct.receipt,
+    };
+  }
+
+  if (action?.executionMode === 'direct_non_persistent') {
+    if (!isDirectNonPersistentPluginAction(action)) {
+      throw new Error(`PLUGIN_DIRECT_NON_PERSISTENT_CONTRACT_INVALID: ${input.request.pluginId}/${input.request.actionId}`);
+    }
+    const direct = input.scope.kind === 'controller'
+      ? await executeControllerPluginDirectNonPersistent(input.controllerHome, input.request)
+      : await executeAssistantPluginDirectNonPersistent(input.controllerHome, input.scope.repository, input.request);
+    return {
+      kind: 'direct_non_persistent',
+      manifest: direct.manifest,
+      action: direct.action,
+      result: direct.result,
+    };
+  }
+
+  if (action?.executionMode === 'runtime') {
+    // Stateful providers may own in-memory resources whose identity is valid only
+    // inside the canonical Runtime process. Keep the normal durable request/effect
+    // receipt path, but do not relocate execution into a short-lived sidecar.
+    return {
+      kind: 'submitted',
+      submitted: input.scope.kind === 'controller'
+        ? await submitControllerPluginAction(input.controllerHome, input.request)
+        : await submitAssistantPluginAction(input.controllerHome, input.scope.repository, input.request),
+    };
+  }
+
+  if (action) {
+    const requestedTimeoutMs = Number.isFinite(input.request.timeoutMs)
+      ? input.request.timeoutMs!
+      : action.defaultTimeoutMs;
+    const timeoutMs = Math.min(Math.max(1_000, Math.trunc(requestedTimeoutMs)), MAX_PLUGIN_ACTION_TIMEOUT_MS);
+    const sidecarTimeoutMs = pluginActionSidecarTimeoutMs(timeoutMs);
+    let { handle } = input.scope.kind === 'controller'
+      ? await startManagedControllerPluginAction({
+          controllerHome: input.controllerHome,
+          request: input.request,
+          interactiveWaitMs: input.interactiveWaitMs,
+          timeoutMs: sidecarTimeoutMs,
+        })
+      : await startManagedPluginAction({
+          controllerHome: input.controllerHome,
+          repository: input.scope.repository,
+          request: input.request,
+          interactiveWaitMs: input.interactiveWaitMs,
+          timeoutMs: sidecarTimeoutMs,
+        });
+    if (!handle.completed && input.wait === true) {
+      handle = input.scope.kind === 'controller'
+        ? await waitManagedControllerPluginAction(
+            input.controllerHome,
+            handle.processId,
+            Math.max(1, input.waitMs ?? 15_000),
+            input.request.signal,
+          )
+        : await waitManagedPluginAction(
+            input.controllerHome,
+            input.scope.repository.repoId,
+            handle.processId,
+            Math.max(1, input.waitMs ?? 15_000),
+            input.request.signal,
+          );
+    }
+    if (!handle.completed) {
+      return {
+        kind: 'managed_running',
+        manifest,
+        action,
+        requestId: input.request.requestId,
+        process: handle,
+      };
+    }
+    if (!handle.ok) {
+      return {
+        kind: 'managed_failed',
+        manifest,
+        action,
+        requestId: input.request.requestId,
+        process: handle,
+      };
+    }
+    // The durable sidecar writes the authoritative receipt. Re-enter the
+    // deterministic store with the same request id to bind/read it without
+    // replaying the provider effect.
+  }
+
+  return {
+    kind: 'submitted',
+    submitted: input.scope.kind === 'controller'
+      ? await submitControllerPluginAction(input.controllerHome, input.request)
+      : await submitAssistantPluginAction(input.controllerHome, input.scope.repository, input.request),
+  };
+}