@the-open-engine/zeroshot 6.30.1 → 6.31.0

package/src/agent-cli-provider/types.ts

@@ -12,7 +12,7 @@ import type {
   StructuredOutputProviderRegistryEntry,
   UnstructuredOutputProviderRegistryEntry,
 } from './provider-registry';
-import type { OmpSessionLaunch } from './omp-rpc-session';
+import type { OmpSessionLaunch } from './omp/rpc-session';
 
 export type ProviderId = (typeof providerIds)[number];
 export type ProviderAlias = (typeof providerAliases)[number];
@@ -290,7 +290,12 @@ export interface CleanupMetadata {
   readonly kind: 'temp-file' | 'temp-directory';
   readonly provider: ProviderId;
   readonly path: string;
-  readonly reason: 'output-schema' | 'settings-overlay' | 'admin-policy' | 'isolated-config';
+  readonly reason:
+    | 'output-schema'
+    | 'settings-overlay'
+    | 'admin-policy'
+    | 'isolated-config'
+    | 'sdk-private-root';
 }
 
 export interface WarningMetadata {
@@ -310,6 +315,118 @@ export interface WebSearchAttestation {
   readonly effective: boolean;
 }
 
+export type InvocationLane = 'spawn' | 'acp-stdio' | 'rpc-stdio';
+
+export interface InvocationLaneMetadata {
+  readonly lane: InvocationLane;
+  readonly pty: boolean;
+  readonly protocol?: 'omp-sdk-v1' | 'omp-rpc-v2' | 'acp';
+}
+
+export type PreparedInvocationParser = 'provider' | 'acp' | 'omp-sdk-ndjson';
+
+export interface PreparedProviderInvoke {
+  readonly lane: InvocationLane;
+  readonly parser: PreparedInvocationParser;
+  readonly ptyEligible: boolean;
+  readonly strictTerminal: boolean;
+}
+
+export interface PreparedEnvironmentPolicy {
+  readonly inherit: 'minimal';
+  readonly values: Readonly<Record<string, string>>;
+}
+
+export interface PreparedPrivateArtifacts {
+  readonly root: string;
+  readonly requestPath: string;
+  readonly owned: true;
+}
+
+export interface OmpSdkExecutionIdentity {
+  readonly backend: 'omp-sdk';
+  readonly backendVersion: '17.2.1';
+  readonly runtime: {
+    readonly name: 'bun';
+    readonly version: '1.3.14';
+  };
+  readonly transport: 'sdk';
+}
+
+export interface OmpSdkSemanticIdentity {
+  readonly requestedModelSelector: string;
+  readonly reasoningEffort: ReasoningEffort;
+  readonly provider: string;
+}
+
+export interface OmpSdkContainmentRequirement {
+  readonly mode: 'host-process-tree' | 'container';
+  readonly required: true;
+}
+
+export interface OmpSdkCleanupAttestation {
+  readonly mode: OmpSdkContainmentRequirement['mode'];
+  readonly terminalBuffered: true;
+  readonly descendantsReaped: true;
+  readonly clean: true;
+}
+
+export interface OmpSdkRequestedIdentity {
+  readonly modelSelector: string;
+  readonly reasoningEffort: ReasoningEffort;
+  readonly outputMode: 'json' | 'text';
+}
+
+export interface OmpSdkResolvedIdentity {
+  readonly modelSelector: string;
+}
+
+export interface OmpSdkStrictOutputEvidence {
+  readonly source: 'caller';
+  readonly mode: 'strict';
+  readonly status: 'valid';
+  readonly yieldCount: 1;
+}
+
+export interface OmpSdkUsageEvidence {
+  readonly source: 'omp-aggregate';
+  readonly completeness: 'unknown';
+  readonly inputTokens: number;
+  readonly outputTokens: number;
+  readonly cacheReadInputTokens: number;
+  readonly cacheCreationInputTokens: number;
+  readonly totalTokens: number;
+  readonly requests: number;
+  readonly durationMs: number;
+  readonly cost: {
+    readonly input: number;
+    readonly output: number;
+    readonly cacheRead: number;
+    readonly cacheWrite: number;
+    readonly total: number;
+  };
+}
+
+export interface OmpSdkTerminalEvidence {
+  readonly backend: {
+    readonly id: 'omp-sdk';
+    readonly version: '17.2.1';
+  };
+  readonly runtime: {
+    readonly name: 'bun';
+    readonly version: '1.3.14';
+  };
+  readonly requested: OmpSdkRequestedIdentity;
+  readonly resolved: OmpSdkResolvedIdentity;
+  readonly strictOutput: OmpSdkStrictOutputEvidence;
+  readonly fallback: false;
+  readonly execution: {
+    readonly exitCode: 0;
+    readonly aborted: false;
+  };
+  readonly usage: OmpSdkUsageEvidence;
+}
+
 export interface CommandSpec {
   readonly binary: string;
   readonly args: readonly string[];
@@ -319,6 +436,7 @@ export interface CommandSpec {
   readonly cleanupMetadata: readonly CleanupMetadata[];
   readonly warnings: readonly WarningMetadata[];
   readonly redactions: readonly RedactionMetadata[];
+  readonly invocation?: InvocationLaneMetadata;
 }
 
 export interface BuildProviderCommandOptions {
@@ -331,7 +449,7 @@ export interface BuildProviderCommandOptions {
   readonly resumeSessionId?: string;
   readonly continueSession?: boolean;
   // OMP-only: a verified session launch (none/fresh/resume) built from a checked partition —
-  // never a raw session id string. See src/agent-cli-provider/omp-rpc-session.ts.
+  // never a raw session id string. See src/agent-cli-provider/omp/rpc-session.ts.
   readonly ompSession?: OmpSessionLaunch;
   readonly webSearch?: boolean;
   readonly claudeSettingsFile?: string;
@@ -339,6 +457,11 @@ export interface BuildProviderCommandOptions {
   readonly authEnv?: Readonly<Record<string, string>>;
   readonly strictSchema?: boolean;
   readonly gateway?: GatewayBuildOptions;
+  /**
+   * Required for fresh OMP SDK runs so preparation can select the containment and
+   * authentication policy before any private request is materialized.
+   */
+  readonly executionContext?: 'host' | 'detached' | 'docker' | 'benchmark';
   // MCP server configs forwarded to providers that accept an MCP config CLI flag. Claude accepts
   // one variadic `--mcp-config` followed by file paths; adapters such as Copilot accept repeated
   // flags with inline JSON so configs survive container path translation.
@@ -383,6 +506,11 @@ export interface ResultEvent {
   readonly cacheReadInputTokens?: number;
   readonly cacheCreationInputTokens?: number;
   readonly modelUsage?: unknown;
+  readonly requests?: number;
+  readonly usageSource?: 'omp-aggregate';
+  readonly usageCompleteness?: 'unknown';
+  readonly invocation?: InvocationLaneMetadata;
+  readonly ompSdk?: OmpSdkTerminalEvidence;
 }
 
 export type OutputEvent = TextEvent | ThinkingEvent | ToolCallEvent | ToolResultEvent | ResultEvent;

package/src/command-cleanup-ownership.js

@@ -17,6 +17,7 @@ const POLICY_DIRECTORY_PATTERN = /^zeroshot-gemini-policy-[A-Za-z0-9_-]+$/u;
 const POLICY_FILE_PATTERN =
   /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.toml$/u;
 const OPENCODE_CONFIG_DIRECTORY_PATTERN = /^zeroshot-opencode-config-[A-Za-z0-9_-]+$/u;
+const OMP_SDK_PRIVATE_DIRECTORY_PATTERN = /^zeroshot-omp-sdk-[A-Za-z0-9_-]+$/u;
 
 function assertClosedCleanupMetadata(cleanupPath, metadata) {
   if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
@@ -121,6 +122,16 @@ function assertOwnedOmpConfigDirectory(cleanupPath) {
   }
   return false;
 }
+function assertOwnedOmpSdkDirectory(cleanupPath) {
+  if (assertOwnedNamedTempDirectory(cleanupPath, OMP_SDK_PRIVATE_DIRECTORY_PATTERN)) return true;
+  const stat = lstatSync(cleanupPath);
+  const ownedByProcess = typeof process.getuid !== 'function' || stat.uid === process.getuid();
+  const privateMode = process.platform === 'win32' || (stat.mode & 0o777) === 0o700;
+  if (!ownedByProcess || !privateMode) {
+    throw new Error(`Refusing unowned temporary directory cleanup: ${cleanupPath}`);
+  }
+  return false;
+}
 
 function assertOwnedTempDirectory(cleanupPath, metadata) {
   const isOpenCodeConfig =
@@ -133,6 +144,10 @@ function assertOwnedTempDirectory(cleanupPath, metadata) {
   if (isOmpConfig) {
     return assertOwnedOmpConfigDirectory(cleanupPath);
   }
+  const isOmpSdkPrivateRoot = metadata.provider === 'omp' && metadata.reason === 'sdk-private-root';
+  if (isOmpSdkPrivateRoot) {
+    return assertOwnedOmpSdkDirectory(cleanupPath);
+  }
 
   if (
     metadata.provider !== 'claude' ||

package/task-lib/omp-sdk-runtime.js

@@ -0,0 +1,8 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+
+export const { resolveOmpTransport } = require('../lib/agent-cli-provider/single-agent-runtime.js');
+export const {
+  spawnOmpSdkProcess,
+} = require('../lib/agent-cli-provider/omp/sdk-process-runner.js');

package/task-lib/runner.js

@@ -24,6 +24,8 @@ const {
   prepareSingleAgentProviderCommand,
 } = require('./provider-helper-runtime.js');
 const { getDefaultProviderId } = require('../lib/provider-names.js');
+const { loadSettings } = require('../lib/settings.js');
+const { resolveOmpTransport } = require('./omp-sdk-runtime.js');
 const {
   ISOLATED_SETTINGS_FILE_ENV,
   ISOLATED_SETTINGS_FILE_MARKER,
@@ -155,10 +157,11 @@ export function resolveOmpResumeExpectation({ descriptor, storageRoot, canonical
  * the structural/identity/fingerprint verification plus the owner transfer happen in the rpc-stdio
  * watcher, not here.
  */
-function resolveOmpSessionPlan({ id, cwd, options }) {
+function resolveOmpSessionPlan({ id, cwd, options, providerName }) {
   if (options.structuredOutputRecovery) return null;
-  const providerName = normalizeProviderName(options.provider || getDefaultProviderId());
-  if (providerName !== 'omp') return null;
+  const resolvedProviderName =
+    providerName || normalizeProviderName(options.provider || getDefaultProviderId());
+  if (resolvedProviderName !== 'omp') return null;
   // Docker stays fresh-only (issue #866). Returning null here means no partition is allocated, no
   // ownership row is written, and the adapter falls back to `--no-session`.
   if (isOmpSessionlessRun(options)) return null;
@@ -237,6 +240,47 @@ function failSpawnAtProvisionalBoundary(id, error) {
     console.warn(`Warning: failed to mark task ${id} failed: ${updateError.message}`);
   }
 }
+function prepareTaskSpawn(prompt, options, runtime) {
+  const outputFormat = resolveOutputFormat(options);
+  const jsonSchema = resolveJsonSchema(options, outputFormat);
+  const settings = loadSettings();
+  const providerName = normalizeProviderName(
+    options.provider || settings.defaultProvider || getDefaultProviderId()
+  );
+  const ompTransport = providerName === 'omp' ? resolveOmpTransport(settings) : null;
+  const providerOutputFormat =
+    ompTransport === 'sdk' && outputFormat === 'stream-json' && jsonSchema === null
+      ? 'text'
+      : outputFormat;
+  if (ompTransport === 'sdk' && options.ompResume) {
+    throw new Error(
+      'OMP SDK detached runs are always fresh; --omp-resume requires transport "rpc".'
+    );
+  }
+  const ompPlan =
+    ompTransport === 'rpc' ? resolveOmpSessionPlan({ ...runtime, options, providerName }) : null;
+  const prepared = prepareTaskProviderCommandFromResolved(
+    prompt,
+    options,
+    {
+      outputFormat: providerOutputFormat,
+      jsonSchema,
+      cwd: runtime.cwd,
+      ompSession: ompPlan?.session,
+    },
+    settings
+  );
+  const resolvedProviderName = prepared.adapter.id;
+  return {
+    outputFormat,
+    jsonSchema,
+    ompPlan,
+    prepared,
+    providerName: resolvedProviderName,
+    modelSpec: prepared.options.modelSpec,
+    commandSpec: attachClaudeOverlayCleanup(prepared.commandSpec, resolvedProviderName),
+  };
+}
 
 export function spawnTask(prompt, options = {}) {
   ensureDirs();
@@ -245,18 +289,8 @@ export function spawnTask(prompt, options = {}) {
   const logFile = join(LOGS_DIR, `${id}.log`);
   const cwd = options.cwd || process.cwd();
 
-  const outputFormat = resolveOutputFormat(options);
-  const jsonSchema = resolveJsonSchema(options, outputFormat);
-  const ompPlan = resolveOmpSessionPlan({ id, cwd, options });
-  const prepared = prepareTaskProviderCommandFromResolved(prompt, options, {
-    outputFormat,
-    jsonSchema,
-    cwd,
-    ompSession: ompPlan?.session,
-  });
-  const providerName = prepared.adapter.id;
-  const modelSpec = prepared.options.modelSpec;
-  const commandSpec = attachClaudeOverlayCleanup(prepared.commandSpec, providerName);
+  const { outputFormat, jsonSchema, ompPlan, prepared, providerName, modelSpec, commandSpec } =
+    prepareTaskSpawn(prompt, options, { id, cwd });
 
   const task = buildTaskRecord({
     id,
@@ -293,6 +327,7 @@ export function spawnTask(prompt, options = {}) {
     jsonSchema,
     options,
     providerName,
+    prepared,
     commandSpec,
     ompPlan
   );
@@ -301,7 +336,8 @@ export function spawnTask(prompt, options = {}) {
       attachable: options.attachable,
       jsonSchema,
     },
-    providerName
+    providerName,
+    prepared.invoke
   );
   spawnWatcher({
     watcherScript,
@@ -310,10 +346,9 @@ export function spawnTask(prompt, options = {}) {
     logFile,
     finalArgs: commandSpec.args,
     watcherConfig,
-    // Prompt bytes never enter argv: the rpc-stdio watcher receives them over a private pipe
-    // (src/watcher-prompt-channel.js). Every other lane passes the prompt to the provider through
-    // commandSpec.args, which the provider process — not a long-lived watcher — then owns.
-    ...(isRpcStdioLane(providerName)
+    // Prompt bytes never enter argv: the rpc-stdio watcher receives them over a private pipe,
+    // while the SDK watcher receives only the path to its owner-only request file.
+    ...(isRpcStdioInvoke(prepared.invoke)
       ? { rpcPrompt: buildOmpPrompt(prompt, prepared.options || {}) }
       : {}),
   });
@@ -323,20 +358,40 @@ export function spawnTask(prompt, options = {}) {
 
 export function prepareTaskProviderCommand(prompt, options = {}) {
   const outputFormat = resolveOutputFormat(options);
-  return prepareTaskProviderCommandFromResolved(prompt, options, {
-    outputFormat,
-    jsonSchema: resolveJsonSchema(options, outputFormat),
-    cwd: options.cwd || process.cwd(),
-  });
+  const jsonSchema = resolveJsonSchema(options, outputFormat);
+  const settings = loadSettings();
+  const providerName = normalizeProviderName(
+    options.provider || settings.defaultProvider || getDefaultProviderId()
+  );
+  const providerOutputFormat =
+    providerName === 'omp' &&
+    resolveOmpTransport(settings) === 'sdk' &&
+    outputFormat === 'stream-json' &&
+    jsonSchema === null
+      ? 'text'
+      : outputFormat;
+  return prepareTaskProviderCommandFromResolved(
+    prompt,
+    options,
+    {
+      outputFormat: providerOutputFormat,
+      jsonSchema,
+      cwd: options.cwd || process.cwd(),
+    },
+    settings
+  );
 }
 
-function prepareTaskProviderCommandFromResolved(prompt, options, runtime) {
+function prepareTaskProviderCommandFromResolved(prompt, options, runtime, settings) {
   const modelSelection = resolveRequestedModelSelection(options);
-  return prepareSingleAgentProviderCommand({
-    provider: options.provider || null,
-    context: prompt,
-    options: buildProviderOptions(options, runtime, modelSelection),
-  });
+  return prepareSingleAgentProviderCommand(
+    {
+      provider: options.provider || null,
+      context: prompt,
+      options: buildProviderOptions(options, runtime, modelSelection),
+    },
+    settings
+  );
 }
 
 function resolveOutputFormat(options) {
@@ -358,6 +413,7 @@ function buildProviderOptions(options, runtime, modelSelection) {
     outputFormat: runtime.outputFormat,
     jsonSchema: runtime.jsonSchema,
     cwd: runtime.cwd,
+    executionContext: 'detached',
     autoApprove: !structuredOutputRecovery,
     ...(modelSelection === undefined ? {} : { modelSpec: modelSelection.modelSpec }),
     ...(structuredOutputRecovery ? {} : mcpConfigOption(options)),
@@ -490,14 +546,27 @@ export function buildTaskRecord({
   };
 }
 
-function isRpcStdioLane(providerName) {
-  return getProviderRegistryEntry(providerName).invoke.lane === 'rpc-stdio';
+function isRpcStdioInvoke(invoke) {
+  return invoke.lane === 'rpc-stdio';
+}
+
+function isOmpSdkInvoke(invoke) {
+  return invoke.parser === 'omp-sdk-ndjson';
 }
 
 // The returned object is JSON-serialized into the detached watcher's argv, so it must never carry
 // prompt or other task content: `ps` and /proc/<pid>/cmdline expose argv to every local user for
 // the whole lifetime of the watcher. Partition paths, ids, and digests are not secret.
-function buildWatcherConfig(outputFormat, jsonSchema, options, providerName, commandSpec, ompPlan) {
+function buildWatcherConfig(
+  outputFormat,
+  jsonSchema,
+  options,
+  providerName,
+  prepared,
+  commandSpec,
+  ompPlan
+) {
+  const protocolInvoke = isRpcStdioInvoke(prepared.invoke) || isOmpSdkInvoke(prepared.invoke);
   return {
     outputFormat,
     jsonSchema,
@@ -506,7 +575,20 @@ function buildWatcherConfig(outputFormat, jsonSchema, options, providerName, com
     provider: providerName,
     command: commandSpec.binary,
     env: commandSpec.env || {},
-    commandSpec: buildWatcherCommandSpec(commandSpec, isRpcStdioLane(providerName)),
+    commandSpec: buildWatcherCommandSpec(commandSpec, protocolInvoke),
+    ...(isOmpSdkInvoke(prepared.invoke)
+      ? {
+          sdkPrepared: {
+            invoke: prepared.invoke,
+            environmentPolicy: prepared.environmentPolicy,
+            credentialNames: prepared.credentialNames,
+            privateArtifacts: prepared.privateArtifacts,
+            executionIdentity: prepared.executionIdentity,
+            semanticIdentity: prepared.semanticIdentity,
+            containmentRequirement: prepared.containmentRequirement,
+          },
+        }
+      : {}),
     ...(ompPlan
       ? {
           ompSession: ompPlan.session,
@@ -532,7 +614,7 @@ export function shouldUseAttachableWatcher(options, providerName) {
 
   // The rpc-stdio lane owns bidirectional correlated RPC over stdio itself (see
   // omp-rpc-driver.ts) and always uses rpc-watcher.js instead of the attachable PTY watcher.
-  if (isRpcStdioLane(providerName)) {
+  if (getProviderRegistryEntry(providerName).invoke.lane === 'rpc-stdio') {
     return false;
   }
 
@@ -543,10 +625,9 @@ export function shouldUseAttachableWatcher(options, providerName) {
   return !(providerName === 'claude' && options.jsonSchema);
 }
 
-function resolveWatcherScript(options, providerName) {
-  if (isRpcStdioLane(providerName)) {
-    return join(__dirname, 'rpc-watcher.js');
-  }
+function resolveWatcherScript(options, providerName, invoke) {
+  if (isOmpSdkInvoke(invoke)) return join(__dirname, 'sdk-watcher.js');
+  if (isRpcStdioInvoke(invoke)) return join(__dirname, 'rpc-watcher.js');
   const useAttachable = shouldUseAttachableWatcher(options, providerName);
   return useAttachable ? join(__dirname, 'attachable-watcher.js') : join(__dirname, 'watcher.js');
 }

package/task-lib/sdk-watcher.js

@@ -0,0 +1,154 @@
+#!/usr/bin/env node
+
+/**
+ * Detached watcher for the pinned OMP SDK lane. The parent passes only runtime metadata and the
+ * path to the owner-only request; prompt bytes remain in that private file and never enter argv.
+ */
+import { appendFileSync } from 'fs';
+import { getTask, updateTask } from './store.js';
+import { createCommandSpecCleanup } from './command-spec-cleanup.js';
+import {
+  completePendingWatcherCancellation,
+  completeWatcherFailure,
+  completeWatcherTask,
+} from './watcher-output-runtime.js';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const { spawnOmpSdkProcess } = require('./omp-sdk-runtime.js');
+
+const [, , taskId, , logFile, , configJson] = process.argv;
+const config = configJson ? JSON.parse(configJson) : {};
+const commandSpec = config.commandSpec || {};
+
+function log(message) {
+  appendFileSync(logFile, message);
+}
+
+function emergencyLog(message) {
+  try {
+    log(message);
+  } catch {
+    process.stderr.write(message);
+  }
+}
+
+const commandCleanup = createCommandSpecCleanup(commandSpec, (cleanupPath, error) => {
+  emergencyLog(`[${Date.now()}][CLEANUP] Failed to delete ${cleanupPath}: ${error.message}\n`);
+});
+
+let crashStarted = false;
+let running = null;
+let terminalResult = null;
+
+function preparedInvocation() {
+  if (!config.sdkPrepared || typeof config.sdkPrepared !== 'object') {
+    throw new Error('OMP SDK watcher is missing its prepared invocation metadata.');
+  }
+  return { ...config.sdkPrepared, commandSpec };
+}
+
+function resultError(result) {
+  if (result.terminal.type === 'error') {
+    const { code, category } = result.terminal.frame.error;
+    return `OMP SDK ${code} (${category})`;
+  }
+  if (result.terminal.event.success === false) {
+    return result.terminal.event.error || 'OMP SDK turn failed';
+  }
+  if (result.cleanupAttestation.clean !== true) return 'OMP SDK cleanup was not attested';
+  return result.exitCode === 0 ? null : `OMP SDK supervisor exited with code ${result.exitCode}`;
+}
+
+function completionFor(result) {
+  const error = resultError(result);
+  const cancelled =
+    result.terminal.type === 'error' && result.terminal.frame.error.category === 'cancelled';
+  const success = error === null;
+  return {
+    status: success ? 'completed' : cancelled ? 'killed' : 'failed',
+    resolvedCode: success ? 0 : cancelled ? 143 : result.exitCode === 0 ? 1 : result.exitCode || 1,
+    error,
+  };
+}
+
+function logTerminal(result) {
+  for (const frame of result.progress) log(`[${Date.now()}]${JSON.stringify(frame)}\n`);
+  const terminal =
+    result.terminal.type === 'result' ? result.terminal.event : result.terminal.frame;
+  log(`[${Date.now()}]${JSON.stringify(terminal)}\n`);
+  if (result.diagnosticStderr) {
+    log(`[${Date.now()}][SDK-DIAGNOSTIC] ${result.diagnosticStderr}\n`);
+  }
+}
+
+async function terminateOwnedProviderBoundary() {
+  if (terminalResult) return terminalResult.cleanupAttestation.clean === true;
+  if (!running) return true;
+  running.cancel();
+  try {
+    terminalResult = await running.result;
+    return terminalResult.cleanupAttestation.clean === true;
+  } catch {
+    return false;
+  }
+}
+
+async function crashWithError(error, source) {
+  if (crashStarted) return;
+  crashStarted = true;
+  await completeWatcherFailure({
+    taskId,
+    error,
+    source,
+    commandCleanup,
+    terminateProvider: terminateOwnedProviderBoundary,
+    updateTask,
+    emergencyLog,
+  });
+  process.exit(1);
+}
+
+process.on('uncaughtException', (error) => {
+  void crashWithError(error, 'uncaughtException');
+});
+process.on('unhandledRejection', (reason) => {
+  void crashWithError(reason, 'unhandledRejection');
+});
+
+if (
+  await completePendingWatcherCancellation({
+    taskId,
+    getTask,
+    commandCleanup,
+    terminateProvider: () => true,
+    updateTask,
+    emergencyLog,
+  })
+) {
+  process.exit(0);
+}
+
+try {
+  running = await spawnOmpSdkProcess(preparedInvocation());
+  updateTask(taskId, {
+    pid: running.pid,
+    processGroupId: null,
+    terminationStrategy: 'process',
+  });
+  if (getTask(taskId)?.cancelRequested) running.cancel();
+
+  terminalResult = await running.result;
+  logTerminal(terminalResult);
+  await completeWatcherTask({
+    taskId,
+    completion: completionFor(terminalResult),
+    commandCleanup,
+    terminateProvider: terminateOwnedProviderBoundary,
+    updateTask,
+    emergencyLog,
+  });
+  process.exit(0);
+} catch (error) {
+  await crashWithError(error, 'OMP SDK watcher');
+}

package/lib/agent-cli-provider/omp-release.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"omp-release.d.ts","sourceRoot":"","sources":["../../src/agent-cli-provider/omp-release.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,qBAAqB,EAAG,QAAiB,CAAC;AACvD,eAAO,MAAM,gBAAgB,EAAG,2BAAoC,CAAC;AACrE,eAAO,MAAM,eAAe,EAAG,KAAc,CAAC;AAoB9C,eAAO,MAAM,mBAAmB,mDACwC,CAAC;AACzE,eAAO,MAAM,qBAAqB,EAAG,aAAsB,CAAC;AAC5D,eAAO,MAAM,eAAe,2IACgH,CAAC;AAE7I,eAAO,MAAM,6BAA6B,iEACkD,CAAC;AAE7F,MAAM,MAAM,kBAAkB,GAC1B,cAAc,GACd,YAAY,GACZ,aAAa,GACb,kBAAkB,GAClB,gBAAgB,GAChB,WAAW,CAAC;AAEhB,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,QAAQ,EAAE,kBAAkB,CAAC;IACtC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;CACzB;AAGD,eAAO,MAAM,kBAAkB,EAAE,SAAS,eAAe,EA+BxD,CAAC;AAEF,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS,CAEjF;AAED,wBAAgB,0BAA0B,CAAC,KAAK,EAAE,eAAe,GAAG,MAAM,CAEzE;AAKD,eAAO,MAAM,mBAAmB,EAAG,aAAsB,CAAC;AAC1D,eAAO,MAAM,2BAA2B,aAAoD,CAAC;AAe7F,eAAO,MAAM,0BAA0B,EAAE,MAKsD,CAAC"}

package/lib/agent-cli-provider/omp-release.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"omp-release.js","sourceRoot":"","sources":["../../src/agent-cli-provider/omp-release.ts"],"names":[],"mappings":";;;AA+EA,kDAEC;AAED,gEAEC;AArFY,QAAA,qBAAqB,GAAG,QAAiB,CAAC;AAC1C,QAAA,gBAAgB,GAAG,2BAAoC,CAAC;AACxD,QAAA,eAAe,GAAG,KAAc,CAAC;AAE9C,8FAA8F;AAC9F,0FAA0F;AAC1F,6FAA6F;AAC7F,gGAAgG;AAChG,8FAA8F;AAC9F,EAAE;AACF,mGAAmG;AACnG,kGAAkG;AAClG,2FAA2F;AAC3F,8DAA8D;AAC9D,uEAAuE;AACvE,6FAA6F;AAC7F,kGAAkG;AAClG,mGAAmG;AACnG,8FAA8F;AAC9F,+FAA+F;AAC/F,iGAAiG;AACjG,oBAAoB;AACP,QAAA,mBAAmB,GAC9B,kBAAkB,wBAAgB,IAAI,6BAAqB,EAAW,CAAC;AAC5D,QAAA,qBAAqB,GAAG,aAAsB,CAAC;AAC/C,QAAA,eAAe,GAC1B,yCAAyC,2BAAmB,2CAA2C,6BAAqB,KAAc,CAAC;AAEhI,QAAA,6BAA6B,GACxC,0DAA0D,6BAAqB,EAAW,CAAC;AAgB7F,uGAAuG;AAC1F,QAAA,kBAAkB,GAA+B;IAC5D;QACE,IAAI,EAAE,kBAAkB;QACxB,QAAQ,EAAE,cAAc;QACxB,MAAM,EAAE,kEAAkE;KAC3E;IACD;QACE,IAAI,EAAE,gBAAgB;QACtB,QAAQ,EAAE,YAAY;QACtB,MAAM,EAAE,kEAAkE;KAC3E;IACD;QACE,IAAI,EAAE,iBAAiB;QACvB,QAAQ,EAAE,aAAa;QACvB,MAAM,EAAE,kEAAkE;KAC3E;IACD;QACE,IAAI,EAAE,sBAAsB;QAC5B,QAAQ,EAAE,kBAAkB;QAC5B,MAAM,EAAE,kEAAkE;KAC3E;IACD;QACE,IAAI,EAAE,oBAAoB;QAC1B,QAAQ,EAAE,gBAAgB;QAC1B,MAAM,EAAE,kEAAkE;KAC3E;IACD;QACE,IAAI,EAAE,eAAe;QACrB,QAAQ,EAAE,WAAW;QACrB,MAAM,EAAE,kEAAkE;KAC3E;CACF,CAAC;AAEF,SAAgB,mBAAmB,CAAC,QAAgB;IAClD,OAAO,0BAAkB,CAAC,IAAI,CAAC,CAAC,KAAK,EAAE,EAAE,CAAC,KAAK,CAAC,QAAQ,KAAK,QAAQ,CAAC,CAAC;AACzE,CAAC;AAED,SAAgB,0BAA0B,CAAC,KAAsB;IAC/D,OAAO,GAAG,qCAA6B,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC;AAC1D,CAAC;AAED,wFAAwF;AACxF,0FAA0F;AAC1F,mEAAmE;AACtD,QAAA,mBAAmB,GAAG,aAAsB,CAAC;AAC7C,QAAA,2BAA2B,GAAG,WAAiD,CAAC;AAE7F,MAAM,wBAAwB,GAAG,mBAAmB,CAAC,mCAA2B,CAAC,CAAC;AAClF,IAAI,CAAC,wBAAwB,EAAE,CAAC;IAC9B,MAAM,IAAI,KAAK,CACb,mDAAmD,mCAA2B,GAAG,CAClF,CAAC;AACJ,CAAC;AAED,MAAM,sBAAsB,GAAG,0BAA0B,CAAC,wBAAwB,CAAC,CAAC;AACpF,MAAM,yBAAyB,GAAG,wBAAwB,CAAC,MAAM,CAAC;AAElE,iGAAiG;AACjG,2FAA2F;AAC3F,8CAA8C;AACjC,QAAA,0BAA0B,GACrC,8CAA8C,sBAAsB,KAAK;IACzE,6BAA6B,yBAAyB,sBAAsB;IAC5E,+DAA+D;IAC/D,wDAAwD;IACxD,aAAa,6BAAqB,2DAA2D,CAAC"}

package/lib/agent-cli-provider/omp-rpc-bounds.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"omp-rpc-bounds.d.ts","sourceRoot":"","sources":["../../src/agent-cli-provider/omp-rpc-bounds.ts"],"names":[],"mappings":"AAQA,eAAO,MAAM,oBAAoB,KAAK,CAAC;AAIvC,eAAO,MAAM,wBAAwB,OAAO,CAAC;AAI7C,eAAO,MAAM,2BAA2B,QAAkB,CAAC;AAI3D,eAAO,MAAM,qBAAqB,OAAO,CAAC;AAM1C,eAAO,MAAM,cAAc,OAAO,CAAC;AACnC,eAAO,MAAM,aAAa,OAAO,CAAC"}

package/lib/agent-cli-provider/omp-rpc-bounds.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"omp-rpc-bounds.js","sourceRoot":"","sources":["../../src/agent-cli-provider/omp-rpc-bounds.ts"],"names":[],"mappings":";AAAA,iGAAiG;AACjG,mFAAmF;;;AAEnF,gGAAgG;AAChG,+FAA+F;AAC/F,6FAA6F;AAC7F,8FAA8F;AAC9F,yBAAyB;AACZ,QAAA,oBAAoB,GAAG,EAAE,CAAC;AAEvC,iGAAiG;AACjG,0FAA0F;AAC7E,QAAA,wBAAwB,GAAG,IAAI,CAAC;AAE7C,iGAAiG;AACjG,kFAAkF;AACrE,QAAA,2BAA2B,GAAG,CAAC,GAAG,IAAI,GAAG,IAAI,CAAC;AAE3D,mGAAmG;AACnG,aAAa;AACA,QAAA,qBAAqB,GAAG,IAAI,CAAC;AAE1C,iGAAiG;AACjG,8FAA8F;AAC9F,gGAAgG;AAChG,4EAA4E;AAC/D,QAAA,cAAc,GAAG,IAAI,CAAC;AACtB,QAAA,aAAa,GAAG,IAAI,CAAC"}