@kbediako/codex-orchestrator 0.1.38 → 0.2.1

package/dist/scripts/lib/review-shell-env-interpreter.js

@@ -0,0 +1,340 @@
+export function createEmptyReviewShellEnvState(initialEnvVarPaths = new Map()) {
+    const shellVars = new Map();
+    for (const [envVar, envPath] of initialEnvVarPaths.entries()) {
+        shellVars.set(envVar, envPath);
+    }
+    return {
+        shellVars,
+        exportedVars: new Set(shellVars.keys()),
+        blockedEnvVars: new Set()
+    };
+}
+export function buildCommandEnvAssignments(shellEnvState, rawTokens, dependencies) {
+    const envAssignments = commandUsesCleanEnvironment(rawTokens, dependencies)
+        ? new Map()
+        : mergeEnvAssignments(shellEnvState.shellVars, new Map());
+    for (const envVar of shellEnvState.blockedEnvVars) {
+        envAssignments.delete(envVar);
+    }
+    return mergeEnvAssignments(envAssignments, collectInlineEnvAssignments(rawTokens, dependencies));
+}
+export function buildNestedShellEnvState(shellEnvState, rawTokens, dependencies) {
+    const blockedEnvVars = buildBlockedEnvVarSet(shellEnvState, rawTokens, dependencies);
+    const usesCleanEnvironment = commandUsesCleanEnvironment(rawTokens, dependencies);
+    const shellVars = new Map();
+    if (!usesCleanEnvironment) {
+        for (const envVar of shellEnvState.exportedVars) {
+            if (blockedEnvVars.has(envVar)) {
+                continue;
+            }
+            const value = shellEnvState.shellVars.get(envVar);
+            if (value !== undefined) {
+                shellVars.set(envVar, value);
+            }
+        }
+    }
+    for (const [key, value] of collectInlineEnvAssignments(rawTokens, dependencies).entries()) {
+        shellVars.set(key, value);
+        blockedEnvVars.delete(key);
+    }
+    return {
+        shellVars,
+        exportedVars: new Set(shellVars.keys()),
+        blockedEnvVars
+    };
+}
+export function updateReviewShellEnvStateForSegment(shellEnvState, rawTokens, dependencies, shellDialect = 'other') {
+    const nextState = cloneReviewShellEnvState(shellEnvState);
+    const leadingAssignments = collectLeadingShellAssignments(rawTokens);
+    const strippedTokens = dependencies.stripLeadingEnvAssignments(rawTokens);
+    if (strippedTokens.length === 0) {
+        for (const [key, value] of leadingAssignments.entries()) {
+            nextState.shellVars.set(key, value);
+            nextState.blockedEnvVars.delete(key);
+        }
+        return nextState;
+    }
+    const tokens = dependencies.unwrapEnvCommandTokens(strippedTokens);
+    if (tokens.length === 0) {
+        return nextState;
+    }
+    const command = dependencies.normalizeCommandToken(tokens[0] ?? '');
+    if (command === 'export') {
+        const exportTokens = tokens.slice(1);
+        const bashLikeUnexportMode = shellDialect === 'bashlike' && exportTokens.includes('-n');
+        if (shellDialect === 'bashlike' && !bashLikeUnexportMode) {
+            applyBashLikeLeadingBareExportAssignments(nextState, exportTokens, leadingAssignments);
+        }
+        applyExportTokensToReviewShellEnvState(nextState, exportTokens, leadingAssignments, dependencies, shellDialect);
+        return nextState;
+    }
+    if (command === 'unset') {
+        applyUnsetTokensToReviewShellEnvState(nextState, tokens.slice(1));
+        return nextState;
+    }
+    return nextState;
+}
+export function collectInlineEnvAssignments(tokens, dependencies) {
+    const assignments = new Map();
+    let index = 0;
+    while (index < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=.*/u.test(tokens[index] ?? '')) {
+        recordInlineEnvAssignment(assignments, tokens[index] ?? '');
+        index += 1;
+    }
+    if (dependencies.normalizeCommandToken(tokens[index] ?? '') !== 'env') {
+        return assignments;
+    }
+    index += 1;
+    while (index < tokens.length) {
+        const token = tokens[index] ?? '';
+        const normalized = token.toLowerCase();
+        if (token === '--') {
+            index += 1;
+            break;
+        }
+        if (/^[A-Za-z_][A-Za-z0-9_]*=.*/u.test(token)) {
+            recordInlineEnvAssignment(assignments, token);
+            index += 1;
+            continue;
+        }
+        if (normalized === '-u' || normalized === '--unset') {
+            index += 2;
+            continue;
+        }
+        if (normalized.startsWith('--unset=')) {
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('-')) {
+            index += 1;
+            continue;
+        }
+        break;
+    }
+    return assignments;
+}
+function cloneReviewShellEnvState(shellEnvState) {
+    return {
+        shellVars: new Map(shellEnvState.shellVars),
+        exportedVars: new Set(shellEnvState.exportedVars),
+        blockedEnvVars: new Set(shellEnvState.blockedEnvVars)
+    };
+}
+function buildBlockedEnvVarSet(shellEnvState, rawTokens, dependencies) {
+    const blockedEnvVars = new Set(shellEnvState.blockedEnvVars);
+    for (const envVar of collectInlineEnvUnsetVars(rawTokens, dependencies)) {
+        blockedEnvVars.add(envVar);
+    }
+    for (const envVar of collectInlineEnvAssignments(rawTokens, dependencies).keys()) {
+        blockedEnvVars.delete(envVar);
+    }
+    return blockedEnvVars;
+}
+function collectLeadingShellAssignments(tokens) {
+    const assignments = new Map();
+    let index = 0;
+    while (index < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=.*/u.test(tokens[index] ?? '')) {
+        recordInlineEnvAssignment(assignments, tokens[index] ?? '');
+        index += 1;
+    }
+    return assignments;
+}
+function applyBashLikeLeadingBareExportAssignments(shellEnvState, tokens, leadingAssignments) {
+    if (leadingAssignments.size === 0) {
+        return;
+    }
+    const bareExportTargets = new Set();
+    for (const token of tokens) {
+        if (!token || token.startsWith('-') || /^[A-Za-z_][A-Za-z0-9_]*=.*/u.test(token)) {
+            continue;
+        }
+        const normalized = token.trim().replace(/^\$/u, '').replace(/[{}]/gu, '').toUpperCase();
+        if (normalized) {
+            bareExportTargets.add(normalized);
+        }
+    }
+    for (const [key, value] of leadingAssignments.entries()) {
+        if (!bareExportTargets.has(key)) {
+            continue;
+        }
+        shellEnvState.shellVars.set(key, value);
+        shellEnvState.exportedVars.add(key);
+        shellEnvState.blockedEnvVars.delete(key);
+    }
+}
+function applyExportTokensToReviewShellEnvState(shellEnvState, tokens, leadingAssignments, dependencies, shellDialect) {
+    let bashLikeExportMode = 'export';
+    for (const token of tokens) {
+        if (!token) {
+            continue;
+        }
+        if (shellDialect === 'bashlike' && token === '-n') {
+            bashLikeExportMode = 'unexport';
+            continue;
+        }
+        if (token === '--') {
+            continue;
+        }
+        if (/^[A-Za-z_][A-Za-z0-9_]*=.*/u.test(token)) {
+            if (bashLikeExportMode === 'unexport') {
+                continue;
+            }
+            const assignments = new Map();
+            recordInlineEnvAssignment(assignments, token);
+            for (const [key, value] of assignments.entries()) {
+                let resolvedValue = value;
+                const normalizedInlineEnvVar = dependencies.normalizeAuditMetaSurfaceEnvVar(value);
+                if (normalizedInlineEnvVar) {
+                    const expansionEnv = new Map(shellEnvState.shellVars);
+                    for (const [leadingKey, leadingValue] of leadingAssignments.entries()) {
+                        if (leadingKey !== key) {
+                            expansionEnv.set(leadingKey, leadingValue);
+                        }
+                    }
+                    const currentValue = expansionEnv.get(normalizedInlineEnvVar);
+                    resolvedValue = currentValue ?? '';
+                }
+                shellEnvState.shellVars.set(key, resolvedValue);
+                shellEnvState.exportedVars.add(key);
+                shellEnvState.blockedEnvVars.delete(key);
+            }
+            continue;
+        }
+        if (token.startsWith('-')) {
+            continue;
+        }
+        const normalized = token.trim().replace(/^\$/u, '').replace(/[{}]/gu, '').toUpperCase();
+        if (!normalized) {
+            continue;
+        }
+        if (bashLikeExportMode === 'unexport') {
+            shellEnvState.exportedVars.delete(normalized);
+            continue;
+        }
+        if (shellEnvState.shellVars.has(normalized)) {
+            shellEnvState.exportedVars.add(normalized);
+            shellEnvState.blockedEnvVars.delete(normalized);
+        }
+    }
+}
+function applyUnsetTokensToReviewShellEnvState(shellEnvState, tokens) {
+    for (const token of tokens) {
+        if (!token || token.startsWith('-')) {
+            continue;
+        }
+        const normalized = token.trim().replace(/^\$/u, '').replace(/[{}]/gu, '').toUpperCase();
+        if (!normalized) {
+            continue;
+        }
+        shellEnvState.shellVars.delete(normalized);
+        shellEnvState.exportedVars.delete(normalized);
+        shellEnvState.blockedEnvVars.add(normalized);
+    }
+}
+function commandUsesCleanEnvironment(tokens, dependencies) {
+    let index = 0;
+    while (index < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=.*/u.test(tokens[index] ?? '')) {
+        index += 1;
+    }
+    if (dependencies.normalizeCommandToken(tokens[index] ?? '') !== 'env') {
+        return false;
+    }
+    index += 1;
+    while (index < tokens.length) {
+        const token = tokens[index] ?? '';
+        const normalized = token.toLowerCase();
+        if (token === '--') {
+            return false;
+        }
+        if (/^[A-Za-z_][A-Za-z0-9_]*=.*/u.test(token)) {
+            index += 1;
+            continue;
+        }
+        if (normalized === '-i' || normalized === '--ignore-environment') {
+            return true;
+        }
+        if ((normalized === '-u' || normalized === '--unset') && index + 1 < tokens.length) {
+            index += 2;
+            continue;
+        }
+        if (normalized.startsWith('--unset=')) {
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('-')) {
+            index += 1;
+            continue;
+        }
+        return false;
+    }
+    return false;
+}
+function collectInlineEnvUnsetVars(tokens, dependencies) {
+    const unsetVars = new Set();
+    let index = 0;
+    while (index < tokens.length && /^[A-Za-z_][A-Za-z0-9_]*=.*/u.test(tokens[index] ?? '')) {
+        index += 1;
+    }
+    if (dependencies.normalizeCommandToken(tokens[index] ?? '') !== 'env') {
+        return unsetVars;
+    }
+    index += 1;
+    while (index < tokens.length) {
+        const token = tokens[index] ?? '';
+        const normalized = token.toLowerCase();
+        if (token === '--') {
+            index += 1;
+            break;
+        }
+        if (/^[A-Za-z_][A-Za-z0-9_]*=.*/u.test(token)) {
+            index += 1;
+            continue;
+        }
+        if ((normalized === '-u' || normalized === '--unset') && index + 1 < tokens.length) {
+            const envVar = tokens[index + 1]?.trim().replace(/^\$/u, '').replace(/[{}]/gu, '').toUpperCase();
+            if (envVar) {
+                unsetVars.add(envVar);
+            }
+            index += 2;
+            continue;
+        }
+        if (normalized.startsWith('--unset=')) {
+            const envVar = normalized
+                .slice('--unset='.length)
+                .trim()
+                .replace(/^\$/u, '')
+                .replace(/[{}]/gu, '')
+                .toUpperCase();
+            if (envVar) {
+                unsetVars.add(envVar);
+            }
+            index += 1;
+            continue;
+        }
+        if (token.startsWith('-')) {
+            index += 1;
+            continue;
+        }
+        break;
+    }
+    return unsetVars;
+}
+function recordInlineEnvAssignment(assignments, token) {
+    const separatorIndex = token.indexOf('=');
+    if (separatorIndex <= 0) {
+        return;
+    }
+    const key = token.slice(0, separatorIndex).trim().toUpperCase();
+    const value = token.slice(separatorIndex + 1).trim();
+    if (!key || !value) {
+        return;
+    }
+    assignments.set(key, value);
+}
+function mergeEnvAssignments(inheritedEnvAssignments, nextEnvAssignments) {
+    const merged = new Map(inheritedEnvAssignments);
+    for (const [key, value] of nextEnvAssignments.entries()) {
+        merged.set(key, value);
+    }
+    return merged;
+}

package/dist/scripts/lib/run-manifests.js

@@ -1,39 +1,191 @@
 import { access, readdir } from 'node:fs/promises';
-import { isAbsolute, join, resolve } from 'node:path';
+import { existsSync } from 'node:fs';
+import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path';
 import process from 'node:process';
 const DEFAULT_TASK_ID = '0101';
 const DEFAULT_RUN_LAYOUT = 'cli';
-function resolveRepoRoot() {
-    const configured = process.env.CODEX_ORCHESTRATOR_ROOT;
+const PROVIDER_WORKSPACE_ROOT_DIRNAME = '.workspaces';
+const PROVIDER_LINEAR_WORKER_PIPELINE_ID = 'provider-linear-worker';
+const PRESERVE_PROVIDER_ARTIFACT_ROOTS_ENV = 'CODEX_ORCHESTRATOR_PRESERVE_PROVIDER_ARTIFACT_ROOTS';
+function resolveConfiguredPath(configured, cwd) {
+    if (isAbsolute(configured)) {
+        return resolve(configured);
+    }
+    return resolve(cwd, configured);
+}
+function normalizeTaskId(value) { return typeof value === 'string' && value.trim().length > 0 ? value.trim() : null; }
+function resolveConfiguredTaskId(env) { return normalizeTaskId(env.MCP_RUNNER_TASK_ID) ?? normalizeTaskId(env.CODEX_ORCHESTRATOR_TASK_ID) ?? normalizeTaskId(env.TASK); }
+function resolveProviderTaskId(env, cwd) { const cwdRoot = resolve(cwd), cwdTask = basename(dirname(cwdRoot)) === PROVIDER_WORKSPACE_ROOT_DIRNAME ? basename(cwdRoot) : null; return cwdTask && [normalizeTaskId(env.CODEX_ORCHESTRATOR_TASK_ID), normalizeTaskId(env.MCP_RUNNER_TASK_ID), normalizeTaskId(env.TASK)].includes(cwdTask) ? cwdTask : resolveConfiguredTaskId(env); }
+function isProviderIssueWorkspaceRootForTask(candidate, taskId) {
+    return (typeof candidate === 'string' &&
+        candidate.length > 0 &&
+        basename(candidate) === taskId &&
+        basename(dirname(candidate)) === PROVIDER_WORKSPACE_ROOT_DIRNAME);
+}
+function providerIssueWorkspaceOverrideForCwd(configuredRoot, env, cwd) {
+    if (env.CODEX_ORCHESTRATOR_PIPELINE_ID !== PROVIDER_LINEAR_WORKER_PIPELINE_ID) {
+        return null;
+    }
+    const taskId = resolveProviderTaskId(env, cwd);
+    if (!taskId) {
+        return null;
+    }
+    const resolvedCwd = resolve(cwd);
+    if (!isProviderIssueWorkspaceRootForTask(resolvedCwd, taskId)) {
+        return null;
+    }
+    const sharedRoot = dirname(dirname(resolvedCwd));
+    return sharedRoot === configuredRoot ? resolvedCwd : null;
+}
+function resolveRepoRoot(env, cwd) {
+    const configured = env.CODEX_ORCHESTRATOR_ROOT;
     if (!configured) {
-        return process.cwd();
+        return cwd;
     }
-    if (isAbsolute(configured)) {
-        return configured;
+    const configuredRoot = resolveConfiguredPath(configured, cwd);
+    return providerIssueWorkspaceOverrideForCwd(configuredRoot, env, cwd) ?? configuredRoot;
+}
+function resolveProviderSharedRootForIssueWorkspace(repoRoot, env, cwd) {
+    const taskId = resolveProviderTaskId(env, repoRoot);
+    if (!taskId || !isProviderIssueWorkspaceRootForTask(repoRoot, taskId)) {
+        return null;
     }
-    return resolve(process.cwd(), configured);
+    const configured = env.CODEX_ORCHESTRATOR_ROOT;
+    if (!configured) {
+        return null;
+    }
+    const configuredRoot = resolveConfiguredPath(configured, cwd);
+    const sharedRoot = dirname(dirname(repoRoot));
+    return configuredRoot === sharedRoot ? sharedRoot : null;
 }
-function resolveRunsDir(repoRoot) {
-    const configured = process.env.CODEX_ORCHESTRATOR_RUNS_DIR || '.runs';
-    if (isAbsolute(configured)) {
-        return configured;
+function isPathWithinRoot(root, candidate) {
+    const relativePath = relative(root, candidate);
+    return (relativePath === '' ||
+        (!relativePath.startsWith('..') &&
+            !relativePath.startsWith(`..${sep}`) &&
+            !isAbsolute(relativePath)));
+}
+function firstPathSegment(relativePath) {
+    return relativePath.split(sep).filter((segment) => segment.length > 0)[0] ?? '';
+}
+function isDefaultRunsLayoutSegment(segment) {
+    return segment === '.runs' || segment === 'runs';
+}
+function resolveConfiguredArtifactRoot(baseRoot, configured, fallbackDirname) {
+    if (!configured) {
+        return resolve(baseRoot, fallbackDirname);
     }
-    return resolve(repoRoot, configured);
+    return isAbsolute(configured) ? resolve(configured) : resolve(baseRoot, configured);
 }
-function resolveOutDir(repoRoot) {
-    const configured = process.env.CODEX_ORCHESTRATOR_OUT_DIR || 'out';
-    if (isAbsolute(configured)) {
-        return configured;
+function resolveWorkspaceArtifactRootForSharedRoot(repoRoot, sharedRoot, sharedArtifactRoot, fallbackDirname, allowCustomCounterpart = false) {
+    if (!sharedRoot || !isPathWithinRoot(sharedRoot, sharedArtifactRoot)) {
+        return null;
     }
-    return resolve(repoRoot, configured);
+    const relativeArtifactRoot = relative(sharedRoot, sharedArtifactRoot);
+    const firstSegment = firstPathSegment(relativeArtifactRoot);
+    if ((fallbackDirname === '.runs' && isDefaultRunsLayoutSegment(firstSegment)) ||
+        firstSegment === fallbackDirname ||
+        allowCustomCounterpart) {
+        return resolve(repoRoot, relativeArtifactRoot);
+    }
+    return null;
 }
-export function resolveEnvironmentPaths() {
-    const repoRoot = resolveRepoRoot();
-    const runsRoot = resolveRunsDir(repoRoot);
-    const outRoot = resolveOutDir(repoRoot);
-    const taskId = process.env.MCP_RUNNER_TASK_ID ?? DEFAULT_TASK_ID;
+function resolveProviderWorkspaceManifestCounterpartPath(repoRoot, env, cwd) {
+    const manifestPath = env.CODEX_ORCHESTRATOR_MANIFEST_PATH || env.MANIFEST;
+    if (!manifestPath) {
+        return null;
+    }
+    const inheritedSharedRoot = resolveProviderSharedRootForIssueWorkspace(repoRoot, env, cwd);
+    const sharedRoot = dirname(dirname(repoRoot));
+    const resolvedManifestPath = resolveConfiguredPath(manifestPath, inheritedSharedRoot ?? repoRoot);
+    if (isPathWithinRoot(repoRoot, resolvedManifestPath)) {
+        return resolvedManifestPath;
+    }
+    const sharedRunsRoot = resolveConfiguredArtifactRoot(inheritedSharedRoot ?? sharedRoot, env.CODEX_ORCHESTRATOR_RUNS_DIR || '.runs', '.runs');
+    if (!isPathWithinRoot(sharedRunsRoot, resolvedManifestPath)) {
+        return null;
+    }
+    const workspaceRunsRoot = resolveWorkspaceArtifactRootForSharedRoot(repoRoot, sharedRoot, sharedRunsRoot, '.runs', true);
+    if (!workspaceRunsRoot) {
+        return null;
+    }
+    const workspaceManifestPath = resolve(workspaceRunsRoot, relative(sharedRunsRoot, resolvedManifestPath));
+    return existsSync(workspaceManifestPath) ? workspaceManifestPath : null;
+}
+function shouldScopeProviderArtifactDirs(repoRoot, env, cwd) {
+    if (env.CODEX_ORCHESTRATOR_PIPELINE_ID !== PROVIDER_LINEAR_WORKER_PIPELINE_ID) {
+        return false;
+    }
+    const taskId = resolveProviderTaskId(env, repoRoot);
+    if (!taskId || !isProviderIssueWorkspaceRootForTask(repoRoot, taskId)) {
+        return false;
+    }
+    if (env[PRESERVE_PROVIDER_ARTIFACT_ROOTS_ENV] === '1' &&
+        !providerWorkspaceManifestCounterpartExists(repoRoot, env, cwd)) {
+        return false;
+    }
+    return true;
+}
+function providerWorkspaceManifestCounterpartExists(repoRoot, env, cwd) {
+    const manifestPath = env.CODEX_ORCHESTRATOR_MANIFEST_PATH || env.MANIFEST;
+    if (!manifestPath) {
+        return true;
+    }
+    const counterpartPath = resolveProviderWorkspaceManifestCounterpartPath(repoRoot, env, cwd);
+    if (counterpartPath) {
+        return true;
+    }
+    const inheritedSharedRoot = resolveProviderSharedRootForIssueWorkspace(repoRoot, env, cwd);
+    const sharedRoot = dirname(dirname(repoRoot));
+    const resolvedManifestPath = resolveConfiguredPath(manifestPath, inheritedSharedRoot ?? repoRoot);
+    if (isPathWithinRoot(repoRoot, resolvedManifestPath)) {
+        return true;
+    }
+    const sharedRunsRoot = resolveConfiguredArtifactRoot(inheritedSharedRoot ?? sharedRoot, env.CODEX_ORCHESTRATOR_RUNS_DIR || '.runs', '.runs');
+    if (!isPathWithinRoot(sharedRunsRoot, resolvedManifestPath)) {
+        return false;
+    }
+    return false;
+}
+function resolveArtifactDir(repoRoot, configured, fallbackDirname, scopeToRepoRoot, baseRoot = repoRoot, hasProviderWorkspaceManifestCounterpart = false, sharedRootForCounterpart = baseRoot) {
+    const relativeBaseRoot = scopeToRepoRoot ? repoRoot : baseRoot;
+    const fallback = resolve(relativeBaseRoot, fallbackDirname);
+    if (!configured) {
+        return fallback;
+    }
+    const candidate = scopeToRepoRoot && !isAbsolute(configured)
+        ? resolve(repoRoot, configured)
+        : resolveConfiguredArtifactRoot(baseRoot, configured, fallbackDirname);
+    if (scopeToRepoRoot && !isPathWithinRoot(repoRoot, candidate)) {
+        const workspaceArtifactRoot = resolveWorkspaceArtifactRootForSharedRoot(repoRoot, sharedRootForCounterpart, candidate, fallbackDirname, hasProviderWorkspaceManifestCounterpart);
+        if (workspaceArtifactRoot) {
+            return workspaceArtifactRoot;
+        }
+    }
+    return candidate;
+}
+function resolveRunsDir(repoRoot, env, scopeToRepoRoot, baseRoot = repoRoot, hasProviderWorkspaceManifestCounterpart = false, sharedRootForCounterpart = baseRoot) {
+    return resolveArtifactDir(repoRoot, env.CODEX_ORCHESTRATOR_RUNS_DIR || '.runs', '.runs', scopeToRepoRoot, baseRoot, hasProviderWorkspaceManifestCounterpart, sharedRootForCounterpart);
+}
+function resolveOutDir(repoRoot, env, scopeToRepoRoot, baseRoot = repoRoot, hasProviderWorkspaceManifestCounterpart = false, sharedRootForCounterpart = baseRoot) {
+    return resolveArtifactDir(repoRoot, env.CODEX_ORCHESTRATOR_OUT_DIR || 'out', 'out', scopeToRepoRoot, baseRoot, hasProviderWorkspaceManifestCounterpart, sharedRootForCounterpart);
+}
+export function resolveEnvironmentPathsForProcess(env = process.env, cwd = process.cwd()) {
+    const repoRoot = resolveRepoRoot(env, cwd);
+    const providerSharedRoot = resolveProviderSharedRootForIssueWorkspace(repoRoot, env, cwd);
+    const providerWorkspaceManifestCounterpartPath = resolveProviderWorkspaceManifestCounterpartPath(repoRoot, env, cwd);
+    const scopeProviderArtifacts = shouldScopeProviderArtifactDirs(repoRoot, env, cwd);
+    const artifactBaseRoot = providerSharedRoot ?? repoRoot;
+    const sharedRootForCounterpart = providerSharedRoot ?? dirname(dirname(repoRoot));
+    const hasProviderWorkspaceManifestCounterpart = Boolean(providerWorkspaceManifestCounterpartPath);
+    const runsRoot = resolveRunsDir(repoRoot, env, scopeProviderArtifacts, artifactBaseRoot, hasProviderWorkspaceManifestCounterpart, sharedRootForCounterpart);
+    const outRoot = resolveOutDir(repoRoot, env, scopeProviderArtifacts, artifactBaseRoot, hasProviderWorkspaceManifestCounterpart, sharedRootForCounterpart);
+    const taskId = (env.CODEX_ORCHESTRATOR_PIPELINE_ID === PROVIDER_LINEAR_WORKER_PIPELINE_ID ? resolveProviderTaskId(env, repoRoot) : resolveConfiguredTaskId(env)) ?? DEFAULT_TASK_ID;
     return { repoRoot, runsRoot, outRoot, taskId };
 }
+export function resolveEnvironmentPaths() {
+    return resolveEnvironmentPathsForProcess(process.env, process.cwd());
+}
 export function resolveRunDir(options) {
     const { runsRoot, taskId, runId, layout = DEFAULT_RUN_LAYOUT } = options ?? {};
     if (!runsRoot || !taskId || !runId) {
@@ -88,9 +240,9 @@ export function pickLatestRunId(runIds) {
 }
 export async function collectManifests(runsDir, taskFilter) {
     const results = [];
-    let taskIds = [];
+    let taskEntries = [];
     try {
-        taskIds = await readdir(runsDir);
+        taskEntries = await readdir(runsDir, { withFileTypes: true });
     }
     catch (error) {
         if (error?.code === 'ENOENT') {
@@ -98,7 +250,11 @@ export async function collectManifests(runsDir, taskFilter) {
         }
         throw error;
     }
-    for (const taskId of taskIds) {
+    for (const taskEntry of taskEntries) {
+        if (!taskEntry.isDirectory()) {
+            continue;
+        }
+        const taskId = taskEntry.name;
         if (taskFilter && taskFilter !== taskId) {
             continue;
         }
@@ -106,26 +262,26 @@ export async function collectManifests(runsDir, taskFilter) {
         const cliPath = join(taskPath, 'cli');
         const legacyPath = taskPath;
         const candidates = [];
-        try {
-            const cliRunIds = await readdir(cliPath);
+        const cliRunIds = await listDirectories(cliPath);
+        if (cliRunIds.length > 0) {
             candidates.push({ root: cliPath, runIds: cliRunIds });
         }
-        catch {
-            // Ignore missing CLI directory; fall back to legacy layout.
-        }
         if (candidates.length === 0) {
-            try {
-                const legacyRunIds = await readdir(legacyPath);
+            const legacyRunIds = (await listDirectories(legacyPath)).filter((name) => name !== 'cli');
+            if (legacyRunIds.length > 0) {
                 candidates.push({ root: legacyPath, runIds: legacyRunIds });
             }
-            catch {
-                continue;
-            }
         }
         for (const candidate of candidates) {
             for (const runId of candidate.runIds) {
                 const manifestPath = join(candidate.root, runId, 'manifest.json');
-                results.push(manifestPath);
+                try {
+                    await access(manifestPath);
+                    results.push(manifestPath);
+                }
+                catch {
+                    // Only return manifest paths that exist on disk.
+                }
             }
         }
     }