@kbediako/codex-orchestrator 0.1.1 → 0.1.3

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

@@ -1,8 +1,12 @@
 import process from 'node:process';
-import { loadUserConfig } from '../config/userConfig.js';
+import { loadPackageConfig, loadUserConfig } from '../config/userConfig.js';
 import { resolvePipeline } from '../pipelines/index.js';
 import { loadDesignConfig, shouldActivateDesignPipeline, designPipelineId } from '../../../../packages/shared/config/index.js';
 import { logger } from '../../logger.js';
+const DEVTOOLS_PIPELINE_ALIASES = new Map([
+    ['implementation-gate-devtools', 'implementation-gate'],
+    ['frontend-testing-devtools', 'frontend-testing']
+]);
 export class PipelineResolver {
     async loadDesignConfig(rootDir) {
         const designConfig = await loadDesignConfig({ rootDir });
@@ -19,9 +23,15 @@ export class PipelineResolver {
         logger.info(`PipelineResolver.resolve loaded design config from ${designConfig.path}`);
         const userConfig = await loadUserConfig(env);
         logger.info(`PipelineResolver.resolve loaded user config`);
-        const requestedPipelineId = options.pipelineId ??
+        const pipelineCandidate = options.pipelineId ??
             (shouldActivateDesignPipeline(designConfig) ? designPipelineId(designConfig) : undefined);
+        const resolvedAlias = this.resolvePipelineAlias(pipelineCandidate);
+        const requestedPipelineId = resolvedAlias.pipelineId;
         const envOverrides = this.resolveDesignEnvOverrides(designConfig, requestedPipelineId);
+        if (resolvedAlias.devtoolsRequested) {
+            envOverrides.CODEX_REVIEW_DEVTOOLS = '1';
+            logger.warn(`[pipeline] ${resolvedAlias.aliasId} is deprecated; use ${requestedPipelineId} with CODEX_REVIEW_DEVTOOLS=1.`);
+        }
         try {
             const { pipeline, source } = resolvePipeline(env, {
                 pipelineId: requestedPipelineId,
@@ -31,6 +41,17 @@ export class PipelineResolver {
             return { pipeline, userConfig, designConfig, source, envOverrides };
         }
         catch (error) {
+            if (requestedPipelineId === 'rlm' && userConfig?.source === 'repo') {
+                const packageConfig = await loadPackageConfig(env);
+                if (packageConfig) {
+                    const { pipeline, source } = resolvePipeline(env, {
+                        pipelineId: requestedPipelineId,
+                        config: packageConfig
+                    });
+                    logger.info(`PipelineResolver.resolve selected package pipeline ${pipeline.id}`);
+                    return { pipeline, userConfig: packageConfig, designConfig, source, envOverrides };
+                }
+            }
             logger.error(`PipelineResolver.resolve failed for ${requestedPipelineId ?? '<default>'}: ${error.message}`);
             throw error;
         }
@@ -44,4 +65,14 @@ export class PipelineResolver {
         }
         return envOverrides;
     }
+    resolvePipelineAlias(pipelineId) {
+        if (!pipelineId) {
+            return { pipelineId, devtoolsRequested: false };
+        }
+        const target = DEVTOOLS_PIPELINE_ALIASES.get(pipelineId);
+        if (!target) {
+            return { pipelineId, devtoolsRequested: false };
+        }
+        return { pipelineId: target, devtoolsRequested: true, aliasId: pipelineId };
+    }
 }

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

@@ -62,11 +62,17 @@ export async function prepareRun(options) {
         planPreview
     };
 }
-export function resolvePipelineForResume(env, manifest, config) {
+export function resolvePipelineForResume(env, manifest, config, fallbackConfig = null) {
     const existing = findPipeline(config ?? null, manifest.pipeline_id);
     if (existing) {
         return existing;
     }
+    if (manifest.pipeline_id === 'rlm' && fallbackConfig) {
+        const fallback = findPipeline(fallbackConfig, manifest.pipeline_id);
+        if (fallback) {
+            return fallback;
+        }
+    }
     const { pipeline } = resolvePipeline(env, { pipelineId: manifest.pipeline_id, config });
     return pipeline;
 }

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

@@ -1,6 +1,6 @@
 import { sanitizeTaskId } from '../run/environment.js';
 import { persistManifest } from '../run/manifestPersister.js';
-import { buildSchedulerRunSummary, createSchedulerPlan, finalizeSchedulerPlan, serializeSchedulerPlan } from '../../scheduler/index.js';
+import { buildSchedulerRunSummary, createSchedulerPlan, finalizeSchedulerPlan, serializeSchedulerPlan } from '../../scheduler/plan.js';
 import { isoTimestamp } from '../utils/time.js';
 export class SchedulerService {
     now;

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

@@ -1,5 +1,29 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import process from 'node:process';
 import { EnvUtils } from '../../../../packages/shared/config/env.js';
+export const DEVTOOLS_SKILL_NAME = 'chrome-devtools';
 export const DEVTOOLS_CONFIG_OVERRIDE = 'mcp_servers.chrome-devtools.enabled=true';
+const DEVTOOLS_CONFIG_FILENAME = 'config.toml';
+const DEVTOOLS_MCP_COMMAND = [
+    'mcp',
+    'add',
+    DEVTOOLS_SKILL_NAME,
+    '--',
+    'npx',
+    '-y',
+    'chrome-devtools-mcp@latest',
+    '--categoryEmulation',
+    '--categoryPerformance',
+    '--categoryNetwork'
+];
+const DEVTOOLS_CONFIG_SNIPPET = [
+    '[mcp_servers.chrome-devtools]',
+    'command = "npx"',
+    'args = ["-y", "chrome-devtools-mcp@latest", "--categoryEmulation", "--categoryPerformance", "--categoryNetwork"]',
+    'enabled = false'
+].join('\n');
 export function isDevtoolsEnabled(env = process.env) {
     const raw = env.CODEX_REVIEW_DEVTOOLS;
     if (!raw) {
@@ -7,12 +31,166 @@ export function isDevtoolsEnabled(env = process.env) {
     }
     return EnvUtils.isTrue(raw.trim().toLowerCase());
 }
+export function resolveCodexHome(env = process.env) {
+    const override = env.CODEX_HOME?.trim();
+    if (override) {
+        return override;
+    }
+    return join(homedir(), '.codex');
+}
+export function resolveCodexConfigPath(env = process.env) {
+    return join(resolveCodexHome(env), DEVTOOLS_CONFIG_FILENAME);
+}
+export function resolveDevtoolsReadiness(env = process.env) {
+    const codexHome = resolveCodexHome(env);
+    const skillPath = join(codexHome, 'skills', DEVTOOLS_SKILL_NAME, 'SKILL.md');
+    const skillInstalled = existsSync(skillPath);
+    const config = inspectDevtoolsConfig(env);
+    const configReady = config.status === 'ok';
+    let status;
+    if (config.status === 'invalid') {
+        status = 'invalid-config';
+    }
+    else if (!skillInstalled && !configReady) {
+        status = 'missing-both';
+    }
+    else if (!skillInstalled) {
+        status = 'missing-skill';
+    }
+    else if (!configReady) {
+        status = 'missing-config';
+    }
+    else {
+        status = 'ok';
+    }
+    return {
+        status,
+        skill: {
+            status: skillInstalled ? 'ok' : 'missing',
+            path: skillPath
+        },
+        config
+    };
+}
+export function buildDevtoolsSetupPlan(env = process.env) {
+    const codexHome = resolveCodexHome(env);
+    const configPath = resolveCodexConfigPath(env);
+    const args = [...DEVTOOLS_MCP_COMMAND];
+    return {
+        codexHome,
+        configPath,
+        command: 'codex',
+        args,
+        commandLine: ['codex', ...args].join(' '),
+        configSnippet: DEVTOOLS_CONFIG_SNIPPET
+    };
+}
 export function resolveCodexCommand(args, env = process.env) {
     if (!isDevtoolsEnabled(env)) {
         return { command: 'codex', args };
     }
+    const readiness = resolveDevtoolsReadiness(env);
+    if (readiness.status !== 'ok') {
+        throw new Error(formatDevtoolsPreflightError(readiness));
+    }
     return {
         command: 'codex',
         args: ['-c', DEVTOOLS_CONFIG_OVERRIDE, ...args]
     };
 }
+export function formatDevtoolsPreflightError(readiness) {
+    const lines = ['DevTools MCP is not ready for this run.'];
+    lines.push(`- Skill: ${readiness.skill.status} (${readiness.skill.path})`);
+    const configStatus = readiness.config.status === 'invalid'
+        ? `invalid (${readiness.config.path})`
+        : `${readiness.config.status} (${readiness.config.path})`;
+    lines.push(`- Config: ${configStatus}`);
+    if (readiness.config.detail) {
+        lines.push(`  detail: ${readiness.config.detail}`);
+    }
+    if (readiness.config.error) {
+        lines.push(`  error: ${readiness.config.error}`);
+    }
+    lines.push('Run `codex-orchestrator doctor --format json` for details.');
+    lines.push('Run `codex-orchestrator devtools setup` to configure the MCP server.');
+    return lines.join('\n');
+}
+function inspectDevtoolsConfig(env = process.env) {
+    const configPath = resolveCodexConfigPath(env);
+    if (!existsSync(configPath)) {
+        return { status: 'missing', path: configPath, detail: 'config.toml not found' };
+    }
+    let raw;
+    try {
+        raw = readFileSync(configPath, 'utf8');
+    }
+    catch (error) {
+        return {
+            status: 'invalid',
+            path: configPath,
+            error: error instanceof Error ? error.message : String(error)
+        };
+    }
+    const hasEntry = hasDevtoolsConfigEntry(raw);
+    if (hasEntry) {
+        return { status: 'ok', path: configPath };
+    }
+    return {
+        status: 'missing',
+        path: configPath,
+        detail: 'chrome-devtools entry not found'
+    };
+}
+function hasDevtoolsConfigEntry(raw) {
+    const lines = raw.split('\n');
+    let currentTable = null;
+    for (const line of lines) {
+        const trimmed = stripTomlComment(line).trim();
+        if (!trimmed) {
+            continue;
+        }
+        const tableMatch = trimmed.match(/^\[(.+)\]$/);
+        if (tableMatch) {
+            currentTable = tableMatch[1]?.trim() ?? null;
+            if (currentTable === 'mcp_servers.chrome-devtools' ||
+                currentTable === 'mcp_servers."chrome-devtools"' ||
+                currentTable === "mcp_servers.'chrome-devtools'") {
+                return true;
+            }
+            continue;
+        }
+        if (trimmed.startsWith('mcp_servers.')) {
+            if (trimmed.startsWith('mcp_servers."chrome-devtools".')) {
+                return true;
+            }
+            if (trimmed.startsWith("mcp_servers.'chrome-devtools'.")) {
+                return true;
+            }
+            if (trimmed.startsWith('mcp_servers.chrome-devtools.')) {
+                return true;
+            }
+            if (trimmed.startsWith('mcp_servers."chrome-devtools"=')) {
+                return true;
+            }
+            if (trimmed.startsWith("mcp_servers.'chrome-devtools'=")) {
+                return true;
+            }
+            if (trimmed.startsWith('mcp_servers.chrome-devtools=')) {
+                return true;
+            }
+        }
+        if (currentTable === 'mcp_servers') {
+            if (/^"?chrome-devtools"?\s*=/.test(trimmed)) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function stripTomlComment(line) {
+    const index = line.indexOf('#');
+    if (index === -1) {
+        return line;
+    }
+    return line.slice(0, index);
+}

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

@@ -3,7 +3,9 @@ import { existsSync } from 'node:fs';
 import { join } from 'node:path';
 import process from 'node:process';
 import { logger } from '../../logger.js';
-const specGuardPath = join(process.cwd(), 'scripts', 'spec-guard.mjs');
+import { resolveEnvironmentPaths } from '../../../../scripts/lib/run-manifests.js';
+const { repoRoot } = resolveEnvironmentPaths();
+const specGuardPath = join(repoRoot, 'scripts', 'spec-guard.mjs');
 if (!existsSync(specGuardPath)) {
     logger.warn(`[spec-guard] skipped: ${specGuardPath} not found`);
     process.exit(0);

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

@@ -1,8 +1,10 @@
+import { slugify as sharedSlugify } from '../../../../packages/shared/utils/strings.js';
 export function slugify(value, fallback = 'command') {
-    const cleaned = value.trim().replace(/[^a-zA-Z0-9]+/g, '-').replace(/-+/g, '-');
-    const normalized = cleaned.replace(/^-|-$/g, '');
-    if (!normalized) {
-        return fallback;
-    }
-    return normalized.slice(0, 80);
+    return sharedSlugify(value, {
+        fallback,
+        maxLength: 80,
+        lowercase: false,
+        pattern: /[^a-zA-Z0-9]+/g,
+        collapseDashes: true
+    });
 }

package/dist/orchestrator/src/persistence/ExperienceStore.js

@@ -1,9 +1,10 @@
 import { randomBytes } from 'node:crypto';
-import { readFile, mkdir, rm, readdir } from 'node:fs/promises';
+import { readFile, mkdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
+import { listDirectories, resolveEnvironmentPaths } from '../../../scripts/lib/run-manifests.js';
 import { acquireLockWithRetry } from './lockFile.js';
 import { sanitizeTaskId } from './sanitizeTaskId.js';
-import { writeAtomicFile } from './writeAtomicFile.js';
+import { writeAtomicFile } from '../utils/atomicWrite.js';
 export class ExperienceStoreLockError extends Error {
     taskId;
     constructor(message, taskId) {
@@ -21,8 +22,9 @@ export class ExperienceStore {
     lockRetry;
     now;
     constructor(options = {}) {
-        this.outDir = options.outDir ?? join(process.cwd(), 'out');
-        this.runsDir = options.runsDir ?? join(process.cwd(), '.runs');
+        const envPaths = resolveEnvironmentPaths();
+        this.outDir = options.outDir ?? envPaths.outRoot;
+        this.runsDir = options.runsDir ?? envPaths.runsRoot;
         this.maxWords = Math.max(1, options.maxSummaryWords ?? DEFAULT_MAX_WORDS);
         const defaults = {
             maxAttempts: 5,
@@ -183,18 +185,6 @@ export class ExperienceStore {
         return `exp-${Date.now().toString(36)}-${suffix}`;
     }
 }
-async function listDirectories(path) {
-    try {
-        const entries = await readdir(path, { withFileTypes: true });
-        return entries.filter((entry) => entry.isDirectory()).map((entry) => entry.name);
-    }
-    catch (error) {
-        if (error.code === 'ENOENT') {
-            return [];
-        }
-        throw error;
-    }
-}
 function truncateSummary(value, maxWords) {
     const tokens = value.trim().split(/\s+/u).filter(Boolean);
     if (tokens.length <= maxWords) {

package/dist/orchestrator/src/persistence/TaskStateStore.js

@@ -2,7 +2,7 @@ import { mkdir, readFile, rm } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { acquireLockWithRetry } from './lockFile.js';
 import { sanitizeTaskId } from './sanitizeTaskId.js';
-import { writeAtomicFile } from './writeAtomicFile.js';
+import { writeAtomicFile } from '../utils/atomicWrite.js';
 export class TaskStateStoreLockError extends Error {
     taskId;
     constructor(message, taskId) {

package/dist/orchestrator/src/persistence/sanitizeIdentifier.js

@@ -1,4 +1,4 @@
-import { WINDOWS_FORBIDDEN_CHARACTERS } from './identifierGuards.js';
+const WINDOWS_FORBIDDEN_CHARACTERS = new Set(['<', '>', ':', '"', '|', '?', '*']);
 export function sanitizeIdentifier(kind, value) {
     const label = kind === 'task' ? 'task' : 'run';
     if (!value) {

package/dist/packages/orchestrator/src/exec/stdio.js

@@ -0,0 +1,112 @@
+import { Buffer } from 'node:buffer';
+/**
+ * Creates a tracker that sequences stdout/stderr chunks while maintaining
+ * bounded in-memory buffers for each stream.
+ */
+export function createStdioTracker(options = {}) {
+    const encoding = options.encoding ?? 'utf-8';
+    const maxBufferBytes = options.maxBufferBytes ?? 64 * 1024;
+    const now = options.now ?? (() => new Date());
+    let sequence = Math.max(0, options.startSequence ?? 0);
+    const buffers = {
+        stdout: createInternalBuffer(),
+        stderr: createInternalBuffer()
+    };
+    const push = (stream, chunk) => {
+        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
+        const target = buffers[stream];
+        appendWithLimit(target, buffer, maxBufferBytes);
+        const chunkRecord = {
+            sequence: ++sequence,
+            stream,
+            bytes: buffer.byteLength,
+            data: buffer.toString(encoding),
+            timestamp: now().toISOString()
+        };
+        return chunkRecord;
+    };
+    const getBuffered = (stream) => {
+        const target = buffers[stream];
+        if (target.byteLength === 0) {
+            return '';
+        }
+        const activeChunks = snapshotChunks(target);
+        if (activeChunks.length === 0) {
+            return '';
+        }
+        if (activeChunks.length === 1) {
+            return activeChunks[0].toString(encoding);
+        }
+        return Buffer.concat(activeChunks, target.byteLength).toString(encoding);
+    };
+    const getBufferedBytes = (stream) => buffers[stream].byteLength;
+    const reset = () => {
+        buffers.stdout = createInternalBuffer();
+        buffers.stderr = createInternalBuffer();
+        sequence = Math.max(0, options.startSequence ?? 0);
+    };
+    return {
+        push,
+        getBuffered,
+        getBufferedBytes,
+        reset
+    };
+}
+function createInternalBuffer() {
+    return { chunks: [], start: 0, byteLength: 0 };
+}
+function snapshotChunks(buffer) {
+    if (buffer.start === 0) {
+        return buffer.chunks;
+    }
+    return buffer.chunks.slice(buffer.start);
+}
+function appendWithLimit(target, incoming, limit) {
+    if (limit <= 0) {
+        target.chunks = [];
+        target.start = 0;
+        target.byteLength = 0;
+        return;
+    }
+    if (!incoming || incoming.byteLength === 0) {
+        trimExcess(target, limit);
+        return;
+    }
+    if (incoming.byteLength >= limit) {
+        const trimmed = Buffer.from(incoming.subarray(incoming.byteLength - limit));
+        target.chunks = [trimmed];
+        target.start = 0;
+        target.byteLength = trimmed.byteLength;
+        return;
+    }
+    target.chunks.push(incoming);
+    target.byteLength += incoming.byteLength;
+    trimExcess(target, limit);
+}
+function trimExcess(target, limit) {
+    if (target.byteLength <= limit) {
+        return;
+    }
+    let startIndex = target.start;
+    const chunks = target.chunks;
+    while (target.byteLength > limit && startIndex < chunks.length) {
+        const head = chunks[startIndex];
+        if (!head) {
+            break;
+        }
+        const overflow = target.byteLength - limit;
+        if (head.byteLength <= overflow) {
+            target.byteLength -= head.byteLength;
+            startIndex += 1;
+            continue;
+        }
+        chunks[startIndex] = head.subarray(overflow);
+        target.byteLength -= overflow;
+        break;
+    }
+    target.start = startIndex;
+    if (target.start > 0 && target.start * 2 >= chunks.length) {
+        target.chunks = chunks.slice(target.start);
+        target.start = 0;
+    }
+}

package/dist/packages/orchestrator/src/exec/unified-exec.js

@@ -1,7 +1,7 @@
 import { spawn } from 'node:child_process';
 import { randomUUID } from 'node:crypto';
 import { ToolInvocationFailedError } from '../tool-orchestrator.js';
-import { createStdioTracker } from '../../../shared/streams/stdio.js';
+import { createStdioTracker } from './stdio.js';
 export class UnifiedExecRunner {
     orchestrator;
     sessionManager;

package/dist/packages/orchestrator/src/index.js

@@ -1,3 +1,4 @@
 export { ToolOrchestrator, SandboxRetryableError, ApprovalRequiredError, ApprovalDeniedError, ToolInvocationFailedError } from './tool-orchestrator.js';
 export { ExecSessionManager } from './exec/session-manager.js';
 export { UnifiedExecRunner } from './exec/unified-exec.js';
+export { RemoteExecHandleService } from './exec/handle-service.js';

package/dist/packages/shared/design-artifacts/writer.js

@@ -1,6 +1,8 @@
-import { mkdir, rename, writeFile } from 'node:fs/promises';
-import { dirname, join, relative as relativePath } from 'node:path';
+import { join, relative as relativePath } from 'node:path';
 import { persistDesignManifest } from '../manifest/writer.js';
+import { writeJsonAtomic } from '../../../orchestrator/src/cli/utils/fs.js';
+import { sanitizeTaskId } from '../../../orchestrator/src/persistence/sanitizeTaskId.js';
+import { sanitizeRunId } from '../../../orchestrator/src/persistence/sanitizeRunId.js';
 export async function writeDesignSummary(options) {
     const now = options.now ?? new Date();
     const context = options.context;
@@ -207,15 +209,3 @@ function accumulateNumericTotals(target, incoming) {
         }
     }
 }
-function sanitizeTaskId(value) {
-    return value.replace(/[^a-zA-Z0-9_-]/g, '').toLowerCase();
-}
-function sanitizeRunId(value) {
-    return value.replace(/[:]/g, '-');
-}
-async function writeJsonAtomic(targetPath, payload) {
-    const tmpPath = `${targetPath}.tmp-${process.pid}-${Date.now()}`;
-    await mkdir(dirname(targetPath), { recursive: true });
-    await writeFile(tmpPath, `${JSON.stringify(payload, null, 2)}\n`, 'utf8');
-    await rename(tmpPath, targetPath);
-}

package/dist/packages/shared/streams/stdio.js

@@ -1,112 +1,2 @@
-import { Buffer } from 'node:buffer';
-/**
- * Creates a tracker that sequences stdout/stderr chunks while maintaining
- * bounded in-memory buffers for each stream.
- */
-export function createStdioTracker(options = {}) {
-    const encoding = options.encoding ?? 'utf-8';
-    const maxBufferBytes = options.maxBufferBytes ?? 64 * 1024;
-    const now = options.now ?? (() => new Date());
-    let sequence = Math.max(0, options.startSequence ?? 0);
-    const buffers = {
-        stdout: createInternalBuffer(),
-        stderr: createInternalBuffer()
-    };
-    const push = (stream, chunk) => {
-        const buffer = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk, encoding);
-        const target = buffers[stream];
-        appendWithLimit(target, buffer, maxBufferBytes);
-        const chunkRecord = {
-            sequence: ++sequence,
-            stream,
-            bytes: buffer.byteLength,
-            data: buffer.toString(encoding),
-            timestamp: now().toISOString()
-        };
-        return chunkRecord;
-    };
-    const getBuffered = (stream) => {
-        const target = buffers[stream];
-        if (target.byteLength === 0) {
-            return '';
-        }
-        const activeChunks = snapshotChunks(target);
-        if (activeChunks.length === 0) {
-            return '';
-        }
-        if (activeChunks.length === 1) {
-            return activeChunks[0].toString(encoding);
-        }
-        return Buffer.concat(activeChunks, target.byteLength).toString(encoding);
-    };
-    const getBufferedBytes = (stream) => buffers[stream].byteLength;
-    const reset = () => {
-        buffers.stdout = createInternalBuffer();
-        buffers.stderr = createInternalBuffer();
-        sequence = Math.max(0, options.startSequence ?? 0);
-    };
-    return {
-        push,
-        getBuffered,
-        getBufferedBytes,
-        reset
-    };
-}
-function createInternalBuffer() {
-    return { chunks: [], start: 0, byteLength: 0 };
-}
-function snapshotChunks(buffer) {
-    if (buffer.start === 0) {
-        return buffer.chunks;
-    }
-    return buffer.chunks.slice(buffer.start);
-}
-function appendWithLimit(target, incoming, limit) {
-    if (limit <= 0) {
-        target.chunks = [];
-        target.start = 0;
-        target.byteLength = 0;
-        return;
-    }
-    if (!incoming || incoming.byteLength === 0) {
-        trimExcess(target, limit);
-        return;
-    }
-    if (incoming.byteLength >= limit) {
-        const trimmed = Buffer.from(incoming.subarray(incoming.byteLength - limit));
-        target.chunks = [trimmed];
-        target.start = 0;
-        target.byteLength = trimmed.byteLength;
-        return;
-    }
-    target.chunks.push(incoming);
-    target.byteLength += incoming.byteLength;
-    trimExcess(target, limit);
-}
-function trimExcess(target, limit) {
-    if (target.byteLength <= limit) {
-        return;
-    }
-    let startIndex = target.start;
-    const chunks = target.chunks;
-    while (target.byteLength > limit && startIndex < chunks.length) {
-        const head = chunks[startIndex];
-        if (!head) {
-            break;
-        }
-        const overflow = target.byteLength - limit;
-        if (head.byteLength <= overflow) {
-            target.byteLength -= head.byteLength;
-            startIndex += 1;
-            continue;
-        }
-        chunks[startIndex] = head.subarray(overflow);
-        target.byteLength -= overflow;
-        break;
-    }
-    target.start = startIndex;
-    if (target.start > 0 && target.start * 2 >= chunks.length) {
-        target.chunks = chunks.slice(target.start);
-        target.start = 0;
-    }
-}
+// Deprecated shim: keep exports stable while stdio tracking moves into packages/orchestrator.
+export * from '../../orchestrator/src/exec/stdio.js';

package/dist/packages/shared/utils/strings.js

@@ -0,0 +1,17 @@
+export function slugify(value, options = {}) {
+    const fallback = typeof options.fallback === 'string' ? options.fallback : 'command';
+    const maxLength = Number.isFinite(options.maxLength)
+        ? Math.max(1, Math.floor(options.maxLength))
+        : 80;
+    const lowercase = options.lowercase ?? false;
+    const pattern = options.pattern ?? /[^a-zA-Z0-9]+/g;
+    const collapseDashes = options.collapseDashes ?? true;
+    const base = lowercase ? value.toLowerCase() : value;
+    const cleaned = base.trim().replace(pattern, '-');
+    const collapsed = collapseDashes ? cleaned.replace(/-+/g, '-') : cleaned;
+    const normalized = collapsed.replace(/^-+|-+$/g, '');
+    if (!normalized) {
+        return fallback;
+    }
+    return normalized.slice(0, maxLength);
+}

package/dist/scripts/design/pipeline/advanced-assets.js

@@ -8,7 +8,7 @@ import { loadDesignContext } from './context.js';
 import { appendApprovals, appendArtifacts, ensureToolkitState, loadDesignRunState, saveDesignRunState, upsertStage } from './state.js';
 import { stageArtifacts } from '../../../orchestrator/src/persistence/ArtifactStager.js';
 import { runDefaultInteractions } from './toolkit/snapshot.js';
-import { loadPlaywright } from './optionalDeps.js';
+import { loadPlaywright } from './optional-deps.js';
 const execFileAsync = promisify(execFile);
 const MOTION_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36';
 const DEFAULT_CAPTURE_SECONDS = 12;