@kbediako/codex-orchestrator 0.1.2 → 0.1.3

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 {

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

@@ -1,8 +1,12 @@
 import process from 'node:process';
-import { loadUserConfig } from '../config/userConfig.js';
+import { loadPackageConfig, loadUserConfig } from '../config/userConfig.js';
 import { resolvePipeline } from '../pipelines/index.js';
 import { loadDesignConfig, shouldActivateDesignPipeline, designPipelineId } from '../../../../packages/shared/config/index.js';
 import { logger } from '../../logger.js';
+const DEVTOOLS_PIPELINE_ALIASES = new Map([
+    ['implementation-gate-devtools', 'implementation-gate'],
+    ['frontend-testing-devtools', 'frontend-testing']
+]);
 export class PipelineResolver {
     async loadDesignConfig(rootDir) {
         const designConfig = await loadDesignConfig({ rootDir });
@@ -19,9 +23,15 @@ export class PipelineResolver {
         logger.info(`PipelineResolver.resolve loaded design config from ${designConfig.path}`);
         const userConfig = await loadUserConfig(env);
         logger.info(`PipelineResolver.resolve loaded user config`);
-        const requestedPipelineId = options.pipelineId ??
+        const pipelineCandidate = options.pipelineId ??
             (shouldActivateDesignPipeline(designConfig) ? designPipelineId(designConfig) : undefined);
+        const resolvedAlias = this.resolvePipelineAlias(pipelineCandidate);
+        const requestedPipelineId = resolvedAlias.pipelineId;
         const envOverrides = this.resolveDesignEnvOverrides(designConfig, requestedPipelineId);
+        if (resolvedAlias.devtoolsRequested) {
+            envOverrides.CODEX_REVIEW_DEVTOOLS = '1';
+            logger.warn(`[pipeline] ${resolvedAlias.aliasId} is deprecated; use ${requestedPipelineId} with CODEX_REVIEW_DEVTOOLS=1.`);
+        }
         try {
             const { pipeline, source } = resolvePipeline(env, {
                 pipelineId: requestedPipelineId,
@@ -31,6 +41,17 @@ export class PipelineResolver {
             return { pipeline, userConfig, designConfig, source, envOverrides };
         }
         catch (error) {
+            if (requestedPipelineId === 'rlm' && userConfig?.source === 'repo') {
+                const packageConfig = await loadPackageConfig(env);
+                if (packageConfig) {
+                    const { pipeline, source } = resolvePipeline(env, {
+                        pipelineId: requestedPipelineId,
+                        config: packageConfig
+                    });
+                    logger.info(`PipelineResolver.resolve selected package pipeline ${pipeline.id}`);
+                    return { pipeline, userConfig: packageConfig, designConfig, source, envOverrides };
+                }
+            }
             logger.error(`PipelineResolver.resolve failed for ${requestedPipelineId ?? '<default>'}: ${error.message}`);
             throw error;
         }
@@ -44,4 +65,14 @@ export class PipelineResolver {
         }
         return envOverrides;
     }
+    resolvePipelineAlias(pipelineId) {
+        if (!pipelineId) {
+            return { pipelineId, devtoolsRequested: false };
+        }
+        const target = DEVTOOLS_PIPELINE_ALIASES.get(pipelineId);
+        if (!target) {
+            return { pipelineId, devtoolsRequested: false };
+        }
+        return { pipelineId: target, devtoolsRequested: true, aliasId: pipelineId };
+    }
 }

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

@@ -62,11 +62,17 @@ export async function prepareRun(options) {
         planPreview
     };
 }
-export function resolvePipelineForResume(env, manifest, config) {
+export function resolvePipelineForResume(env, manifest, config, fallbackConfig = null) {
     const existing = findPipeline(config ?? null, manifest.pipeline_id);
     if (existing) {
         return existing;
     }
+    if (manifest.pipeline_id === 'rlm' && fallbackConfig) {
+        const fallback = findPipeline(fallbackConfig, manifest.pipeline_id);
+        if (fallback) {
+            return fallback;
+        }
+    }
     const { pipeline } = resolvePipeline(env, { pipelineId: manifest.pipeline_id, config });
     return pipeline;
 }

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

@@ -1,6 +1,6 @@
 import { sanitizeTaskId } from '../run/environment.js';
 import { persistManifest } from '../run/manifestPersister.js';
-import { buildSchedulerRunSummary, createSchedulerPlan, finalizeSchedulerPlan, serializeSchedulerPlan } from '../../scheduler/index.js';
+import { buildSchedulerRunSummary, createSchedulerPlan, finalizeSchedulerPlan, serializeSchedulerPlan } from '../../scheduler/plan.js';
 import { isoTimestamp } from '../utils/time.js';
 export class SchedulerService {
     now;

package/dist/orchestrator/src/cli/utils/specGuardRunner.js

@@ -3,7 +3,9 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import process from 'node:process';
 import { logger } from '../../logger.js';
-const specGuardPath = join(process.cwd(), 'scripts', 'spec-guard.mjs');
+import { resolveEnvironmentPaths } from '../../../../scripts/lib/run-manifests.js';
+const { repoRoot } = resolveEnvironmentPaths();
+const specGuardPath = join(repoRoot, 'scripts', 'spec-guard.mjs');
 if (!existsSync(specGuardPath)) {
     logger.warn(`[spec-guard] skipped: ${specGuardPath} not found`);
     process.exit(0);

package/dist/orchestrator/src/cli/utils/strings.js

@@ -1,8 +1,10 @@
+import { slugify as sharedSlugify } from '../../../../packages/shared/utils/strings.js';
 export function slugify(value, fallback = 'command') {
-    const cleaned = value.trim().replace(/[^a-zA-Z0-9]+/g, '-').replace(/-+/g, '-');
-    const normalized = cleaned.replace(/^-|-$/g, '');
-    if (!normalized) {
-        return fallback;
-    }
-    return normalized.slice(0, 80);
+    return sharedSlugify(value, {
+        fallback,
+        maxLength: 80,
+        lowercase: false,
+        pattern: /[^a-zA-Z0-9]+/g,
+        collapseDashes: true
+    });
 }

package/dist/orchestrator/src/persistence/ExperienceStore.js

@@ -1,9 +1,10 @@
 import { randomBytes } from 'node:crypto';
-import { readFile, mkdir, rm, readdir } from 'node:fs/promises';
+import { readFile, mkdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
+import { listDirectories, resolveEnvironmentPaths } from '../../../scripts/lib/run-manifests.js';
 import { acquireLockWithRetry } from './lockFile.js';
 import { sanitizeTaskId } from './sanitizeTaskId.js';
-import { writeAtomicFile } from './writeAtomicFile.js';
+import { writeAtomicFile } from '../utils/atomicWrite.js';
 export class ExperienceStoreLockError extends Error {
     taskId;
     constructor(message, taskId) {
@@ -21,8 +22,9 @@ export class ExperienceStore {
     lockRetry;
     now;
     constructor(options = {}) {
-        this.outDir = options.outDir ?? join(process.cwd(), 'out');
-        this.runsDir = options.runsDir ?? join(process.cwd(), '.runs');
+        const envPaths = resolveEnvironmentPaths();
+        this.outDir = options.outDir ?? envPaths.outRoot;
+        this.runsDir = options.runsDir ?? envPaths.runsRoot;
         this.maxWords = Math.max(1, options.maxSummaryWords ?? DEFAULT_MAX_WORDS);
         const defaults = {
             maxAttempts: 5,
@@ -183,18 +185,6 @@ export class ExperienceStore {
         return `exp-${Date.now().toString(36)}-${suffix}`;
     }
 }
-async function listDirectories(path) {
-    try {
-        const entries = await readdir(path, { withFileTypes: true });
-        return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            return [];
-        }
-        throw error;
-    }
-}
 function truncateSummary(value, maxWords) {
     const tokens = value.trim().split(/\s+/u).filter(Boolean);
     if (tokens.length <= maxWords) {

package/dist/orchestrator/src/persistence/TaskStateStore.js

@@ -2,7 +2,7 @@ import { mkdir, readFile, rm } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { acquireLockWithRetry } from './lockFile.js';
 import { sanitizeTaskId } from './sanitizeTaskId.js';
-import { writeAtomicFile } from './writeAtomicFile.js';
+import { writeAtomicFile } from '../utils/atomicWrite.js';
 export class TaskStateStoreLockError extends Error {
     taskId;
     constructor(message, taskId) {

package/dist/orchestrator/src/persistence/sanitizeIdentifier.js

@@ -1,4 +1,4 @@
-import { WINDOWS_FORBIDDEN_CHARACTERS } from './identifierGuards.js';
+const WINDOWS_FORBIDDEN_CHARACTERS = new Set(['<', '>', ':', '"', '|', '?', '*']);
 export function sanitizeIdentifier(kind, value) {
     const label = kind === 'task' ? 'task' : 'run';
     if (!value) {