@kbediako/codex-orchestrator 0.1.15 → 0.1.16

package/README.md

@@ -80,6 +80,11 @@ codex -c 'mcp_servers.delegation.enabled=true' ...
 ```
 `delegate-server` is the canonical name; `delegation-server` is supported as an alias (older docs may use it).
 
+Delegation guard profile:
+- `CODEX_ORCHESTRATOR_GUARD_PROFILE=auto` (default): strict in CO-style repos, warn in lightweight repos.
+- Set `CODEX_ORCHESTRATOR_GUARD_PROFILE=warn` for ad-hoc/no-task-id runs.
+- Set `CODEX_ORCHESTRATOR_GUARD_PROFILE=strict` to enforce full delegation evidence checks.
+
 ## Delegation + RLM flow
 
 RLM (Recursive Language Model) is the long-horizon loop used by the `rlm` pipeline (`codex-orchestrator rlm "<goal>"` or `codex-orchestrator start rlm --goal "<goal>"`). Delegated runs only enter RLM when the child is launched with the `rlm` pipeline (or the rlm runner directly). In auto mode it resolves to symbolic when delegated, when `RLM_CONTEXT_PATH` is set, or when the context exceeds `RLM_SYMBOLIC_MIN_BYTES`; otherwise it stays iterative. The runner writes state to `.runs/<task-id>/cli/<run-id>/rlm/state.json` and stops when the validator passes or budgets are exhausted.

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

@@ -40,6 +40,7 @@ const CONFIRMATION_ERROR_CODES = new Set([
     'nonce_already_consumed'
 ]);
 const TOOL_PROFILE_ENTRY_PATTERN = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+const TERMINAL_RUN_STATUSES = new Set(['succeeded', 'failed', 'cancelled', 'canceled']);
 export async function startDelegationServer(options) {
     const repoRoot = resolve(options.repoRoot);
     const configFiles = await loadDelegationConfigFiles({ repoRoot });
@@ -272,7 +273,9 @@ async function handleDelegateStatus(input, allowedRoots, allowedHosts) {
     const raw = await readFile(manifestPath, 'utf8');
     const manifest = JSON.parse(raw);
     const eventsPath = resolve(dirname(manifestPath), 'events.jsonl');
-    await assertControlEndpoint(manifestPath, allowedHosts);
+    if (!TERMINAL_RUN_STATUSES.has(manifest.status)) {
+        await assertControlEndpoint(manifestPath, allowedHosts);
+    }
     return {
         run_id: manifest.run_id,
         task_id: manifest.task_id,

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

@@ -153,6 +153,7 @@ export async function runCommandStage(context, hooks = {}) {
         const baseEnv = {
             ...process.env,
             ...(envOverrides ?? {}),
+            MCP_RUNNER_TASK_ID: manifest.task_id,
             CODEX_ORCHESTRATOR_TASK_ID: manifest.task_id,
             CODEX_ORCHESTRATOR_RUN_ID: manifest.run_id,
             CODEX_ORCHESTRATOR_PIPELINE_ID: manifest.pipeline_id,

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

@@ -0,0 +1,80 @@
+import { spawn } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import process from 'node:process';
+import { pathToFileURL } from 'node:url';
+import { logger } from '../../logger.js';
+import { resolveEnvironmentPaths } from '../../../../scripts/lib/run-manifests.js';
+const DEFAULT_PROFILE = 'auto';
+const REPO_STRICT_MARKERS = ['AGENTS.md', join('tasks', 'index.json'), join('docs', 'TASKS.md')];
+export function parseGuardProfile(raw) {
+    const normalized = String(raw ?? '').trim().toLowerCase();
+    if (normalized === 'strict' || normalized === 'warn' || normalized === 'auto') {
+        return normalized;
+    }
+    return DEFAULT_PROFILE;
+}
+export function hasRepoStrictMarkers(repoRoot, fileExists = existsSync) {
+    return REPO_STRICT_MARKERS.every((marker) => fileExists(join(repoRoot, marker)));
+}
+export function resolveEffectiveGuardProfile(repoRoot, env = process.env, fileExists = existsSync) {
+    const requested = parseGuardProfile(env.CODEX_ORCHESTRATOR_GUARD_PROFILE ?? env.CODEX_GUARD_PROFILE);
+    if (requested === 'strict' || requested === 'warn') {
+        return requested;
+    }
+    return hasRepoStrictMarkers(repoRoot, fileExists) ? 'strict' : 'warn';
+}
+export function buildDelegationGuardEnv(env, profile) {
+    const taskId = (env.MCP_RUNNER_TASK_ID ?? '').trim();
+    const existingOverride = (env.DELEGATION_GUARD_OVERRIDE_REASON ?? '').trim();
+    if (profile !== 'warn' || taskId || existingOverride) {
+        return { ...env };
+    }
+    return {
+        ...env,
+        DELEGATION_GUARD_OVERRIDE_REASON: 'No MCP_RUNNER_TASK_ID provided (warn profile): delegation evidence check bypassed.'
+    };
+}
+export async function runDelegationGuardRunner(argv = process.argv.slice(2)) {
+    const { repoRoot } = resolveEnvironmentPaths();
+    const guardPath = join(repoRoot, 'scripts', 'delegation-guard.mjs');
+    const profile = resolveEffectiveGuardProfile(repoRoot);
+    if (!existsSync(guardPath)) {
+        if (profile === 'strict') {
+            logger.error(`[delegation-guard] failed: ${guardPath} not found (strict profile)`);
+            process.exit(1);
+            return;
+        }
+        logger.warn(`[delegation-guard] skipped: ${guardPath} not found (warn profile)`);
+        process.exit(0);
+        return;
+    }
+    const child = spawn(process.execPath, [guardPath, ...argv], {
+        stdio: 'inherit',
+        env: buildDelegationGuardEnv(process.env, profile)
+    });
+    child.on('error', (error) => {
+        logger.error(`[delegation-guard] failed: ${error.message}`);
+        process.exit(1);
+    });
+    child.on('exit', (code, signal) => {
+        if (typeof code === 'number') {
+            process.exit(code);
+            return;
+        }
+        if (signal) {
+            logger.error(`[delegation-guard] exited with signal ${signal}`);
+        }
+        process.exit(1);
+    });
+}
+function isDirectExecution() {
+    const entry = process.argv[1];
+    if (!entry) {
+        return false;
+    }
+    return import.meta.url === pathToFileURL(entry).href;
+}
+if (isDirectExecution()) {
+    void runDelegationGuardRunner();
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kbediako/codex-orchestrator",
-  "version": "0.1.15",
+  "version": "0.1.16",
   "license": "MIT",
   "repository": {
     "type": "git",

package/skills/delegate-early/SKILL.md

@@ -24,7 +24,9 @@ Use this skill when a task can be split into parallel streams or when the main c
 ## Required conventions
 - Use `MCP_RUNNER_TASK_ID=<task-id>-<stream>` for subagents.
 - Record manifest paths and summarize findings in the main run.
-- Run `node scripts/delegation-guard.mjs` before review handoff to verify delegation evidence.
+- Before review handoff, run the delegation guard stage via the packaged runner:
+  `node "$CODEX_ORCHESTRATOR_PACKAGE_ROOT/dist/orchestrator/src/cli/utils/delegationGuardRunner.js"`.
+  For ad-hoc runs without task IDs, set `CODEX_ORCHESTRATOR_GUARD_PROFILE=warn`.
 
 ## Minimal delegation workflow
 1) Name streams and write 1–2 sentence goals for each.