@kbediako/codex-orchestrator 0.1.37 → 0.2.0

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

@@ -0,0 +1,14 @@
+export async function runResumeCliShell(params) {
+    await params.runWithUi(async (runEvents) => {
+        const result = await params.orchestrator.resume({
+            runId: params.runId,
+            resumeToken: params.resumeToken,
+            actor: params.actor,
+            reason: params.reason,
+            targetStageId: params.targetStageId,
+            runtimeMode: params.runtimeMode,
+            runEvents
+        });
+        params.emitRunOutput(result, params.format, 'Run resumed');
+    });
+}

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

@@ -0,0 +1,72 @@
+/* eslint-disable patterns/prefer-logger-over-console */
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+import { fileURLToPath } from 'node:url';
+import { findPackageRoot } from './utils/packageInfo.js';
+const DEFAULT_DEPENDENCIES = {
+    runningFromSourceRuntime: () => fileURLToPath(import.meta.url).endsWith('.ts'),
+    getPackageRoot: () => findPackageRoot(import.meta.url),
+    fileExists: existsSync,
+    execPath: process.execPath,
+    getCwd: () => process.cwd(),
+    getEnv: () => process.env,
+    runPassthroughCommand,
+    setExitCode: (code) => {
+        process.exitCode = code;
+    }
+};
+export async function runReviewCliLaunchShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const runner = resolveReviewRunner(dependencies);
+    const exitCode = await dependencies.runPassthroughCommand(runner.command, [...runner.args, ...params.rawArgs], {
+        cwd: dependencies.getCwd(),
+        env: dependencies.getEnv()
+    });
+    if (exitCode !== 0) {
+        dependencies.setExitCode(exitCode);
+    }
+    return exitCode;
+}
+function resolveReviewRunner(dependencies) {
+    const packageRoot = dependencies.getPackageRoot();
+    const sourceRunner = join(packageRoot, 'scripts', 'run-review.ts');
+    const distRunner = join(packageRoot, 'dist', 'scripts', 'run-review.js');
+    if (dependencies.runningFromSourceRuntime() && dependencies.fileExists(sourceRunner)) {
+        return {
+            command: dependencies.execPath,
+            args: ['--loader', 'ts-node/esm', sourceRunner]
+        };
+    }
+    if (dependencies.fileExists(distRunner)) {
+        return {
+            command: dependencies.execPath,
+            args: [distRunner]
+        };
+    }
+    if (dependencies.fileExists(sourceRunner)) {
+        return {
+            command: dependencies.execPath,
+            args: ['--loader', 'ts-node/esm', sourceRunner]
+        };
+    }
+    throw new Error('Unable to locate review runner. Expected dist/scripts/run-review.js (npm) or scripts/run-review.ts (source checkout).');
+}
+async function runPassthroughCommand(command, args, options = {}) {
+    return await new Promise((resolve, reject) => {
+        const child = spawn(command, args, {
+            env: options.env ?? process.env,
+            cwd: options.cwd ?? process.cwd(),
+            stdio: 'inherit'
+        });
+        child.once('error', (error) => reject(error instanceof Error ? error : new Error(String(error))));
+        child.once('close', (code, signal) => {
+            if (signal) {
+                resolve(1);
+                return;
+            }
+            resolve(typeof code === 'number' ? code : 1);
+        });
+    });
+}

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

@@ -46,9 +46,9 @@ export const DEFAULT_ALIGNMENT_POLICY = {
         mandatory_turn_window: 20
     },
     route: {
-        sentinel_model: 'gpt-5.3-spark',
-        high_reasoning_model: 'gpt-5.3-codex',
-        arbitration_model: 'gpt-5.3-codex',
+        sentinel_model: 'gpt-5.4',
+        high_reasoning_model: 'gpt-5.4',
+        arbitration_model: 'gpt-5.4',
         high_reasoning_available: true
     }
 };

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

@@ -49,14 +49,14 @@ function foldAsciiBytes(buffer) {
     return output;
 }
 function buildChunks(source, targetBytes, overlapBytes) {
-    const chunks = [];
-    if (source.length === 0) {
-        return chunks;
-    }
     const safeTarget = Number.isFinite(targetBytes) ? Math.floor(targetBytes) : 0;
     if (safeTarget <= 0) {
         throw new Error('context chunk target_bytes must be > 0');
     }
+    const chunks = [];
+    if (source.length === 0) {
+        return chunks;
+    }
     const safeOverlap = Number.isFinite(overlapBytes) ? Math.floor(overlapBytes) : 0;
     const overlap = clampOverlap(safeTarget, safeOverlap);
     let index = 0;
@@ -105,6 +105,82 @@ function validateIndex(index) {
         throw new Error('context index chunks missing');
     }
 }
+async function hashOpenFile(file) {
+    const hash = createHash('sha256');
+    const buffer = Buffer.allocUnsafe(64 * 1024);
+    for (;;) {
+        const { bytesRead } = await file.read(buffer, 0, buffer.length, null);
+        if (bytesRead === 0) {
+            break;
+        }
+        hash.update(buffer.subarray(0, bytesRead));
+    }
+    return hash.digest('hex');
+}
+async function readExactFileSlice(file, start, end) {
+    const length = Math.max(0, end - start);
+    const bytes = Buffer.alloc(length);
+    let offset = 0;
+    while (offset < length) {
+        const { bytesRead } = await file.read(bytes, offset, length - offset, start + offset);
+        if (bytesRead === 0) {
+            throw new Error('context source truncated while validating chunk');
+        }
+        offset += bytesRead;
+    }
+    return bytes;
+}
+async function validateIndexAgainstSourcePath(index, sourcePath) {
+    const file = await open(sourcePath, 'r');
+    try {
+        const sourceStats = await file.stat();
+        if (index.source.byte_length !== sourceStats.size) {
+            throw new Error('context index source length mismatch');
+        }
+        const expectedObjectId = `sha256:${await hashOpenFile(file)}`;
+        if (index.object_id !== expectedObjectId) {
+            throw new Error('context index object_id mismatch');
+        }
+        const safeTarget = Number.isFinite(index.chunking.target_bytes)
+            ? Math.floor(index.chunking.target_bytes)
+            : 0;
+        if (safeTarget <= 0) {
+            throw new Error('context chunk target_bytes must be > 0');
+        }
+        const safeOverlap = Number.isFinite(index.chunking.overlap_bytes)
+            ? Math.floor(index.chunking.overlap_bytes)
+            : 0;
+        const overlap = clampOverlap(safeTarget, safeOverlap);
+        let indexPosition = 0;
+        let start = 0;
+        while (start < sourceStats.size) {
+            const end = Math.min(start + safeTarget, sourceStats.size);
+            const expectedId = `c${String(indexPosition + 1).padStart(6, '0')}`;
+            const actualChunk = index.chunks[indexPosition];
+            if (!actualChunk) {
+                throw new Error('context index chunk missing');
+            }
+            const chunkBytes = await readExactFileSlice(file, start, end);
+            if (actualChunk.id !== expectedId ||
+                actualChunk.start !== start ||
+                actualChunk.end !== end ||
+                actualChunk.sha256 !== hashBytes(chunkBytes)) {
+                throw new Error('context index chunk mismatch');
+            }
+            indexPosition += 1;
+            if (end >= sourceStats.size) {
+                break;
+            }
+            start = Math.max(0, end - overlap);
+        }
+        if (index.chunks.length !== indexPosition) {
+            throw new Error('context index chunk count mismatch');
+        }
+    }
+    finally {
+        await file.close();
+    }
+}
 export function parseContextPointer(pointer) {
     if (typeof pointer !== 'string' || !pointer.startsWith(DEFAULT_POINTER_PREFIX)) {
         return null;
@@ -133,13 +209,24 @@ export async function buildContextObject(options) {
         if (!(await pathExists(existingIndexPath)) || !(await pathExists(existingSourcePath))) {
             throw new Error('context_source invalid');
         }
-        const raw = await readFile(existingIndexPath, 'utf8');
-        const parsed = JSON.parse(raw);
-        validateIndex(parsed);
         if (sourceDir !== targetDir) {
             await copyFile(existingIndexPath, indexPath);
             await copyFile(existingSourcePath, sourcePath);
+            const copiedRaw = await readFile(indexPath, 'utf8');
+            const copiedParsed = JSON.parse(copiedRaw);
+            validateIndex(copiedParsed);
+            await validateIndexAgainstSourcePath(copiedParsed, sourcePath);
+            return {
+                dir: targetDir,
+                indexPath,
+                sourcePath,
+                index: copiedParsed
+            };
         }
+        const raw = await readFile(existingIndexPath, 'utf8');
+        const parsed = JSON.parse(raw);
+        validateIndex(parsed);
+        await validateIndexAgainstSourcePath(parsed, existingSourcePath);
         return {
             dir: targetDir,
             indexPath,