@kbediako/codex-orchestrator 0.1.37 → 0.2.0

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

@@ -0,0 +1,72 @@
+/* eslint-disable patterns/prefer-logger-over-console */
+import process from 'node:process';
+import { runDoctorCliShell } from './doctorCliShell.js';
+const DEFAULT_DEPENDENCIES = {
+    runDoctorCliShell,
+    getCwd: () => process.cwd()
+};
+export async function runDoctorCliRequestShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const format = resolveOutputFormat(params.flags);
+    const includeUsage = Boolean(params.flags['usage']);
+    const includeCloudPreflight = Boolean(params.flags['cloud-preflight']);
+    const includeIssueLog = Boolean(params.flags['issue-log']);
+    const cloudEnvIdOverride = readStringFlag(params.flags, 'cloud-env-id');
+    const cloudBranchOverride = readStringFlag(params.flags, 'cloud-branch');
+    const issueTitle = readStringFlag(params.flags, 'issue-title');
+    const issueNotes = readStringFlag(params.flags, 'issue-notes');
+    const issueLogPath = readStringFlag(params.flags, 'issue-log-path');
+    if (!includeCloudPreflight && (cloudEnvIdOverride || cloudBranchOverride)) {
+        throw new Error('--cloud-env-id/--cloud-branch require --cloud-preflight.');
+    }
+    if (!includeIssueLog && (issueTitle || issueNotes || issueLogPath)) {
+        throw new Error('--issue-title/--issue-notes/--issue-log-path require --issue-log.');
+    }
+    const wantsApply = Boolean(params.flags['apply']);
+    const apply = Boolean(params.flags['yes']);
+    if (wantsApply && format === 'json') {
+        throw new Error('doctor --apply does not support --format json.');
+    }
+    const windowDays = parseWindowDays(readStringFlag(params.flags, 'window-days'));
+    const taskFilter = readStringFlag(params.flags, 'task') ?? null;
+    await dependencies.runDoctorCliShell({
+        format,
+        includeUsage,
+        includeCloudPreflight,
+        includeIssueLog,
+        cloudEnvIdOverride: cloudEnvIdOverride ?? undefined,
+        cloudBranchOverride: cloudBranchOverride ?? undefined,
+        issueTitle: issueTitle ?? undefined,
+        issueNotes: issueNotes ?? undefined,
+        issueLogPath: issueLogPath ?? undefined,
+        wantsApply,
+        apply,
+        windowDays,
+        taskFilter,
+        repoRoot: dependencies.getCwd()
+    });
+}
+function resolveOutputFormat(flags) {
+    return flags['format'] === 'json' ? 'json' : 'text';
+}
+function readStringFlag(flags, key) {
+    const value = flags[key];
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}
+function parseWindowDays(windowDaysRaw) {
+    if (!windowDaysRaw) {
+        return undefined;
+    }
+    if (!/^\d+$/u.test(windowDaysRaw)) {
+        throw new Error(`Invalid --window-days value '${windowDaysRaw}'. Expected a positive integer.`);
+    }
+    const parsed = Number(windowDaysRaw);
+    if (!Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`Invalid --window-days value '${windowDaysRaw}'. Expected a positive integer.`);
+    }
+    return parsed;
+}

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

@@ -0,0 +1,138 @@
+/* eslint-disable patterns/prefer-logger-over-console */
+import { formatDoctorCloudPreflightSummary, formatDoctorSummary, runDoctor, runDoctorCloudPreflight } from './doctor.js';
+import { formatDoctorUsageSummary, runDoctorUsage } from './doctorUsage.js';
+import { formatDoctorIssueLogSummary, writeDoctorIssueLog } from './doctorIssueLog.js';
+import { formatDevtoolsSetupSummary, runDevtoolsSetup } from './devtoolsSetup.js';
+import { formatDelegationSetupSummary, runDelegationSetup } from './delegationSetup.js';
+import { formatSkillsInstallSummary, installSkills } from './skills.js';
+const DEFAULT_DEPENDENCIES = {
+    runDoctor,
+    runDoctorUsage,
+    runDoctorCloudPreflight,
+    writeDoctorIssueLog,
+    runDelegationSetup,
+    runDevtoolsSetup,
+    installSkills,
+    formatDoctorSummary,
+    formatDoctorUsageSummary,
+    formatDoctorCloudPreflightSummary,
+    formatDoctorIssueLogSummary,
+    formatSkillsInstallSummary,
+    formatDelegationSetupSummary,
+    formatDevtoolsSetupSummary,
+    log: (line) => console.log(line)
+};
+export async function runDoctorCliShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    const doctorResult = dependencies.runDoctor(params.repoRoot);
+    const usageResult = params.includeUsage
+        ? await dependencies.runDoctorUsage({ windowDays: params.windowDays, taskFilter: params.taskFilter })
+        : null;
+    const cloudPreflightResult = params.includeCloudPreflight
+        ? await dependencies.runDoctorCloudPreflight({
+            cwd: params.repoRoot,
+            environmentId: params.cloudEnvIdOverride,
+            branch: params.cloudBranchOverride,
+            taskId: params.taskFilter
+        })
+        : null;
+    const issueLogResult = params.includeIssueLog
+        ? await dependencies.writeDoctorIssueLog({
+            doctor: doctorResult,
+            usage: usageResult,
+            cloudPreflight: cloudPreflightResult,
+            issueTitle: params.issueTitle,
+            issueNotes: params.issueNotes,
+            issueLogPath: params.issueLogPath,
+            taskFilter: params.taskFilter
+        })
+        : null;
+    if (params.format === 'json') {
+        const payload = { ...doctorResult };
+        if (usageResult) {
+            payload.usage = usageResult;
+        }
+        if (cloudPreflightResult) {
+            payload.cloud_preflight = cloudPreflightResult;
+        }
+        if (issueLogResult) {
+            payload.issue_log = issueLogResult;
+        }
+        dependencies.log(JSON.stringify(payload, null, 2));
+        return;
+    }
+    for (const line of dependencies.formatDoctorSummary(doctorResult)) {
+        dependencies.log(line);
+    }
+    if (usageResult) {
+        for (const line of dependencies.formatDoctorUsageSummary(usageResult)) {
+            dependencies.log(line);
+        }
+    }
+    if (cloudPreflightResult) {
+        for (const line of dependencies.formatDoctorCloudPreflightSummary(cloudPreflightResult)) {
+            dependencies.log(line);
+        }
+    }
+    if (issueLogResult) {
+        for (const line of dependencies.formatDoctorIssueLogSummary(issueLogResult)) {
+            dependencies.log(line);
+        }
+    }
+    if (!params.wantsApply) {
+        return;
+    }
+    const delegationPlan = await dependencies.runDelegationSetup({ repoRoot: params.repoRoot });
+    const devtoolsPlan = await dependencies.runDevtoolsSetup();
+    const needsDelegation = !delegationPlan.readiness.configured;
+    const needsDevtoolsSkill = devtoolsPlan.readiness.skill.status !== 'ok';
+    const devtoolsConfigStatus = devtoolsPlan.readiness.config.status;
+    const needsDevtoolsConfig = devtoolsConfigStatus === 'missing';
+    const hasInvalidDevtoolsConfig = devtoolsConfigStatus === 'invalid';
+    if (!needsDelegation && !needsDevtoolsSkill && !needsDevtoolsConfig && !hasInvalidDevtoolsConfig) {
+        dependencies.log('Doctor apply: nothing to do.');
+        return;
+    }
+    dependencies.log('Doctor apply plan:');
+    if (needsDevtoolsSkill) {
+        dependencies.log('- Install skill: chrome-devtools (codex-orchestrator skills install --only chrome-devtools)');
+    }
+    if (hasInvalidDevtoolsConfig) {
+        dependencies.log(`- DevTools MCP config is invalid: ${devtoolsPlan.readiness.config.path} (fix config.toml then rerun doctor --apply)`);
+    }
+    if (needsDevtoolsConfig) {
+        dependencies.log('- Configure DevTools MCP: codex-orchestrator devtools setup --yes');
+    }
+    if (needsDelegation) {
+        dependencies.log('- Configure delegation MCP: codex-orchestrator delegation setup --yes');
+    }
+    if (!params.apply) {
+        dependencies.log('Run with --apply --yes to apply these fixes.');
+        return;
+    }
+    if (needsDevtoolsSkill) {
+        const skills = await dependencies.installSkills({ only: ['chrome-devtools'] });
+        for (const line of dependencies.formatSkillsInstallSummary(skills)) {
+            dependencies.log(line);
+        }
+    }
+    if (needsDelegation) {
+        const delegation = await dependencies.runDelegationSetup({ apply: true, repoRoot: params.repoRoot });
+        for (const line of dependencies.formatDelegationSetupSummary(delegation)) {
+            dependencies.log(line);
+        }
+    }
+    if (hasInvalidDevtoolsConfig) {
+        dependencies.log(`DevTools setup: skipped (config.toml is invalid: ${devtoolsPlan.readiness.config.path}). Fix it and rerun doctor --apply --yes.`);
+    }
+    else if (needsDevtoolsConfig) {
+        const devtools = await dependencies.runDevtoolsSetup({ apply: true });
+        for (const line of dependencies.formatDevtoolsSetupSummary(devtools)) {
+            dependencies.log(line);
+        }
+    }
+    const doctorAfter = dependencies.runDoctor(params.repoRoot);
+    for (const line of dependencies.formatDoctorSummary(doctorAfter)) {
+        dependencies.log(line);
+    }
+}

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

@@ -31,6 +31,9 @@ export async function runDoctorUsage(options = {}) {
     const collabByEventType = {};
     const collabTools = new Map();
     const collabCaptureDisabled = String(process.env.CODEX_ORCHESTRATOR_COLLAB_MAX_EVENTS ?? '').trim() === '0';
+    let collabSpawnForkContextTrue = 0;
+    let collabSpawnForkContextFalse = 0;
+    let collabSpawnForkContextUnknown = 0;
     let collabRunsWithUnclosedSpawnAgents = 0;
     let collabUnclosedSpawnAgents = 0;
     let collabRunsWithSpawnThreadLimitFailures = 0;
@@ -133,8 +136,8 @@ export async function runDoctorUsage(options = {}) {
             if (collabEventsPossiblyTruncated) {
                 collabRunsWithPotentiallyTruncatedToolCalls += 1;
             }
-            const spawnedAgents = new Set();
-            const closedAgents = new Set();
+            const spawnedAgentAliases = [];
+            const closedSpawnIndexes = new Set();
             const failedSpawnIds = new Set();
             let failedSpawnCalls = 0;
             if (typeof manifest.task_id === 'string' && manifest.task_id) {
@@ -144,11 +147,7 @@ export async function runDoctorUsage(options = {}) {
                 const tool = typeof entry?.tool === 'string' && entry.tool ? entry.tool : 'unknown';
                 const status = typeof entry?.status === 'string' && entry.status ? entry.status : 'unknown';
                 const eventType = typeof entry?.event_type === 'string' && entry.event_type ? entry.event_type : 'unknown';
-                const receiverThreadIds = Array.isArray(entry?.receiver_thread_ids)
-                    ? entry.receiver_thread_ids
-                        .map((id) => (typeof id === 'string' ? id.trim() : ''))
-                        .filter((id) => id.length > 0)
-                    : [];
+                const receiverIdentifierGroups = resolveCollabReceiverIdentifierGroups(entry);
                 const completedEventWithoutStatus = eventType === 'item.completed' && status !== 'failed';
                 const isCompleted = status === 'completed' || completedEventWithoutStatus;
                 const isFailed = status === 'failed';
@@ -160,6 +159,15 @@ export async function runDoctorUsage(options = {}) {
                     continue;
                 }
                 if (tool === 'spawn_agent') {
+                    if (entry?.fork_context === true) {
+                        collabSpawnForkContextTrue += 1;
+                    }
+                    else if (entry?.fork_context === false) {
+                        collabSpawnForkContextFalse += 1;
+                    }
+                    else {
+                        collabSpawnForkContextUnknown += 1;
+                    }
                     if (isFailed) {
                         const rawFailedSpawnId = typeof entry?.item_id === 'string' ? entry.item_id.trim() : '';
                         const failedSpawnId = rawFailedSpawnId.length > 0 && rawFailedSpawnId !== 'unknown'
@@ -174,25 +182,34 @@ export async function runDoctorUsage(options = {}) {
                     if (!isCompleted) {
                         continue;
                     }
-                    if (receiverThreadIds.length > 0) {
-                        for (const id of receiverThreadIds) {
-                            spawnedAgents.add(id);
+                    if (receiverIdentifierGroups.length > 0) {
+                        for (const receiverIdentifiers of receiverIdentifierGroups) {
+                            spawnedAgentAliases.push(new Set(receiverIdentifiers));
                         }
                     }
                     else {
-                        const fallbackId = `spawn@${entry?.item_id ?? entryIndex}`;
-                        spawnedAgents.add(fallbackId);
+                        spawnedAgentAliases.push(new Set([`spawn@${entry?.item_id ?? entryIndex}`]));
                     }
                     continue;
                 }
                 if (tool === 'close_agent' && isCompleted) {
-                    for (const id of receiverThreadIds) {
-                        closedAgents.add(id);
+                    if (receiverIdentifierGroups.length === 0) {
+                        continue;
+                    }
+                    for (const receiverIdentifiers of receiverIdentifierGroups) {
+                        for (const [spawnIndex, aliases] of spawnedAgentAliases.entries()) {
+                            if (closedSpawnIndexes.has(spawnIndex)) {
+                                continue;
+                            }
+                            if (collabReceiverGroupMatches(receiverIdentifiers, aliases)) {
+                                closedSpawnIndexes.add(spawnIndex);
+                            }
+                        }
                     }
                 }
             }
             if (collabCaptureLimitKnown && !collabEventsPossiblyTruncated) {
-                const unclosedSpawnAgents = [...spawnedAgents].filter((id) => !closedAgents.has(id));
+                const unclosedSpawnAgents = spawnedAgentAliases.filter((_aliases, spawnIndex) => !closedSpawnIndexes.has(spawnIndex));
                 if (unclosedSpawnAgents.length > 0) {
                     collabRunsWithUnclosedSpawnAgents += 1;
                     collabUnclosedSpawnAgents += unclosedSpawnAgents.length;
@@ -290,6 +307,9 @@ export async function runDoctorUsage(options = {}) {
             by_event_type: collabByEventType,
             top_tools: collabTopTools,
             capture_disabled: collabCaptureDisabled,
+            spawn_agent_fork_context_true: collabSpawnForkContextTrue,
+            spawn_agent_fork_context_false: collabSpawnForkContextFalse,
+            spawn_agent_fork_context_unknown: collabSpawnForkContextUnknown,
             runs_with_unclosed_spawn_agents: collabRunsWithUnclosedSpawnAgents,
             unclosed_spawn_agents: collabUnclosedSpawnAgents,
             runs_with_spawn_thread_limit_failures: collabRunsWithSpawnThreadLimitFailures,
@@ -357,9 +377,10 @@ export function formatDoctorUsageSummary(result) {
     const collabLifecycleUnknownSignal = collabLifecycleUnknownRuns > 0
         ? `, lifecycle_unknown_runs=${collabLifecycleUnknownRuns}`
         : '';
+    const collabForkContextSignal = `, fork_context=${result.collab.spawn_agent_fork_context_true}/${result.collab.spawn_agent_fork_context_false}/${result.collab.spawn_agent_fork_context_unknown}`;
     const collabToolList = formatTopList(result.collab.top_tools.map((entry) => ({ key: entry.tool, value: entry.calls })), 3, 'tools');
     lines.push(`  - collab: ${result.collab.runs_with_tool_calls} (${formatPercent(result.collab.runs_with_tool_calls, result.runs.total)})${collabSuffix}`
-        + `${collabTaskSuffix}, events=${result.collab.total_tool_calls}${collabAvg} (ok=${collabOk}, failed=${collabFailed}${collabLeakSignal}${collabThreadLimitSignal}${collabLifecycleUnknownSignal})${collabToolList}`);
+        + `${collabTaskSuffix}, events=${result.collab.total_tool_calls}${collabAvg} (ok=${collabOk}, failed=${collabFailed}${collabLeakSignal}${collabThreadLimitSignal}${collabLifecycleUnknownSignal}${collabForkContextSignal})${collabToolList}`);
     if (result.delegation.active_top_level_tasks > 0) {
         lines.push(`  - delegation: ${result.delegation.active_with_subagents}/${result.delegation.active_top_level_tasks} top-level tasks have subagent manifests (${result.delegation.total_subagent_manifests} total); child_runs=${result.delegation.total_child_runs} over ${result.delegation.tasks_with_child_runs} tasks`);
     }
@@ -443,6 +464,105 @@ function resolveManifestCollabCaptureLimit(manifest) {
     }
     return Math.trunc(value);
 }
+function resolveCollabReceiverIdentifierGroups(entry) {
+    const receiverThreadIdSlots = normalizeCollabAliasSlots('thread', entry?.receiver_thread_ids);
+    const receiverAgentPathSlots = normalizeCollabAliasSlots('path', entry?.receiver_agent_paths);
+    const receiverAgents = Array.isArray(entry?.receiver_agents) ? entry.receiver_agents : [];
+    const groups = [];
+    const consumedThreadIndexes = new Set();
+    const consumedPathIndexes = new Set();
+    if (receiverAgents.length > 0) {
+        for (const agent of receiverAgents) {
+            const identifiers = dedupeCollabAliases([
+                normalizeCollabAlias('thread', agent?.thread_id),
+                normalizeCollabAlias('path', agent?.agent_path)
+            ]);
+            if (identifiers.length > 0) {
+                groups.push(identifiers);
+                consumeMatchingAliasIndex(receiverThreadIdSlots, identifiers, consumedThreadIndexes);
+                consumeMatchingAliasIndex(receiverAgentPathSlots, identifiers, consumedPathIndexes);
+            }
+        }
+    }
+    const pairCount = Math.max(receiverThreadIdSlots.length, receiverAgentPathSlots.length);
+    for (let index = 0; index < pairCount; index += 1) {
+        if (consumedThreadIndexes.has(index) || consumedPathIndexes.has(index)) {
+            continue;
+        }
+        const receiverThreadId = receiverThreadIdSlots[index] ?? null;
+        const receiverAgentPath = receiverAgentPathSlots[index] ?? null;
+        if (receiverThreadId === null || receiverAgentPath === null) {
+            continue;
+        }
+        const identifiers = dedupeCollabAliases([receiverThreadId, receiverAgentPath]);
+        if (identifiers.length > 0) {
+            const existingGroup = groups.find((group) => group.includes(receiverThreadId));
+            if (existingGroup) {
+                for (const identifier of identifiers) {
+                    if (!existingGroup.includes(identifier)) {
+                        existingGroup.push(identifier);
+                    }
+                }
+            }
+            else {
+                groups.push(identifiers);
+            }
+        }
+        consumedThreadIndexes.add(index);
+        consumedPathIndexes.add(index);
+    }
+    const groupedAliases = new Set(groups.flat());
+    for (const [index, receiverThreadId] of receiverThreadIdSlots.entries()) {
+        if (receiverThreadId !== null && !consumedThreadIndexes.has(index) && !groupedAliases.has(receiverThreadId)) {
+            groups.push([receiverThreadId]);
+            groupedAliases.add(receiverThreadId);
+        }
+    }
+    for (const [index, receiverAgentPath] of receiverAgentPathSlots.entries()) {
+        if (receiverAgentPath !== null && !consumedPathIndexes.has(index) && !groupedAliases.has(receiverAgentPath)) {
+            groups.push([receiverAgentPath]);
+            groupedAliases.add(receiverAgentPath);
+        }
+    }
+    return groups;
+}
+function normalizeCollabAliasSlots(prefix, values) {
+    return Array.isArray(values) ? values.map((value) => normalizeCollabAlias(prefix, value)) : [];
+}
+function normalizeCollabAlias(prefix, value) {
+    if (typeof value !== 'string') {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed ? `${prefix}:${trimmed}` : null;
+}
+function consumeMatchingAliasIndex(slots, aliases, consumedIndexes) {
+    for (const alias of aliases) {
+        const index = slots.findIndex((slotAlias, slotIndex) => slotAlias === alias && !consumedIndexes.has(slotIndex));
+        if (index >= 0) {
+            consumedIndexes.add(index);
+        }
+    }
+}
+function collabReceiverGroupMatches(receiverIdentifiers, aliases) {
+    const threadIdentifiers = receiverIdentifiers.filter((identifier) => identifier.startsWith('thread:'));
+    if (threadIdentifiers.length > 0) {
+        return threadIdentifiers.some((identifier) => aliases.has(identifier));
+    }
+    return receiverIdentifiers.some((identifier) => aliases.has(identifier));
+}
+function dedupeCollabAliases(values) {
+    const seen = new Set();
+    const deduped = [];
+    for (const value of values) {
+        if (!value || seen.has(value)) {
+            continue;
+        }
+        seen.add(value);
+        deduped.push(value);
+    }
+    return deduped;
+}
 function clampInt(value, min, max) {
     const rounded = Math.floor(value);
     if (!Number.isFinite(rounded)) {

package/dist/orchestrator/src/cli/exec/experience.js

@@ -38,16 +38,30 @@ export function framesFromToolMetrics(metrics, representativeEvent) {
         latencyMs: metric.latencyMs
     }));
 }
-export function formatExperienceInjections(experiences, slots) {
+export function formatExperienceInjections(experiences, slots, diagnostics) {
     if (slots <= 0) {
         return [];
     }
+    const selectedMetadata = new Map((diagnostics?.selected ?? []).map((entry) => [entry.id, entry]));
     return experiences.slice(0, slots).map((experience) => {
+        const selected = selectedMetadata.get(experience.id);
         const rewardScore = (experience.reward.gtScore + experience.reward.relativeRank).toFixed(2);
         const statText = experience.toolStats
             .map((stat) => `${stat.tool}: ${stat.tokens}t/${stat.costUsd.toFixed(3)}usd/${Math.round(stat.latencyMs)}ms`)
             .join('; ');
-        return `[exp ${experience.id} | epoch ${experience.epoch ?? 'n/a'} | reward ${rewardScore}] ${experience.summary32} (stats: ${statText})`;
+        const metadataParts = [
+            `exp ${experience.id}`,
+            `epoch ${experience.epoch ?? 'n/a'}`,
+            `reward ${rewardScore}`
+        ];
+        if (selected) {
+            metadataParts.push(`source ${selected.source_kind}:${selected.source_key}`);
+            metadataParts.push(`competitive ${selected.competitive_score.toFixed(2)}`);
+            if (selected.dominance_penalty > 0) {
+                metadataParts.push(`anti-dom ${selected.dominance_penalty.toFixed(2)}`);
+            }
+        }
+        return `[${metadataParts.join(' | ')}] ${experience.summary32} (stats: ${statText})`;
     });
 }
 function buildTrajectorySummary(frames, fallback) {

package/dist/orchestrator/src/cli/exec/summary.js

@@ -2,6 +2,7 @@ import { join } from 'node:path';
 import { relativeToRepo } from '../run/runPaths.js';
 import { writeJsonAtomic } from '../utils/fs.js';
 import { persistManifest } from '../run/manifestPersister.js';
+import { refreshRunMemoryObservability } from '../run/source0.js';
 import { readExecMetadata } from './finalization.js';
 export function createRunSummaryPayload(params) {
     const { env, paths, manifest, runStatus, shellCommand, argv, resultSummary, toolRecord, execEvents, exitCode, signal, notificationTargets, cwd, metrics } = params;
@@ -16,6 +17,7 @@ export function createRunSummaryPayload(params) {
     const persisted = Boolean(execMetadata?.persisted);
     const metadataSandbox = execMetadata?.sandboxState;
     const sandboxState = resultSummary?.sandboxState ?? toolRecord?.sandboxState ?? metadataSandbox ?? 'sandboxed';
+    refreshRunMemoryObservability(manifest);
     return {
         status: runStatus === 'succeeded' ? 'succeeded' : 'failed',
         run: {
@@ -52,6 +54,7 @@ export function createRunSummaryPayload(params) {
         },
         toolRun: toolRecord,
         metrics: metrics ?? undefined,
+        memory: manifest.memory?.observability ?? undefined,
         notifications: {
             targets: notificationTargets,
             delivered: [],

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

@@ -0,0 +1,51 @@
+/* eslint-disable patterns/prefer-logger-over-console */
+import process from 'node:process';
+import { resolveEnvironmentPaths } from '../../../scripts/lib/run-manifests.js';
+import { executeExecCommand } from './exec/command.js';
+import { normalizeEnvironmentPaths, sanitizeTaskId } from './run/environment.js';
+const DEFAULT_DEPENDENCIES = {
+    resolveEnvironmentPaths,
+    normalizeEnvironmentPaths,
+    sanitizeTaskId,
+    executeExecCommand,
+    stdout: process.stdout,
+    stderr: process.stderr,
+    maybeEmitAdoptionHint: async () => undefined,
+    setExitCode: (code) => {
+        process.exitCode = code;
+    }
+};
+export async function runExecCliShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    if (params.commandTokens.length === 0) {
+        throw new Error('exec requires a command to run.');
+    }
+    const isInteractive = dependencies.stdout.isTTY === true && dependencies.stderr.isTTY === true;
+    const outputMode = params.requestedMode ?? (isInteractive ? 'interactive' : 'jsonl');
+    const env = dependencies.normalizeEnvironmentPaths(dependencies.resolveEnvironmentPaths());
+    if (params.taskId) {
+        env.taskId = dependencies.sanitizeTaskId(params.taskId);
+    }
+    const result = await dependencies.executeExecCommand({
+        env,
+        stdout: dependencies.stdout,
+        stderr: dependencies.stderr
+    }, {
+        command: params.commandTokens[0],
+        args: params.commandTokens.slice(1),
+        cwd: params.cwd,
+        outputMode,
+        notifyTargets: params.notifyTargets,
+        otelEndpoint: params.otelEndpoint,
+        jsonPretty: params.jsonPretty
+    });
+    if (result.exitCode !== null) {
+        dependencies.setExitCode(result.exitCode);
+    }
+    else if (result.status !== 'succeeded') {
+        dependencies.setExitCode(1);
+    }
+    if (outputMode === 'interactive') {
+        await dependencies.maybeEmitAdoptionHint(env.taskId);
+    }
+}

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

@@ -0,0 +1,44 @@
+import { runFlowCliShell } from './flowCliShell.js';
+const DEFAULT_DEPENDENCIES = {
+    runFlowCliShell
+};
+export async function runFlowCliRequestShell(params, overrides = {}) {
+    const dependencies = { ...DEFAULT_DEPENDENCIES, ...overrides };
+    if (params.positionals.length > 0) {
+        throw new Error(`flow does not accept positional arguments: ${params.positionals.join(' ')}`);
+    }
+    const format = resolveOutputFormat(params.flags);
+    const executionMode = params.resolveExecutionModeFlag(params.flags);
+    const runtimeMode = params.resolveRuntimeModeFlag(params.flags);
+    params.applyRepoConfigRequiredPolicy(params.flags);
+    const autoIssueLogEnabled = params.resolveAutoIssueLogEnabled(params.flags);
+    await dependencies.runFlowCliShell({
+        orchestrator: params.orchestrator,
+        format,
+        executionMode,
+        runtimeMode,
+        autoIssueLogEnabled,
+        taskId: readStringFlagValue(params.flags['task']),
+        parentRunId: readStringFlagValue(params.flags['parent-run']),
+        approvalPolicy: readStringFlagValue(params.flags['approval-policy']),
+        targetStageId: params.resolveTargetStageId(params.flags),
+        runWithUi: async (action) => await params.runWithUi(format, action),
+        emitRunOutput: params.emitRunOutput,
+        formatIssueLogSummary: params.formatIssueLogSummary,
+        toRunOutputPayload: params.toRunOutputPayload,
+        maybeCaptureAutoIssueLog: params.maybeCaptureAutoIssueLog,
+        resolveTaskFilter: params.resolveTaskFilter,
+        withAutoIssueLogContext: params.withAutoIssueLogContext,
+        maybeEmitRunAdoptionHint: params.maybeEmitRunAdoptionHint
+    });
+}
+function resolveOutputFormat(flags) {
+    return flags['format'] === 'json' ? 'json' : 'text';
+}
+function readStringFlagValue(value) {
+    if (typeof value !== 'string') {
+        return undefined;
+    }
+    const trimmed = value.trim();
+    return trimmed.length > 0 ? trimmed : undefined;
+}