@kbediako/codex-orchestrator 0.1.1 → 0.1.3

package/dist/orchestrator/src/cli/rlm/validator.js

@@ -0,0 +1,159 @@
+import { access, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+const NODE_PACKAGE_MANAGER_MAP = {
+    pnpm: 'pnpm test',
+    yarn: 'yarn test',
+    npm: 'npm test',
+    bun: 'bun test'
+};
+const NODE_LOCKFILES = [
+    { file: 'pnpm-lock.yaml', command: 'pnpm test' },
+    { file: 'yarn.lock', command: 'yarn test' },
+    { file: 'package-lock.json', command: 'npm test' },
+    { file: 'bun.lockb', command: 'bun test' }
+];
+async function fileExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function ecosystemReason(ecosystem, reason) {
+    return `${ecosystem}: ${reason}`;
+}
+async function detectNodeCandidates(repoRoot) {
+    const candidates = [];
+    const packageJsonPath = join(repoRoot, 'package.json');
+    if (await fileExists(packageJsonPath)) {
+        try {
+            const raw = await readFile(packageJsonPath, 'utf8');
+            const parsed = JSON.parse(raw);
+            const packageManager = parsed.packageManager?.trim();
+            if (packageManager) {
+                const tool = packageManager.split('@')[0]?.trim();
+                const command = tool ? NODE_PACKAGE_MANAGER_MAP[tool] : undefined;
+                if (command) {
+                    candidates.push({
+                        command,
+                        reason: ecosystemReason('node', `packageManager=${packageManager}`),
+                        ecosystem: 'node'
+                    });
+                }
+            }
+        }
+        catch {
+            // Ignore invalid package.json for auto-detection.
+        }
+    }
+    for (const lockfile of NODE_LOCKFILES) {
+        const lockPath = join(repoRoot, lockfile.file);
+        if (await fileExists(lockPath)) {
+            candidates.push({
+                command: lockfile.command,
+                reason: ecosystemReason('node', lockfile.file),
+                ecosystem: 'node'
+            });
+        }
+    }
+    return candidates;
+}
+async function detectPythonCandidates(repoRoot) {
+    const candidates = [];
+    const pyprojectPath = join(repoRoot, 'pyproject.toml');
+    if (await fileExists(pyprojectPath)) {
+        candidates.push({
+            command: 'python -m pytest',
+            reason: ecosystemReason('python', 'pyproject.toml'),
+            ecosystem: 'python'
+        });
+    }
+    const pytestIni = join(repoRoot, 'pytest.ini');
+    if (await fileExists(pytestIni)) {
+        candidates.push({
+            command: 'pytest',
+            reason: ecosystemReason('python', 'pytest.ini'),
+            ecosystem: 'python'
+        });
+    }
+    const requirements = join(repoRoot, 'requirements.txt');
+    if (await fileExists(requirements)) {
+        candidates.push({
+            command: 'pytest',
+            reason: ecosystemReason('python', 'requirements.txt'),
+            ecosystem: 'python'
+        });
+    }
+    return candidates;
+}
+async function detectGoCandidates(repoRoot) {
+    const goModPath = join(repoRoot, 'go.mod');
+    if (await fileExists(goModPath)) {
+        return [
+            {
+                command: 'go test ./...',
+                reason: ecosystemReason('go', 'go.mod'),
+                ecosystem: 'go'
+            }
+        ];
+    }
+    return [];
+}
+async function detectRustCandidates(repoRoot) {
+    const cargoPath = join(repoRoot, 'Cargo.toml');
+    if (await fileExists(cargoPath)) {
+        return [
+            {
+                command: 'cargo test',
+                reason: ecosystemReason('rust', 'Cargo.toml'),
+                ecosystem: 'rust'
+            }
+        ];
+    }
+    return [];
+}
+export async function detectValidatorCandidates(repoRoot) {
+    const [node, python, go, rust] = await Promise.all([
+        detectNodeCandidates(repoRoot),
+        detectPythonCandidates(repoRoot),
+        detectGoCandidates(repoRoot),
+        detectRustCandidates(repoRoot)
+    ]);
+    return [...node, ...python, ...go, ...rust];
+}
+export async function detectValidator(repoRoot) {
+    const rawCandidates = await detectValidatorCandidates(repoRoot);
+    if (rawCandidates.length === 0) {
+        return { status: 'missing', command: null, candidates: [] };
+    }
+    const grouped = new Map();
+    for (const candidate of rawCandidates) {
+        const entry = grouped.get(candidate.command);
+        if (entry) {
+            entry.reasons.push(candidate.reason);
+        }
+        else {
+            grouped.set(candidate.command, {
+                command: candidate.command,
+                reasons: [candidate.reason],
+                ecosystem: candidate.ecosystem
+            });
+        }
+    }
+    const candidates = Array.from(grouped.values()).map((entry) => ({
+        command: entry.command,
+        reason: entry.reasons.join('; '),
+        ecosystem: entry.ecosystem
+    }));
+    if (candidates.length === 1) {
+        return {
+            status: 'selected',
+            command: candidates[0]?.command ?? null,
+            reason: candidates[0]?.reason,
+            candidates
+        };
+    }
+    return { status: 'ambiguous', command: null, candidates };
+}

package/dist/orchestrator/src/cli/rlmRunner.js

@@ -0,0 +1,417 @@
+import { exec } from 'node:child_process';
+import { spawn } from 'node:child_process';
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+import process from 'node:process';
+import { promisify } from 'node:util';
+import { createInterface } from 'node:readline/promises';
+import { fileURLToPath } from 'node:url';
+import { logger } from '../logger.js';
+import { resolveCodexCommand } from './utils/devtools.js';
+import { detectValidator } from './rlm/validator.js';
+import { buildRlmPrompt } from './rlm/prompt.js';
+import { runRlmLoop } from './rlm/runner.js';
+const execAsync = promisify(exec);
+const DEFAULT_MAX_ITERATIONS = 88;
+function parseArgs(argv) {
+    const parsed = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const token = argv[i] ?? '';
+        if (!token.startsWith('--')) {
+            continue;
+        }
+        const [flag, inlineValue] = token.slice(2).split('=', 2);
+        const nextValue = inlineValue ?? argv[i + 1];
+        switch (flag) {
+            case 'goal':
+                if (!inlineValue && nextValue && !nextValue.startsWith('--')) {
+                    parsed.goal = nextValue;
+                    i += 1;
+                }
+                else if (inlineValue) {
+                    parsed.goal = inlineValue;
+                }
+                break;
+            case 'validator':
+                if (!inlineValue && nextValue && !nextValue.startsWith('--')) {
+                    parsed.validator = nextValue;
+                    i += 1;
+                }
+                else if (inlineValue) {
+                    parsed.validator = inlineValue;
+                }
+                break;
+            case 'max-iterations':
+                if (!inlineValue && nextValue && !nextValue.startsWith('--')) {
+                    parsed.maxIterations = nextValue;
+                    i += 1;
+                }
+                else if (inlineValue) {
+                    parsed.maxIterations = inlineValue;
+                }
+                break;
+            case 'max-minutes':
+                if (!inlineValue && nextValue && !nextValue.startsWith('--')) {
+                    parsed.maxMinutes = nextValue;
+                    i += 1;
+                }
+                else if (inlineValue) {
+                    parsed.maxMinutes = inlineValue;
+                }
+                break;
+            case 'roles':
+                if (!inlineValue && nextValue && !nextValue.startsWith('--')) {
+                    parsed.roles = nextValue;
+                    i += 1;
+                }
+                else if (inlineValue) {
+                    parsed.roles = inlineValue;
+                }
+                break;
+            default:
+                break;
+        }
+    }
+    return parsed;
+}
+function envFlagEnabled(value) {
+    if (!value) {
+        return false;
+    }
+    const normalized = value.trim().toLowerCase();
+    return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
+}
+function shouldForceNonInteractive(env) {
+    const stdinIsTTY = process.stdin?.isTTY === true;
+    return (!stdinIsTTY ||
+        envFlagEnabled(env.CI) ||
+        envFlagEnabled(env.CODEX_REVIEW_NON_INTERACTIVE) ||
+        envFlagEnabled(env.CODEX_NON_INTERACTIVE) ||
+        envFlagEnabled(env.CODEX_NONINTERACTIVE) ||
+        envFlagEnabled(env.CODEX_NO_INTERACTIVE));
+}
+function resolveRepoRoot(env) {
+    return env.CODEX_ORCHESTRATOR_ROOT?.trim() || process.cwd();
+}
+function resolveRunIds(env) {
+    const taskId = env.CODEX_ORCHESTRATOR_TASK_ID || env.MCP_RUNNER_TASK_ID || 'rlm-adhoc';
+    const runId = env.CODEX_ORCHESTRATOR_RUN_ID || 'rlm-adhoc';
+    return { taskId, runId };
+}
+function resolveRunsRoot(env, repoRoot) {
+    return env.CODEX_ORCHESTRATOR_RUNS_DIR?.trim() || join(repoRoot, '.runs');
+}
+function resolveRunDir(env, repoRoot) {
+    const explicit = env.CODEX_ORCHESTRATOR_RUN_DIR?.trim();
+    if (explicit) {
+        return explicit;
+    }
+    const { taskId, runId } = resolveRunIds(env);
+    const runsRoot = resolveRunsRoot(env, repoRoot);
+    return join(runsRoot, taskId, 'cli', runId);
+}
+function parsePositiveInt(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isFinite(parsed) || parsed < 0) {
+        return null;
+    }
+    return parsed;
+}
+function parseRoles(value, fallback) {
+    if (!value) {
+        return fallback;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (normalized === 'single' || normalized === 'triad') {
+        return normalized;
+    }
+    return null;
+}
+function normalizeValidator(value) {
+    if (!value) {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    return trimmed;
+}
+async function promptForValidator(candidates) {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        console.log('Validator auto-detect found multiple candidates:');
+        candidates.forEach((candidate, index) => {
+            console.log(`  ${index + 1}) ${candidate.command} (${candidate.reason})`);
+        });
+        console.log('  n) none');
+        const answer = (await rl.question('Select validator [1-n or n for none]: ')).trim().toLowerCase();
+        if (!answer || answer === 'n' || answer === 'none') {
+            return null;
+        }
+        const selectedIndex = Number.parseInt(answer, 10);
+        if (!Number.isFinite(selectedIndex) || selectedIndex < 1 || selectedIndex > candidates.length) {
+            throw new Error('Invalid selection');
+        }
+        return candidates[selectedIndex - 1]?.command ?? null;
+    }
+    finally {
+        rl.close();
+    }
+}
+async function promptForValidatorCommand() {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    try {
+        const answer = (await rl.question('Enter validator command (or "none"): ')).trim();
+        if (!answer || answer.toLowerCase() === 'none') {
+            return null;
+        }
+        return answer;
+    }
+    finally {
+        rl.close();
+    }
+}
+async function writeTerminalState(runDir, state) {
+    const rlmDir = join(runDir, 'rlm');
+    await mkdir(rlmDir, { recursive: true });
+    await writeFile(join(rlmDir, 'state.json'), JSON.stringify(state, null, 2), 'utf8');
+}
+async function runCodexAgent(input, env, repoRoot, nonInteractive, subagentsEnabled) {
+    const prompt = buildRlmPrompt(input);
+    const { command, args } = resolveCodexCommand(['exec', prompt], env);
+    const childEnv = { ...process.env, ...env };
+    if (nonInteractive) {
+        childEnv.CODEX_NON_INTERACTIVE = childEnv.CODEX_NON_INTERACTIVE ?? '1';
+        childEnv.CODEX_NO_INTERACTIVE = childEnv.CODEX_NO_INTERACTIVE ?? '1';
+        childEnv.CODEX_INTERACTIVE = childEnv.CODEX_INTERACTIVE ?? '0';
+    }
+    if (subagentsEnabled) {
+        childEnv.CODEX_SUBAGENTS = childEnv.CODEX_SUBAGENTS ?? '1';
+    }
+    const child = spawn(command, args, { cwd: repoRoot, env: childEnv, stdio: ['ignore', 'pipe', 'pipe'] });
+    let stdout = '';
+    let stderr = '';
+    child.stdout?.on('data', (chunk) => {
+        stdout += chunk.toString();
+        process.stdout.write(chunk);
+    });
+    child.stderr?.on('data', (chunk) => {
+        stderr += chunk.toString();
+        process.stderr.write(chunk);
+    });
+    await new Promise((resolvePromise, reject) => {
+        child.once('error', (error) => reject(error instanceof Error ? error : new Error(String(error))));
+        child.once('exit', (code) => {
+            if (code === 0) {
+                resolvePromise();
+            }
+            else {
+                reject(new Error(`codex exec exited with code ${code ?? 'unknown'}`));
+            }
+        });
+    });
+    const output = [stdout.trim(), stderr.trim()].filter(Boolean).join('\n');
+    return { output };
+}
+function normalizeExitCode(code) {
+    if (typeof code === 'number' && Number.isInteger(code)) {
+        return code;
+    }
+    if (typeof code === 'string') {
+        const parsed = Number.parseInt(code, 10);
+        if (Number.isInteger(parsed)) {
+            return parsed;
+        }
+    }
+    return 1;
+}
+async function runValidatorCommand(command, repoRoot) {
+    try {
+        const { stdout, stderr } = await execAsync(command, {
+            cwd: repoRoot,
+            env: { ...process.env },
+            maxBuffer: 10 * 1024 * 1024
+        });
+        return { exitCode: 0, stdout: stdout ?? '', stderr: stderr ?? '' };
+    }
+    catch (error) {
+        const execError = error;
+        const exitCode = normalizeExitCode(execError.code);
+        const spawnError = execError.code === 'ENOENT' || exitCode === 127;
+        return {
+            exitCode,
+            stdout: execError.stdout ?? '',
+            stderr: execError.stderr ?? execError.message ?? '',
+            spawnError
+        };
+    }
+}
+async function main() {
+    const env = process.env;
+    const repoRoot = resolveRepoRoot(env);
+    const runDir = resolveRunDir(env, repoRoot);
+    const parsedArgs = parseArgs(process.argv.slice(2));
+    const goal = (parsedArgs.goal ?? env.RLM_GOAL)?.trim();
+    const roles = parseRoles(parsedArgs.roles ?? env.RLM_ROLES, 'single');
+    const maxIterations = parsePositiveInt(parsedArgs.maxIterations ?? env.RLM_MAX_ITERATIONS, DEFAULT_MAX_ITERATIONS);
+    const maxMinutes = parsePositiveInt(parsedArgs.maxMinutes ?? env.RLM_MAX_MINUTES, 0);
+    if (!goal) {
+        const state = {
+            goal: '',
+            validator: null,
+            roles: roles ?? 'single',
+            maxIterations: maxIterations ?? DEFAULT_MAX_ITERATIONS,
+            maxMinutes: maxMinutes && maxMinutes > 0 ? maxMinutes : null,
+            iterations: [],
+            final: { status: 'invalid_config', exitCode: 5 }
+        };
+        await writeTerminalState(runDir, state);
+        console.error('RLM goal is required. Set RLM_GOAL or pass --goal.');
+        process.exitCode = 5;
+        return;
+    }
+    if (!roles) {
+        const state = {
+            goal,
+            validator: null,
+            roles: 'single',
+            maxIterations: maxIterations ?? DEFAULT_MAX_ITERATIONS,
+            maxMinutes: maxMinutes && maxMinutes > 0 ? maxMinutes : null,
+            iterations: [],
+            final: { status: 'invalid_config', exitCode: 5 }
+        };
+        await writeTerminalState(runDir, state);
+        console.error('Invalid RLM roles value. Use "single" or "triad".');
+        process.exitCode = 5;
+        return;
+    }
+    if (maxIterations === null) {
+        const state = {
+            goal,
+            validator: null,
+            roles,
+            maxIterations: DEFAULT_MAX_ITERATIONS,
+            maxMinutes: maxMinutes && maxMinutes > 0 ? maxMinutes : null,
+            iterations: [],
+            final: { status: 'invalid_config', exitCode: 5 }
+        };
+        await writeTerminalState(runDir, state);
+        console.error('Invalid max iterations value.');
+        process.exitCode = 5;
+        return;
+    }
+    if (maxMinutes === null) {
+        const state = {
+            goal,
+            validator: null,
+            roles,
+            maxIterations,
+            maxMinutes: null,
+            iterations: [],
+            final: { status: 'invalid_config', exitCode: 5 }
+        };
+        await writeTerminalState(runDir, state);
+        console.error('Invalid max minutes value.');
+        process.exitCode = 5;
+        return;
+    }
+    const validatorOverride = normalizeValidator(parsedArgs.validator ?? env.RLM_VALIDATOR);
+    const isInteractive = !shouldForceNonInteractive(env);
+    let validatorCommand = null;
+    if (validatorOverride && validatorOverride.toLowerCase() !== 'auto') {
+        if (validatorOverride.toLowerCase() === 'none') {
+            validatorCommand = null;
+        }
+        else {
+            validatorCommand = validatorOverride;
+        }
+    }
+    else {
+        const detection = await detectValidator(repoRoot);
+        if (detection.status === 'selected' && detection.command) {
+            validatorCommand = detection.command;
+            console.log(`Validator: ${detection.command} (${detection.reason ?? 'auto-detect'})`);
+        }
+        else if (detection.status === 'ambiguous') {
+            if (isInteractive) {
+                validatorCommand = await promptForValidator(detection.candidates);
+            }
+            else {
+                const candidates = detection.candidates
+                    .map((candidate) => `- ${candidate.command} (${candidate.reason})`)
+                    .join('\n');
+                const state = {
+                    goal,
+                    validator: null,
+                    roles,
+                    maxIterations,
+                    maxMinutes: maxMinutes && maxMinutes > 0 ? maxMinutes : null,
+                    iterations: [],
+                    final: { status: 'no_validator', exitCode: 2 }
+                };
+                await writeTerminalState(runDir, state);
+                console.error('Validator auto-detect ambiguous. Provide --validator or --validator none.');
+                console.error(candidates);
+                process.exitCode = 2;
+                return;
+            }
+        }
+        else {
+            if (isInteractive) {
+                validatorCommand = await promptForValidatorCommand();
+            }
+            else {
+                const state = {
+                    goal,
+                    validator: null,
+                    roles,
+                    maxIterations,
+                    maxMinutes: maxMinutes && maxMinutes > 0 ? maxMinutes : null,
+                    iterations: [],
+                    final: { status: 'no_validator', exitCode: 2 }
+                };
+                await writeTerminalState(runDir, state);
+                console.error('Validator auto-detect failed. Provide --validator or --validator none.');
+                process.exitCode = 2;
+                return;
+            }
+        }
+    }
+    if (validatorCommand === null) {
+        console.log('Validator: none');
+    }
+    else {
+        console.log(`Validator: ${validatorCommand}`);
+    }
+    const subagentsEnabled = envFlagEnabled(env.CODEX_SUBAGENTS) || envFlagEnabled(env.RLM_SUBAGENTS);
+    const nonInteractive = shouldForceNonInteractive(env);
+    const result = await runRlmLoop({
+        goal,
+        validatorCommand,
+        maxIterations,
+        maxMinutes: maxMinutes && maxMinutes > 0 ? maxMinutes : null,
+        roles,
+        subagentsEnabled,
+        repoRoot,
+        runDir: join(runDir, 'rlm'),
+        runAgent: (input) => runCodexAgent(input, env, repoRoot, nonInteractive, subagentsEnabled),
+        runValidator: (command) => runValidatorCommand(command, repoRoot),
+        logger: (line) => logger.info(line)
+    });
+    const finalStatus = result.state.final?.status ?? 'unknown';
+    const iterationCount = result.state.iterations.length;
+    console.log(`RLM completed: status=${finalStatus} iterations=${iterationCount} exit=${result.exitCode}`);
+    process.exitCode = result.exitCode;
+}
+const entry = process.argv[1] ? resolve(process.argv[1]) : null;
+const self = resolve(fileURLToPath(import.meta.url));
+if (entry && entry === self) {
+    main().catch((error) => {
+        logger.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 10;
+    });
+}

package/dist/orchestrator/src/cli/run/environment.js

@@ -1,15 +1,5 @@
-import { join, resolve } from 'node:path';
 import { sanitizeTaskId } from '../../persistence/sanitizeTaskId.js';
-const DEFAULT_TASK_ID = '0101';
-export function resolveEnvironment() {
-    const repoRoot = resolve(process.env.CODEX_ORCHESTRATOR_ROOT ?? process.cwd());
-    const runsRoot = resolve(process.env.CODEX_ORCHESTRATOR_RUNS_DIR ?? join(repoRoot, '.runs'));
-    const outRoot = resolve(process.env.CODEX_ORCHESTRATOR_OUT_DIR ?? join(repoRoot, 'out'));
-    const rawTaskId = process.env.MCP_RUNNER_TASK_ID ?? DEFAULT_TASK_ID;
-    const taskId = normalizeTaskId(rawTaskId);
-    return { repoRoot, runsRoot, outRoot, taskId };
-}
-function normalizeTaskId(value) {
+export function normalizeTaskId(value) {
     try {
         return sanitizeTaskId(value);
     }
@@ -21,4 +11,7 @@ function normalizeTaskId(value) {
         throw new Error(`Invalid MCP_RUNNER_TASK_ID: ${message}`);
     }
 }
+export function normalizeEnvironmentPaths(paths) {
+    return { ...paths, taskId: normalizeTaskId(paths.taskId) };
+}
 export { sanitizeTaskId };

package/dist/orchestrator/src/cli/run/manifest.js

@@ -239,7 +239,13 @@ function computeGuardrailStatus(manifest) {
     };
 }
 function selectGuardrailCommands(manifest) {
-    return manifest.commands.filter((entry) => entry.command?.includes('spec-guard'));
+    return manifest.commands.filter((entry) => {
+        const id = entry.id?.toLowerCase() ?? '';
+        const title = entry.title?.toLowerCase() ?? '';
+        const command = entry.command?.toLowerCase() ?? '';
+        const haystack = `${id} ${title} ${command}`;
+        return haystack.includes('spec-guard') || haystack.includes('specguardrunner');
+    });
 }
 function formatGuardrailSummary(counts) {
     if (counts.total === 0) {

package/dist/orchestrator/src/cli/services/commandRunner.js

@@ -129,7 +129,7 @@ export async function runCommandStage(context, hooks = {}) {
             CODEX_ORCHESTRATOR_RUN_DIR: paths.runDir,
             CODEX_ORCHESTRATOR_RUNS_DIR: env.runsRoot,
             CODEX_ORCHESTRATOR_OUT_DIR: env.outRoot,
-            CODEX_ORCHESTRATOR_REPO_ROOT: env.repoRoot,
+            CODEX_ORCHESTRATOR_ROOT: env.repoRoot,
             CODEX_ORCHESTRATOR_PACKAGE_ROOT: PACKAGE_ROOT
         };
         const execEnv = { ...baseEnv, ...stage.env };

package/dist/orchestrator/src/cli/services/controlPlaneService.js

@@ -1,5 +1,7 @@
 import process from 'node:process';
-import { buildRunRequestV2, ControlPlaneDriftReporter, ControlPlaneValidationError, ControlPlaneValidator } from '../../control-plane/index.js';
+import { ControlPlaneDriftReporter } from '../../control-plane/drift-reporter.js';
+import { buildRunRequestV2 } from '../../control-plane/request-builder.js';
+import { ControlPlaneValidationError, ControlPlaneValidator } from '../../control-plane/validator.js';
 import { relativeToRepo } from '../run/runPaths.js';
 import { appendSummary } from '../run/manifest.js';
 import { persistManifest } from '../run/manifestPersister.js';

package/dist/orchestrator/src/cli/services/execRuntime.js

@@ -1,6 +1,5 @@
 import { spawn } from 'node:child_process';
-import { ExecSessionManager, UnifiedExecRunner, ToolOrchestrator } from '../../../../packages/orchestrator/src/index.js';
-import { RemoteExecHandleService } from '../../../../packages/orchestrator/src/exec/handle-service.js';
+import { ExecSessionManager, UnifiedExecRunner, ToolOrchestrator, RemoteExecHandleService } from '../../../../packages/orchestrator/src/index.js';
 import { PrivacyGuard } from '../../privacy/guard.js';
 import { resolveEnforcementMode } from '../utils/enforcementMode.js';
 class CliExecSessionHandle {