@kbediako/codex-orchestrator 0.1.32 → 0.1.34

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

@@ -33,7 +33,16 @@ const DEFAULT_MAX_CONCURRENCY = 4;
 const DEFAULT_SYMBOLIC_DELIBERATION_INTERVAL = 2;
 const DEFAULT_SYMBOLIC_DELIBERATION_MAX_RUNS = 12;
 const DEFAULT_SYMBOLIC_DELIBERATION_MAX_SUMMARY_BYTES = 2048;
+const DEFAULT_COLLAB_ROLE_POLICY = 'enforce';
+const COLLAB_ROLE_POLICY_ENV_CANONICAL = 'RLM_SYMBOLIC_MULTI_AGENT_ROLE_POLICY';
+const COLLAB_ROLE_POLICY_ENV_LEGACY = 'RLM_COLLAB_ROLE_POLICY';
+const COLLAB_ALLOW_DEFAULT_ROLE_ENV_CANONICAL = 'RLM_SYMBOLIC_MULTI_AGENT_ALLOW_DEFAULT_ROLE';
+const COLLAB_ALLOW_DEFAULT_ROLE_ENV_LEGACY = 'RLM_COLLAB_ALLOW_DEFAULT_ROLE';
 const UNBOUNDED_ITERATION_ALIASES = new Set(['unbounded', 'unlimited', 'infinite', 'infinity']);
+const COLLAB_FEATURE_CANONICAL = 'multi_agent';
+const COLLAB_FEATURE_LEGACY = 'collab';
+const COLLAB_ROLE_TAG_PATTERN = /^\s*\[(?:agent_type|role)\s*:\s*([a-z0-9._-]+)\]/i;
+const COLLAB_ROLE_TOKEN_PATTERN = /^[a-z0-9._-]+$/;
 function parseArgs(argv) {
     const parsed = {};
     for (let i = 0; i < argv.length; i += 1) {
@@ -102,6 +111,15 @@ function envFlagEnabled(value) {
     const normalized = value.trim().toLowerCase();
     return normalized === '1' || normalized === 'true' || normalized === 'yes' || normalized === 'on';
 }
+function resolveSymbolicMultiAgentConfig(env) {
+    if (env.RLM_SYMBOLIC_MULTI_AGENT !== undefined) {
+        return { enabled: envFlagEnabled(env.RLM_SYMBOLIC_MULTI_AGENT), source: 'canonical' };
+    }
+    if (env.RLM_SYMBOLIC_COLLAB !== undefined) {
+        return { enabled: envFlagEnabled(env.RLM_SYMBOLIC_COLLAB), source: 'legacy' };
+    }
+    return { enabled: false, source: null };
+}
 function shouldForceNonInteractive(env) {
     const stdinIsTTY = process.stdin?.isTTY === true;
     return (!stdinIsTTY ||
@@ -196,9 +214,9 @@ function resolveRlmMode(rawMode, options) {
     if (normalized !== 'auto') {
         return null;
     }
-    if (options.delegated ||
-        options.hasContextPath ||
-        options.contextBytes >= options.symbolicMinBytes) {
+    const largeContext = options.contextBytes >= options.symbolicMinBytes;
+    const explicitContextSignal = options.hasContextPath || options.delegated;
+    if (largeContext && explicitContextSignal) {
         return 'symbolic';
     }
     return 'iterative';
@@ -323,9 +341,19 @@ async function runCodexCompletion(prompt, env, repoRoot, nonInteractive, subagen
 async function runCodexJsonlCompletion(prompt, env, repoRoot, nonInteractive, mirrorOutput, extraArgs = [], options = {}) {
     const { stdout, stderr } = await runCodexExec(['exec', '--json', ...extraArgs, prompt], env, repoRoot, nonInteractive, false, mirrorOutput);
     if (options.validateCollabLifecycle) {
-        const validation = validateCollabLifecycle(stdout);
+        const rolePolicy = options.collabRolePolicy ?? DEFAULT_COLLAB_ROLE_POLICY;
+        const validation = validateCollabLifecycle(stdout, {
+            requireSpawnRole: rolePolicy !== 'off',
+            allowDefaultRole: options.collabAllowDefaultRole ?? false
+        });
         if (!validation.ok) {
-            throw new Error(`Collab lifecycle validation failed: ${validation.reason}`);
+            const rolePolicyFailure = isRolePolicyValidationReason(validation.reasonCode);
+            if (rolePolicy === 'warn' && rolePolicyFailure) {
+                logger.warn(`Collab lifecycle validation warning: ${validation.reason}`);
+            }
+            else {
+                throw new Error(`Collab lifecycle validation failed: ${validation.reason}`);
+            }
         }
     }
     const message = extractAgentMessageFromJsonl(stdout);
@@ -334,6 +362,50 @@ async function runCodexJsonlCompletion(prompt, env, repoRoot, nonInteractive, mi
     }
     return [stdout.trim(), stderr.trim()].filter(Boolean).join('\n');
 }
+function parseFeatureFlagsFromText(raw) {
+    const flags = {};
+    for (const line of raw.split(/\r?\n/u)) {
+        const trimmed = line.trim();
+        if (!trimmed) {
+            continue;
+        }
+        const tokens = trimmed.split(/\s+/u);
+        if (tokens.length < 2) {
+            continue;
+        }
+        const name = tokens[0] ?? '';
+        const enabledToken = tokens[tokens.length - 1] ?? '';
+        if (!name) {
+            continue;
+        }
+        if (enabledToken === 'true') {
+            flags[name] = true;
+        }
+        else if (enabledToken === 'false') {
+            flags[name] = false;
+        }
+    }
+    return flags;
+}
+function resolveCollabFeatureKeyFromFlags(flags) {
+    if (Object.prototype.hasOwnProperty.call(flags, COLLAB_FEATURE_CANONICAL)) {
+        return COLLAB_FEATURE_CANONICAL;
+    }
+    if (Object.prototype.hasOwnProperty.call(flags, COLLAB_FEATURE_LEGACY)) {
+        return COLLAB_FEATURE_LEGACY;
+    }
+    return COLLAB_FEATURE_LEGACY;
+}
+async function resolveCollabFeatureKey(env, repoRoot, nonInteractive) {
+    try {
+        const { stdout } = await runCodexExec(['features', 'list'], env, repoRoot, nonInteractive, false, false);
+        return resolveCollabFeatureKeyFromFlags(parseFeatureFlagsFromText(stdout));
+    }
+    catch (error) {
+        logger.debug(`Unable to resolve Codex collab feature key via \`codex features list\`: ${error instanceof Error ? error.message : String(error)}`);
+        return COLLAB_FEATURE_LEGACY;
+    }
+}
 function extractAgentMessageFromJsonl(raw) {
     let lastMessage = null;
     const lines = raw.split(/\r?\n/);
@@ -380,12 +452,16 @@ function parseCollabToolCallsFromJsonl(raw) {
             const receiverThreadIds = Array.isArray(parsed.item.receiver_thread_ids)
                 ? parsed.item.receiver_thread_ids.filter((entry) => typeof entry === 'string')
                 : [];
+            const prompt = typeof parsed.item.prompt === 'string' ? parsed.item.prompt : null;
             calls.push({
                 sequence: index,
                 eventType: parsed.type,
                 tool: parsed.item.tool,
                 status: normalizeCollabStatus(parsed.item.status),
-                receiverThreadIds
+                receiverThreadIds,
+                prompt,
+                agentType: normalizeCollabRoleToken(parsed.item.agent_type),
+                promptRole: resolveCollabRoleFromPrompt(prompt)
             });
         }
         catch {
@@ -397,6 +473,82 @@ function parseCollabToolCallsFromJsonl(raw) {
 function formatLifecycleIds(ids) {
     return ids.slice(0, 3).join(', ');
 }
+function normalizeCollabRoleToken(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const normalized = value.trim().toLowerCase();
+    if (!normalized || !COLLAB_ROLE_TOKEN_PATTERN.test(normalized)) {
+        return null;
+    }
+    return normalized;
+}
+function resolveCollabRoleFromPrompt(value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const match = value.match(COLLAB_ROLE_TAG_PATTERN);
+    if (!match || typeof match[1] !== 'string') {
+        return null;
+    }
+    return normalizeCollabRoleToken(match[1]);
+}
+function resolveCollabRolePolicy(value) {
+    const normalized = (value ?? '').trim().toLowerCase();
+    if (!normalized) {
+        return DEFAULT_COLLAB_ROLE_POLICY;
+    }
+    if (normalized === 'off' ||
+        normalized === 'disabled' ||
+        normalized === 'none' ||
+        normalized === '0' ||
+        normalized === 'false') {
+        return 'off';
+    }
+    if (normalized === 'warn' || normalized === 'warning' || normalized === 'soft') {
+        return 'warn';
+    }
+    if (normalized === 'enforce' || normalized === 'strict' || normalized === 'on' || normalized === 'true' || normalized === '1') {
+        return 'enforce';
+    }
+    logger.warn(`Invalid multi-agent role policy value "${value}". Using "${DEFAULT_COLLAB_ROLE_POLICY}" ` +
+        `(expected: enforce|warn|off; canonical env ${COLLAB_ROLE_POLICY_ENV_CANONICAL}, ` +
+        `legacy alias ${COLLAB_ROLE_POLICY_ENV_LEGACY}).`);
+    return DEFAULT_COLLAB_ROLE_POLICY;
+}
+function resolveSymbolicMultiAgentRolePolicyConfig(env) {
+    const canonical = env[COLLAB_ROLE_POLICY_ENV_CANONICAL];
+    const legacy = env[COLLAB_ROLE_POLICY_ENV_LEGACY];
+    if (canonical !== undefined) {
+        if (legacy !== undefined && legacy.trim().toLowerCase() !== canonical.trim().toLowerCase()) {
+            logger.warn(`${COLLAB_ROLE_POLICY_ENV_LEGACY} is ignored because ${COLLAB_ROLE_POLICY_ENV_CANONICAL} is set.`);
+        }
+        return { value: resolveCollabRolePolicy(canonical), source: 'canonical' };
+    }
+    if (legacy !== undefined) {
+        return { value: resolveCollabRolePolicy(legacy), source: 'legacy' };
+    }
+    return { value: resolveCollabRolePolicy(undefined), source: null };
+}
+function resolveSymbolicMultiAgentAllowDefaultRoleConfig(env) {
+    const canonical = env[COLLAB_ALLOW_DEFAULT_ROLE_ENV_CANONICAL];
+    const legacy = env[COLLAB_ALLOW_DEFAULT_ROLE_ENV_LEGACY];
+    if (canonical !== undefined) {
+        if (legacy !== undefined && envFlagEnabled(legacy) !== envFlagEnabled(canonical)) {
+            logger.warn(`${COLLAB_ALLOW_DEFAULT_ROLE_ENV_LEGACY} is ignored because ${COLLAB_ALLOW_DEFAULT_ROLE_ENV_CANONICAL} is set.`);
+        }
+        return { value: envFlagEnabled(canonical), source: 'canonical' };
+    }
+    if (legacy !== undefined) {
+        return { value: envFlagEnabled(legacy), source: 'legacy' };
+    }
+    return { value: false, source: null };
+}
+function isRolePolicyValidationReason(reasonCode) {
+    return (reasonCode === 'missing_role' ||
+        reasonCode === 'default_role_disallowed' ||
+        reasonCode === 'role_mismatch');
+}
 function includesThreadLimit(text) {
     return text.toLowerCase().includes('agent thread limit reached');
 }
@@ -438,9 +590,11 @@ function hasCollabSpawnThreadLimitError(raw) {
     }
     return false;
 }
-function validateCollabLifecycle(raw) {
+function validateCollabLifecycle(raw, options = {}) {
+    const requireSpawnRole = options.requireSpawnRole !== false;
+    const allowDefaultRole = options.allowDefaultRole === true;
     if (hasCollabSpawnThreadLimitError(raw)) {
-        return { ok: false, reason: 'collab spawn hit thread limit' };
+        return { ok: false, reason: 'collab spawn hit thread limit', reasonCode: 'thread_limit' };
     }
     const calls = parseCollabToolCallsFromJsonl(raw);
     if (calls.length === 0) {
@@ -449,16 +603,53 @@ function validateCollabLifecycle(raw) {
     const spawnedAt = new Map();
     const waitedAt = new Map();
     const closedAt = new Map();
+    const missingRoleIds = new Set();
+    const disallowedDefaultRoleIds = new Set();
+    const mismatchedRoleIds = new Set();
+    const roleByThread = new Map();
     for (const call of calls) {
         const isCompleted = call.status === 'completed' || (call.status === 'unknown' && call.eventType === 'item.completed');
         if (!isCompleted) {
             continue;
         }
-        for (const threadId of call.receiverThreadIds) {
-            if (call.tool === 'spawn_agent' && !spawnedAt.has(threadId)) {
-                spawnedAt.set(threadId, call.sequence);
+        if (call.tool === 'spawn_agent') {
+            const explicitRole = call.agentType;
+            const promptRole = call.promptRole;
+            const effectiveRole = explicitRole ?? promptRole;
+            const roleTargets = call.receiverThreadIds.length > 0 ? call.receiverThreadIds : [`spawn@${call.sequence}`];
+            if (requireSpawnRole && !effectiveRole) {
+                for (const target of roleTargets) {
+                    missingRoleIds.add(target);
+                }
+            }
+            else if (effectiveRole === 'default' && !allowDefaultRole) {
+                for (const target of roleTargets) {
+                    disallowedDefaultRoleIds.add(target);
+                }
+            }
+            if (explicitRole && promptRole && explicitRole !== promptRole) {
+                for (const target of roleTargets) {
+                    mismatchedRoleIds.add(target);
+                }
             }
-            else if (call.tool === 'wait') {
+            for (const threadId of call.receiverThreadIds) {
+                if (!spawnedAt.has(threadId)) {
+                    spawnedAt.set(threadId, call.sequence);
+                }
+                if (!effectiveRole) {
+                    continue;
+                }
+                const previous = roleByThread.get(threadId);
+                if (previous && previous !== effectiveRole) {
+                    mismatchedRoleIds.add(threadId);
+                    continue;
+                }
+                roleByThread.set(threadId, effectiveRole);
+            }
+            continue;
+        }
+        for (const threadId of call.receiverThreadIds) {
+            if (call.tool === 'wait') {
                 waitedAt.set(threadId, call.sequence);
             }
             else if (call.tool === 'close_agent') {
@@ -467,35 +658,63 @@ function validateCollabLifecycle(raw) {
         }
     }
     const spawnedIds = Array.from(spawnedAt.keys());
-    if (spawnedIds.length === 0) {
+    if (spawnedIds.length > 0) {
+        const missingWait = spawnedIds.filter((threadId) => !waitedAt.has(threadId));
+        if (missingWait.length > 0) {
+            return {
+                ok: false,
+                reason: `missing wait for spawned agent(s): ${formatLifecycleIds(missingWait)}`,
+                reasonCode: 'missing_wait'
+            };
+        }
+        const missingClose = spawnedIds.filter((threadId) => !closedAt.has(threadId));
+        if (missingClose.length > 0) {
+            return {
+                ok: false,
+                reason: `missing close_agent for spawned agent(s): ${formatLifecycleIds(missingClose)}`,
+                reasonCode: 'missing_close'
+            };
+        }
+        const invalidOrder = spawnedIds.filter((threadId) => {
+            const waitSequence = waitedAt.get(threadId);
+            const closeSequence = closedAt.get(threadId);
+            if (waitSequence === undefined || closeSequence === undefined) {
+                return false;
+            }
+            return closeSequence < waitSequence;
+        });
+        if (invalidOrder.length > 0) {
+            return {
+                ok: false,
+                reason: `close_agent before wait for agent(s): ${formatLifecycleIds(invalidOrder)}`,
+                reasonCode: 'close_before_wait'
+            };
+        }
+    }
+    if (!requireSpawnRole) {
         return { ok: true };
     }
-    const missingWait = spawnedIds.filter((threadId) => !waitedAt.has(threadId));
-    if (missingWait.length > 0) {
+    if (missingRoleIds.size > 0) {
         return {
             ok: false,
-            reason: `missing wait for spawned agent(s): ${formatLifecycleIds(missingWait)}`
+            reason: `missing explicit role for spawn_agent call(s): ${formatLifecycleIds(Array.from(missingRoleIds))}. ` +
+                'Prefix prompts with [agent_type:<role>] and set spawn_agent.agent_type when supported.',
+            reasonCode: 'missing_role'
         };
     }
-    const missingClose = spawnedIds.filter((threadId) => !closedAt.has(threadId));
-    if (missingClose.length > 0) {
+    if (disallowedDefaultRoleIds.size > 0) {
         return {
             ok: false,
-            reason: `missing close_agent for spawned agent(s): ${formatLifecycleIds(missingClose)}`
+            reason: `spawn_agent used disallowed default role for: ${formatLifecycleIds(Array.from(disallowedDefaultRoleIds))}. ` +
+                'Set a non-default agent_type explicitly.',
+            reasonCode: 'default_role_disallowed'
         };
     }
-    const invalidOrder = spawnedIds.filter((threadId) => {
-        const waitSequence = waitedAt.get(threadId);
-        const closeSequence = closedAt.get(threadId);
-        if (waitSequence === undefined || closeSequence === undefined) {
-            return false;
-        }
-        return closeSequence < waitSequence;
-    });
-    if (invalidOrder.length > 0) {
+    if (mismatchedRoleIds.size > 0) {
         return {
             ok: false,
-            reason: `close_agent before wait for agent(s): ${formatLifecycleIds(invalidOrder)}`
+            reason: `spawn_agent role mismatch for agent(s): ${formatLifecycleIds(Array.from(mismatchedRoleIds))}`,
+            reasonCode: 'role_mismatch'
         };
     }
     return { ok: true };
@@ -504,7 +723,8 @@ function buildCollabSubcallPrompt(prompt) {
     return [
         'Use collab tools to run the sub-agent prompt below.',
         'For every spawned agent id, execute this lifecycle in order:',
-        '1) spawn_agent',
+        '1) spawn_agent with explicit agent_type (never omit it; omission defaults to `default`),',
+        '   and prefix the spawned prompt with [agent_type:<same-role>] on the first line',
         '2) wait (for that same id)',
         '3) close_agent (for that same id)',
         'Never leave spawned agents unclosed, including timeout or error paths.',
@@ -772,7 +992,12 @@ async function main() {
         logger.info(`Validator: ${validatorCommand}`);
     }
     const subagentsEnabled = envFlagEnabled(env.CODEX_SUBAGENTS) || envFlagEnabled(env.RLM_SUBAGENTS);
-    const symbolicCollabEnabled = envFlagEnabled(env.RLM_SYMBOLIC_COLLAB);
+    const symbolicMultiAgent = resolveSymbolicMultiAgentConfig(env);
+    const symbolicCollabEnabled = symbolicMultiAgent.enabled;
+    const collabRolePolicyConfig = resolveSymbolicMultiAgentRolePolicyConfig(env);
+    const collabRolePolicy = collabRolePolicyConfig.value;
+    const collabAllowDefaultRoleConfig = resolveSymbolicMultiAgentAllowDefaultRoleConfig(env);
+    const collabAllowDefaultRole = collabAllowDefaultRoleConfig.value;
     const symbolicDeliberationEnabled = env.RLM_SYMBOLIC_DELIBERATION === undefined
         ? true
         : envFlagEnabled(env.RLM_SYMBOLIC_DELIBERATION);
@@ -782,6 +1007,22 @@ async function main() {
     const symbolicDeliberationLogArtifacts = envFlagEnabled(env.RLM_SYMBOLIC_DELIBERATION_LOG);
     const nonInteractive = shouldForceNonInteractive(env);
     if (mode === 'symbolic') {
+        if (symbolicMultiAgent.source === 'legacy') {
+            logger.warn('RLM_SYMBOLIC_COLLAB is a legacy alias; prefer RLM_SYMBOLIC_MULTI_AGENT.');
+        }
+        if (collabRolePolicyConfig.source === 'legacy') {
+            logger.warn(`${COLLAB_ROLE_POLICY_ENV_LEGACY} is a legacy alias; prefer ${COLLAB_ROLE_POLICY_ENV_CANONICAL}.`);
+        }
+        if (collabAllowDefaultRoleConfig.source === 'legacy') {
+            logger.warn(`${COLLAB_ALLOW_DEFAULT_ROLE_ENV_LEGACY} is a legacy alias; prefer ${COLLAB_ALLOW_DEFAULT_ROLE_ENV_CANONICAL}.`);
+        }
+        const collabFeatureKey = symbolicCollabEnabled
+            ? await resolveCollabFeatureKey(env, repoRoot, nonInteractive)
+            : COLLAB_FEATURE_LEGACY;
+        if (symbolicCollabEnabled) {
+            logger.info(`Symbolic collab feature key: ${collabFeatureKey}`);
+            logger.info(`Symbolic collab role policy: ${collabRolePolicy} (allow_default_role=${collabAllowDefaultRole ? '1' : '0'})`);
+        }
         const budgets = {
             maxSubcallsPerIteration: parsePositiveInt(env.RLM_MAX_SUBCALLS_PER_ITERATION, DEFAULT_MAX_SUBCALLS_PER_ITERATION) ??
                 0,
@@ -881,11 +1122,13 @@ async function main() {
                 const collabPrompt = buildCollabSubcallPrompt(prompt);
                 return runCodexJsonlCompletion(collabPrompt, env, repoRoot, nonInteractive, true, [
                     '--enable',
-                    'collab',
+                    collabFeatureKey,
                     '--sandbox',
                     'read-only'
                 ], {
-                    validateCollabLifecycle: true
+                    validateCollabLifecycle: true,
+                    collabRolePolicy,
+                    collabAllowDefaultRole
                 });
             },
             deliberation: {
@@ -904,11 +1147,13 @@ async function main() {
                     const collabPrompt = buildCollabSubcallPrompt(prompt);
                     return runCodexJsonlCompletion(collabPrompt, env, repoRoot, nonInteractive, true, [
                         '--enable',
-                        'collab',
+                        collabFeatureKey,
                         '--sandbox',
                         'read-only'
                     ], {
-                        validateCollabLifecycle: true
+                        validateCollabLifecycle: true,
+                        collabRolePolicy,
+                        collabAllowDefaultRole
                     });
                 }
             },
@@ -956,10 +1201,19 @@ if (entry && entry === self) {
 export const __test__ = {
     parseMaxIterations,
     parsePositiveInt,
+    resolveSymbolicMultiAgentConfig,
+    resolveSymbolicMultiAgentRolePolicyConfig,
+    resolveSymbolicMultiAgentAllowDefaultRoleConfig,
+    parseFeatureFlagsFromText,
+    resolveCollabFeatureKeyFromFlags,
+    resolveCollabRolePolicy,
+    isRolePolicyValidationReason,
     resolveRlmMode,
     parseCollabToolCallsFromJsonl,
     validateCollabLifecycle,
     buildCollabSubcallPrompt,
+    COLLAB_FEATURE_CANONICAL,
+    COLLAB_FEATURE_LEGACY,
     DEFAULT_MAX_ITERATIONS,
     DEFAULT_MAX_MINUTES,
     DEFAULT_SYMBOLIC_MIN_BYTES

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

@@ -58,6 +58,7 @@ export async function bootstrapManifest(runId, options) {
         prompt_packs: [],
         guardrails_required: pipeline.guardrailsRequired !== false,
         cloud_execution: null,
+        cloud_fallback: null,
         learning: {
             validation: {
                 mode: 'per-task',
@@ -192,6 +193,7 @@ export function resetForResume(manifest) {
     manifest.status_detail = 'resuming';
     manifest.guardrail_status = undefined;
     manifest.cloud_execution = null;
+    manifest.cloud_fallback = null;
 }
 export function recordResumeEvent(manifest, event) {
     manifest.resume_events.push({ ...event, timestamp: isoTimestamp() });
@@ -228,18 +230,20 @@ function computeGuardrailStatus(manifest) {
         other: 0
     };
     for (const entry of guardrailCommands) {
-        if (entry.status === 'succeeded') {
+        const status = classifyGuardrailCommand(entry);
+        if (status === 'succeeded') {
             counts.succeeded += 1;
+            continue;
         }
-        else if (entry.status === 'failed') {
+        if (status === 'failed') {
             counts.failed += 1;
+            continue;
         }
-        else if (entry.status === 'skipped') {
+        if (status === 'skipped') {
             counts.skipped += 1;
+            continue;
         }
-        else {
-            counts.other += 1;
-        }
+        counts.other += 1;
     }
     const present = counts.succeeded > 0;
     let recommendation = null;
@@ -270,6 +274,27 @@ function selectGuardrailCommands(manifest) {
         return haystack.includes('spec-guard') || haystack.includes('specguardrunner');
     });
 }
+function classifyGuardrailCommand(entry) {
+    if (entry.status === 'failed') {
+        return 'failed';
+    }
+    if (entry.status === 'skipped') {
+        return 'skipped';
+    }
+    if (entry.status === 'succeeded') {
+        return isExplicitGuardrailSkip(entry.summary) ? 'skipped' : 'succeeded';
+    }
+    return 'other';
+}
+function isExplicitGuardrailSkip(summary) {
+    const normalized = summary?.toLowerCase() ?? '';
+    if (!normalized) {
+        return false;
+    }
+    return (normalized.includes('[spec-guard] skipped') ||
+        normalized.includes('spec-guard skipped') ||
+        normalized.includes('spec guard skipped'));
+}
 function formatGuardrailSummary(counts) {
     if (counts.total === 0) {
         return 'Guardrails: spec-guard command not found.';

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

@@ -53,11 +53,19 @@ export async function runCommandStage(context, hooks = {}) {
     let stderrTruncated = false;
     let collabBuffer = '';
     let collabCount = manifest.collab_tool_calls?.length ?? 0;
+    const manifestCaptureLimit = typeof manifest.collab_tool_calls_max_events === 'number'
+        ? Math.max(0, Math.trunc(manifest.collab_tool_calls_max_events))
+        : null;
+    const hasLegacyUnknownCaptureHistory = manifestCaptureLimit === null && collabCount > 0;
+    const runCollabCaptureLimit = manifestCaptureLimit ?? Math.max(0, MAX_COLLAB_TOOL_CALLS);
+    if (!hasLegacyUnknownCaptureHistory) {
+        manifest.collab_tool_calls_max_events = runCollabCaptureLimit;
+    }
     const recordCollabToolCall = (record) => {
-        if (MAX_COLLAB_TOOL_CALLS <= 0) {
+        if (runCollabCaptureLimit <= 0) {
             return;
         }
-        if (collabCount >= MAX_COLLAB_TOOL_CALLS) {
+        if (collabCount >= runCollabCaptureLimit) {
             return;
         }
         if (!manifest.collab_tool_calls) {