@kbediako/codex-orchestrator 0.1.38 → 0.2.0

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

@@ -29,6 +29,7 @@ export class UnifiedExecRunner {
     async run(options) {
         const args = options.args;
         const resolvedArgs = args ?? [];
+        const timeoutMs = normalizeTimeoutMs(options.timeoutMs);
         const invocationId = options.invocationId ?? this.idGenerator();
         const correlationId = this.idGenerator();
         const issuedHandle = this.handleService ? this.handleService.issueHandle(correlationId) : undefined;
@@ -55,7 +56,8 @@ export class UnifiedExecRunner {
             sessionId: lease.id,
             correlationId,
             persisted: lease.persisted,
-            handleId
+            handleId,
+            timeoutMs
         };
         const toolInvocation = {
             id: invocationId,
@@ -98,7 +100,9 @@ export class UnifiedExecRunner {
                         durationMs: 0,
                         status: 'failed',
                         sandboxState,
-                        sessionId: lease.id
+                        sessionId: lease.id,
+                        timedOut: false,
+                        ...(timeoutMs !== null ? { timeoutMs } : {})
                     };
                     try {
                         const outcome = await this.executor({
@@ -109,6 +113,7 @@ export class UnifiedExecRunner {
                             attempt,
                             sandboxState,
                             session: lease,
+                            ...(timeoutMs !== null ? { timeoutMs } : {}),
                             onStdout: (chunk) => {
                                 const sequenced = this.recordChunk(tracker, 'stdout', chunk);
                                 chunkSequence = sequenced.sequence;
@@ -132,7 +137,11 @@ export class UnifiedExecRunner {
                         });
                         attemptSummary.exitCode = outcome.exitCode ?? null;
                         attemptSummary.signal = outcome.signal ?? null;
-                        attemptSummary.status = outcome.exitCode === 0 ? 'succeeded' : 'failed';
+                        attemptSummary.timedOut = outcome.timedOut === true;
+                        if (typeof outcome.timeoutMs === 'number' && Number.isFinite(outcome.timeoutMs) && outcome.timeoutMs > 0) {
+                            attemptSummary.timeoutMs = Math.trunc(outcome.timeoutMs);
+                        }
+                        attemptSummary.status = outcome.exitCode === 0 && !attemptSummary.timedOut ? 'succeeded' : 'failed';
                         attemptSummary.durationMs = outcome.durationMs ?? 0;
                     }
                     catch (error) {
@@ -171,6 +180,8 @@ export class UnifiedExecRunner {
                 durationMs: attemptResult.durationMs,
                 status: attemptResult.status,
                 sandboxState: attemptResult.sandboxState,
+                ...(attemptResult.timedOut ? { timedOut: true } : {}),
+                ...(attemptResult.timeoutMs !== undefined ? { timeoutMs: attemptResult.timeoutMs } : {}),
                 record: invocationRecord,
                 events,
                 handle: undefined
@@ -307,7 +318,9 @@ export class UnifiedExecRunner {
                 correlationId,
                 handleId,
                 exitCode: attemptResult?.exitCode ?? null,
-                signal: attemptResult?.signal ?? null
+                signal: attemptResult?.signal ?? null,
+                timedOut: attemptResult?.timedOut ?? null,
+                timeoutMs: attemptResult?.timeoutMs ?? null
             }
         };
         record.metadata = execMetadata;
@@ -414,20 +427,100 @@ const defaultExecutor = async (request) => {
     }
     child.stdout.on('data', request.onStdout);
     child.stderr.on('data', request.onStderr);
+    const timeoutMs = normalizeTimeoutMs(request.timeoutMs);
+    const startedAt = Date.now();
     return await new Promise((resolve, reject) => {
-        const handleExit = (exitCode, signal) => {
+        let settled = false;
+        let timedOut = false;
+        let timeoutHandle = null;
+        let forceKillHandle = null;
+        let forcedSettleHandle = null;
+        const resolveResult = (exitCode, signal) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
             cleanup();
-            resolve({ exitCode, signal });
+            const result = {
+                exitCode,
+                signal,
+                durationMs: Math.max(0, Date.now() - startedAt)
+            };
+            if (timedOut) {
+                result.timedOut = true;
+                if (timeoutMs !== null) {
+                    result.timeoutMs = timeoutMs;
+                }
+            }
+            resolve(result);
+        };
+        const handleExit = (exitCode, signal) => {
+            resolveResult(exitCode, signal);
         };
         const handleError = (error) => {
+            if (timedOut) {
+                return;
+            }
             cleanup();
             reject(error);
         };
         const cleanup = () => {
             child.off('exit', handleExit);
             child.off('error', handleError);
+            if (timeoutHandle) {
+                clearTimeout(timeoutHandle);
+                timeoutHandle = null;
+            }
+            if (forceKillHandle) {
+                clearTimeout(forceKillHandle);
+                forceKillHandle = null;
+            }
+            if (forcedSettleHandle) {
+                clearTimeout(forcedSettleHandle);
+                forcedSettleHandle = null;
+            }
         };
+        if (timeoutMs !== null) {
+            timeoutHandle = setTimeout(() => {
+                timedOut = true;
+                if (!child.killed) {
+                    try {
+                        child.kill('SIGTERM');
+                    }
+                    catch {
+                        // ignore kill errors and continue to forced settlement fallback
+                    }
+                }
+                forceKillHandle = setTimeout(() => {
+                    if (settled) {
+                        return;
+                    }
+                    try {
+                        child.kill('SIGKILL');
+                    }
+                    catch {
+                        // ignore kill errors and allow forced settlement to conclude
+                    }
+                }, 1000);
+                forceKillHandle.unref?.();
+                forcedSettleHandle = setTimeout(() => {
+                    resolveResult(null, 'SIGKILL');
+                }, 1500);
+                forcedSettleHandle.unref?.();
+            }, timeoutMs);
+            timeoutHandle.unref?.();
+        }
         child.once('exit', handleExit);
         child.once('error', handleError);
     });
 };
+function normalizeTimeoutMs(value) {
+    if (typeof value !== 'number' || !Number.isFinite(value)) {
+        return null;
+    }
+    const normalized = Math.trunc(value);
+    if (normalized <= 0) {
+        return null;
+    }
+    return normalized;
+}

package/dist/packages/orchestrator/src/instructions/promptPacks.js

@@ -3,6 +3,9 @@ import { readFile, readdir, stat } from 'node:fs/promises';
 import { join, relative } from 'node:path';
 const PROMPT_SECTIONS = ['system', 'inject', 'summarize', 'extract', 'optimize'];
 const PROMPT_PACK_DIR = ['.agent', 'prompts', 'prompt-packs'];
+const DEFAULT_PROMPT_PACK_RETRIEVAL_POLICY_KIND = 'competitive_scoring_v1';
+const DEFAULT_PROMPT_PACK_SOURCE_GROUPING = 'provenance_fallback_v1';
+const DEFAULT_ANTI_DOMINANCE_STRENGTH = 0.5;
 export async function loadPromptPacks(repoRoot) {
     const manifestPaths = await discoverPromptPackManifests(repoRoot);
     const packs = [];
@@ -17,6 +20,20 @@ export async function loadPromptPacks(repoRoot) {
     });
     return packs;
 }
+export async function loadPromptPackMetadata(repoRoot) {
+    const manifestPaths = await discoverPromptPackManifests(repoRoot);
+    const packs = [];
+    for (const manifestPath of manifestPaths) {
+        packs.push(await loadPromptPackMetadataEntry(manifestPath, repoRoot));
+    }
+    packs.sort((a, b) => {
+        if (a.domain === b.domain) {
+            return a.id.localeCompare(b.id);
+        }
+        return a.domain.localeCompare(b.domain);
+    });
+    return packs;
+}
 async function discoverPromptPackManifests(repoRoot) {
     const baseDir = join(repoRoot, ...PROMPT_PACK_DIR);
     let entries;
@@ -49,15 +66,11 @@ async function discoverPromptPackManifests(repoRoot) {
     return manifests;
 }
 async function loadPromptPack(manifestPath, repoRoot) {
-    let parsed;
-    try {
-        const raw = await readFile(manifestPath, 'utf8');
-        parsed = JSON.parse(raw);
-    }
-    catch (error) {
-        throw new Error(`Failed to read prompt pack manifest at ${relative(repoRoot, manifestPath)}: ${String(error)}`);
-    }
+    const parsed = await readPromptPackManifestFile(manifestPath, repoRoot);
     validateManifest(parsed, manifestPath, repoRoot);
+    const id = requireNonEmptyManifestString(parsed.id, 'id', manifestPath, repoRoot);
+    const domain = requireNonEmptyManifestString(parsed.domain, 'domain', manifestPath, repoRoot);
+    const system = requireNonEmptyManifestString(parsed.system, 'system', manifestPath, repoRoot);
     const sections = {
         system: [],
         inject: [],
@@ -65,34 +78,70 @@ async function loadPromptPack(manifestPath, repoRoot) {
         extract: [],
         optimize: []
     };
-    sections.system = [await loadSectionSource(repoRoot, 'system', parsed.system, manifestPath)];
+    sections.system = [await loadSectionSource(repoRoot, 'system', system, manifestPath)];
     sections.inject = await loadSectionArray(repoRoot, 'inject', parsed.inject ?? [], manifestPath);
     sections.summarize = await loadSectionArray(repoRoot, 'summarize', parsed.summarize ?? [], manifestPath);
     sections.extract = await loadSectionArray(repoRoot, 'extract', parsed.extract ?? [], manifestPath);
     sections.optimize = await loadSectionArray(repoRoot, 'optimize', parsed.optimize ?? [], manifestPath);
     const allSources = PROMPT_SECTIONS.flatMap((section) => sections[section]);
     if (allSources.length === 0) {
-        throw new Error(`Prompt pack ${parsed.id} ${parsed.domain} has no sources defined (${relative(repoRoot, manifestPath)})`);
+        throw new Error(`Prompt pack ${id} ${domain} has no sources defined (${relative(repoRoot, manifestPath)})`);
     }
-    const computedStamp = computePromptPackStamp(allSources);
+    const experienceSlots = resolvePromptPackExperienceSlots(parsed, manifestPath, repoRoot);
+    const retrievalPolicy = normalizePromptPackRetrievalPolicy(parsed.retrievalPolicy);
+    const computedStamp = computePromptPackStamp(allSources, {
+        experienceSlots,
+        retrievalPolicy
+    });
     if (!parsed.stamp) {
-        throw new Error(`Prompt pack ${parsed.id} is missing a stamp (manifest: ${relative(repoRoot, manifestPath)})`);
+        throw new Error(`Prompt pack ${id} is missing a stamp (manifest: ${relative(repoRoot, manifestPath)})`);
     }
     if (computedStamp !== parsed.stamp) {
-        throw new Error(`Prompt pack ${parsed.id} stamp mismatch. expected ${parsed.stamp}, computed ${computedStamp} (${relative(repoRoot, manifestPath)})`);
+        throw new Error(`Prompt pack ${id} stamp mismatch. expected ${parsed.stamp}, computed ${computedStamp} (${relative(repoRoot, manifestPath)})`);
     }
-    const experienceSlots = Number.isInteger(parsed.experienceSlots) && parsed.experienceSlots >= 0
-        ? parsed.experienceSlots
-        : 0;
     return {
-        id: parsed.id,
-        domain: parsed.domain,
+        id,
+        domain,
         stamp: parsed.stamp,
         experienceSlots,
+        retrievalPolicy,
         sections,
         sources: allSources
     };
 }
+async function loadPromptPackMetadataEntry(manifestPath, repoRoot) {
+    const parsed = await readPromptPackManifestFile(manifestPath, repoRoot);
+    validateManifest(parsed, manifestPath, repoRoot);
+    const id = requireNonEmptyManifestString(parsed.id, 'id', manifestPath, repoRoot);
+    const domain = requireNonEmptyManifestString(parsed.domain, 'domain', manifestPath, repoRoot);
+    requireNonEmptyManifestString(parsed.system, 'system', manifestPath, repoRoot);
+    if (!parsed.stamp) {
+        throw new Error(`Prompt pack ${id} is missing a stamp (manifest: ${relative(repoRoot, manifestPath)})`);
+    }
+    return {
+        id,
+        domain,
+        experienceSlots: resolvePromptPackExperienceSlots(parsed, manifestPath, repoRoot)
+    };
+}
+async function readPromptPackManifestFile(manifestPath, repoRoot) {
+    try {
+        const raw = await readFile(manifestPath, 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        throw new Error(`Failed to read prompt pack manifest at ${relative(repoRoot, manifestPath)}: ${String(error)}`);
+    }
+}
+function resolvePromptPackExperienceSlots(parsed, manifestPath, repoRoot) {
+    if (parsed.experienceSlots !== undefined &&
+        (typeof parsed.experienceSlots !== 'number' ||
+            !Number.isInteger(parsed.experienceSlots) ||
+            parsed.experienceSlots < 0)) {
+        throw new Error(`Prompt pack ${parsed.id} has invalid experienceSlots; expected a non-negative integer (${relative(repoRoot, manifestPath)})`);
+    }
+    return parsed.experienceSlots ?? 0;
+}
 function validateManifest(manifest, manifestPath, repoRoot) {
     const missing = [];
     if (!manifest.id) {
@@ -108,6 +157,69 @@ function validateManifest(manifest, manifestPath, repoRoot) {
         throw new Error(`Prompt pack manifest ${relative(repoRoot, manifestPath)} missing required fields: ${missing.join(', ')}`);
     }
 }
+function requireNonEmptyManifestString(value, field, manifestPath, repoRoot) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`Prompt pack manifest ${relative(repoRoot, manifestPath)} has invalid '${field}'; expected a non-empty string (repoRoot: ${repoRoot})`);
+    }
+    return value.trim();
+}
+function normalizePromptPackRetrievalPolicy(input) {
+    const antiDominance = input?.antiDominanceNormalization;
+    return {
+        kind: normalizeRetrievalPolicyKind(input?.kind),
+        minScore: input?.minScore === null || input?.minScore === undefined
+            ? null
+            : normalizeNonNegativeNumber(input.minScore, 'retrievalPolicy.minScore'),
+        scoreWeights: {
+            gtScore: normalizeNonNegativeNumber(input?.scoreWeights?.gtScore, 'retrievalPolicy.scoreWeights.gtScore', 1),
+            relativeRank: normalizeNonNegativeNumber(input?.scoreWeights?.relativeRank, 'retrievalPolicy.scoreWeights.relativeRank', 1)
+        },
+        antiDominanceNormalization: {
+            enabled: normalizeBoolean(antiDominance?.enabled, 'retrievalPolicy.antiDominanceNormalization.enabled', true),
+            strength: normalizeNonNegativeNumber(antiDominance?.strength, 'retrievalPolicy.antiDominanceNormalization.strength', DEFAULT_ANTI_DOMINANCE_STRENGTH),
+            sourceGrouping: normalizeSourceGrouping(antiDominance?.sourceGrouping)
+        }
+    };
+}
+function normalizeRetrievalPolicyKind(value) {
+    if (!value || !value.trim()) {
+        return DEFAULT_PROMPT_PACK_RETRIEVAL_POLICY_KIND;
+    }
+    if (value !== DEFAULT_PROMPT_PACK_RETRIEVAL_POLICY_KIND) {
+        throw new Error(`Unsupported prompt-pack retrieval policy kind '${value}'. Expected '${DEFAULT_PROMPT_PACK_RETRIEVAL_POLICY_KIND}'.`);
+    }
+    return DEFAULT_PROMPT_PACK_RETRIEVAL_POLICY_KIND;
+}
+function normalizeSourceGrouping(value) {
+    if (!value || !value.trim()) {
+        return DEFAULT_PROMPT_PACK_SOURCE_GROUPING;
+    }
+    if (value !== DEFAULT_PROMPT_PACK_SOURCE_GROUPING) {
+        throw new Error(`Unsupported prompt-pack source grouping '${value}'. Expected '${DEFAULT_PROMPT_PACK_SOURCE_GROUPING}'.`);
+    }
+    return DEFAULT_PROMPT_PACK_SOURCE_GROUPING;
+}
+function normalizeNonNegativeNumber(value, field, defaultValue) {
+    if (value === undefined) {
+        if (defaultValue === undefined) {
+            throw new Error(`${field} is required.`);
+        }
+        return defaultValue;
+    }
+    if (!Number.isFinite(value) || value < 0) {
+        throw new Error(`${field} must be a finite non-negative number.`);
+    }
+    return value;
+}
+function normalizeBoolean(value, field, defaultValue) {
+    if (value === undefined) {
+        return defaultValue;
+    }
+    if (typeof value !== 'boolean') {
+        throw new Error(`${field} must be a boolean.`);
+    }
+    return value;
+}
 async function loadSectionArray(repoRoot, section, paths, manifestPath) {
     const sources = [];
     for (const relPath of paths) {
@@ -134,7 +246,7 @@ async function loadSectionSource(repoRoot, section, relativePath, manifestPath)
         content
     };
 }
-export function computePromptPackStamp(sources) {
+export function computePromptPackStamp(sources, config) {
     const hash = createHash('sha256');
     const sorted = [...sources].sort((a, b) => {
         if (a.section === b.section) {
@@ -147,5 +259,24 @@ export function computePromptPackStamp(sources) {
         hash.update(source.content, 'utf8');
         hash.update('\n', 'utf8');
     }
+    if (config) {
+        hash.update(JSON.stringify({
+            experienceSlots: config.experienceSlots,
+            retrievalPolicy: {
+                kind: config.retrievalPolicy.kind,
+                minScore: config.retrievalPolicy.minScore,
+                scoreWeights: {
+                    gtScore: config.retrievalPolicy.scoreWeights.gtScore,
+                    relativeRank: config.retrievalPolicy.scoreWeights.relativeRank
+                },
+                antiDominanceNormalization: {
+                    enabled: config.retrievalPolicy.antiDominanceNormalization.enabled,
+                    strength: config.retrievalPolicy.antiDominanceNormalization.strength,
+                    sourceGrouping: config.retrievalPolicy.antiDominanceNormalization.sourceGrouping
+                }
+            }
+        }), 'utf8');
+        hash.update('\n', 'utf8');
+    }
     return hash.digest('hex');
 }

package/dist/packages/sdk-node/src/orchestrator.js

@@ -1,11 +1,76 @@
 import { spawn } from 'node:child_process';
-import { createWriteStream, mkdtempSync } from 'node:fs';
+import { createWriteStream, mkdtempSync, rmSync } from 'node:fs';
 import { rm } from 'node:fs/promises';
 import { EventEmitter } from 'node:events';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
 import { PassThrough } from 'node:stream';
 import { tmpdir } from 'node:os';
+const activeArtifactRoots = new Set();
+const artifactCleanupFinalizer = new FinalizationRegistry((retention) => {
+    retention.releaseCollectedHolder();
+});
+process.once('exit', () => {
+    for (const artifactRoot of activeArtifactRoots) {
+        try {
+            rmSync(artifactRoot, { recursive: true, force: true });
+        }
+        catch {
+            // Best-effort cleanup only.
+        }
+    }
+});
+class ArtifactRetention {
+    artifactRoot;
+    holderCount = 0;
+    cleaned = false;
+    cleanupPromise = null;
+    constructor(artifactRoot) {
+        this.artifactRoot = artifactRoot;
+        activeArtifactRoots.add(artifactRoot);
+    }
+    registerHolder(target, token) {
+        if (this.cleaned) {
+            return;
+        }
+        this.holderCount += 1;
+        artifactCleanupFinalizer.register(target, this, token);
+    }
+    unregisterHolder(token) {
+        if (!artifactCleanupFinalizer.unregister(token)) {
+            return;
+        }
+        this.releaseHolder();
+    }
+    releaseCollectedHolder() {
+        this.releaseHolder();
+    }
+    async cleanup() {
+        if (this.cleanupPromise) {
+            return await this.cleanupPromise;
+        }
+        if (!this.cleaned) {
+            this.cleaned = true;
+            this.holderCount = 0;
+            this.cleanupPromise = rm(this.artifactRoot, { recursive: true, force: true })
+                .catch(() => { })
+                .finally(() => {
+                activeArtifactRoots.delete(this.artifactRoot);
+            })
+                .then(() => undefined);
+        }
+        await this.cleanupPromise;
+    }
+    releaseHolder() {
+        if (this.cleaned || this.holderCount === 0) {
+            return;
+        }
+        this.holderCount -= 1;
+        if (this.holderCount === 0) {
+            void this.cleanup();
+        }
+    }
+}
 export class ExecClient {
     cliPath;
     cwd;
@@ -49,11 +114,15 @@ export class ExecRunHandle extends EventEmitter {
     eventsFilePath;
     stderrFilePath;
     artifactRoot;
+    artifactRetention;
     maxEventBuffer = 200;
     maxStderrBuffer = 200;
     streamsClosed = false;
+    artifactsCleaned = false;
+    resultSettled = false;
     summaryEvent = null;
     resultPromise;
+    resolvedResult = null;
     resolveResult;
     rejectResult;
     constructor(client, baseOptions, child) {
@@ -64,12 +133,15 @@ export class ExecRunHandle extends EventEmitter {
         this.artifactRoot = mkdtempSync(join(tmpdir(), 'codex-exec-'));
         this.eventsFilePath = join(this.artifactRoot, 'events.ndjson');
         this.stderrFilePath = join(this.artifactRoot, 'stderr.log');
+        this.artifactRetention = new ArtifactRetention(this.artifactRoot);
+        this.artifactRetention.registerHolder(this, this);
         this.eventsStream = createWriteStream(this.eventsFilePath, { flags: 'a' });
         this.stderrStream = createWriteStream(this.stderrFilePath, { flags: 'a' });
         this.resultPromise = new Promise((resolve, reject) => {
             this.resolveResult = resolve;
             this.rejectResult = reject;
         });
+        this.artifactRetention.registerHolder(this.resultPromise, this.resultPromise);
         const stdout = child.stdout ?? new PassThrough();
         const stderr = child.stderr ?? new PassThrough();
         const rl = createInterface({ input: stdout, crlfDelay: Infinity });
@@ -94,7 +166,6 @@ export class ExecRunHandle extends EventEmitter {
             this.emit('event', parsed);
             if (parsed.type === 'run:summary') {
                 this.summaryEvent = parsed;
-                this.resolveResult(this.buildResult());
                 this.emit('summary', this.summaryEvent);
             }
         });
@@ -108,19 +179,32 @@ export class ExecRunHandle extends EventEmitter {
             this.emit('stderr', text);
         });
         child.once('error', (error) => {
-            this.closeStreams();
-            this.emit('error', error);
-            this.rejectResult(error);
+            if (this.listenerCount('error') > 0) {
+                this.emit('error', error);
+            }
+            this.rejectResultOnce(error);
+            void this.closeStreams({ preserveArtifacts: false }).catch(() => {
+                // Preserve the original child-process failure as the terminal result.
+            });
         });
-        child.once('close', (code, signal) => {
-            this.closeStreams();
+        child.once('close', async (code, signal) => {
+            const preserveArtifacts = this.summaryEvent !== null;
+            try {
+                await this.closeStreams({ preserveArtifacts });
+            }
+            catch (error) {
+                this.rejectResultOnce(error);
+                return;
+            }
             this.emit('exit', { code, signal });
             if (!this.summaryEvent) {
                 const error = new Error('Exec command exited without emitting a summary event.');
                 error.exitCode = code ?? null;
                 error.signal = signal ?? null;
-                this.rejectResult(error);
+                this.rejectResultOnce(error);
+                return;
             }
+            this.resolveResultOnce(this.buildResult());
         });
     }
     get events() {
@@ -147,12 +231,19 @@ export class ExecRunHandle extends EventEmitter {
         delete merged.inheritedEnv;
         return this.client.run(merged);
     }
+    async cleanupArtifacts() {
+        await this.result.catch(() => undefined);
+        await this.removeArtifacts();
+    }
     buildResult() {
+        if (this.resolvedResult) {
+            return this.resolvedResult;
+        }
         if (!this.summaryEvent) {
             throw new Error('Summary not available');
         }
         const payload = this.summaryEvent.payload;
-        return {
+        const result = {
             summary: this.summaryEvent,
             events: [...this.eventsList],
             eventsPath: this.eventsFilePath,
@@ -162,15 +253,48 @@ export class ExecRunHandle extends EventEmitter {
             rawStderr: [...this.stderrLines],
             stderrPath: this.stderrFilePath
         };
+        this.resolvedResult = result;
+        this.artifactRetention.registerHolder(result, result);
+        return result;
+    }
+    resolveResultOnce(value) {
+        if (this.resultSettled) {
+            return;
+        }
+        this.resultSettled = true;
+        this.resolveResult(value);
+    }
+    rejectResultOnce(reason) {
+        if (this.resultSettled) {
+            return;
+        }
+        this.resultSettled = true;
+        this.rejectResult(reason);
     }
-    closeStreams() {
+    async closeStreams(options) {
         if (this.streamsClosed) {
             return;
         }
         this.streamsClosed = true;
-        this.eventsStream.end();
-        this.stderrStream.end();
-        void rm(this.artifactRoot, { recursive: true, force: true }).catch(() => { });
+        await Promise.all([
+            new Promise((resolve) => this.eventsStream.end(resolve)),
+            new Promise((resolve) => this.stderrStream.end(resolve))
+        ]);
+        if (!options.preserveArtifacts) {
+            await this.removeArtifacts();
+        }
+    }
+    async removeArtifacts() {
+        if (this.artifactsCleaned) {
+            return;
+        }
+        this.artifactsCleaned = true;
+        this.artifactRetention.unregisterHolder(this);
+        this.artifactRetention.unregisterHolder(this.resultPromise);
+        if (this.resolvedResult) {
+            this.artifactRetention.unregisterHolder(this.resolvedResult);
+        }
+        await this.artifactRetention.cleanup();
     }
 }
 function buildCliArgs(options) {

package/dist/packages/shared/config/designConfig.js

@@ -1,6 +1,5 @@
 import { readFile } from 'node:fs/promises';
 import { join } from 'node:path';
-import { load as parseYaml } from 'js-yaml';
 const DEFAULT_CONFIG_PATH = 'design.config.yaml';
 const DEFAULT_RETENTION_DAYS = 30;
 const DEFAULT_CONFIG = {
@@ -76,6 +75,7 @@ const DEFAULT_CONFIG = {
 };
 const DESIGN_REFERENCE_PIPELINE_ID = 'design-reference';
 const HI_FI_TOOLKIT_PIPELINE_ID = 'hi-fi-design-toolkit';
+let designConfigYamlLoader = null;
 export function designPipelineId(result, env = process.env) {
     return selectDesignPipeline(result ?? null, env).id;
 }
@@ -84,6 +84,7 @@ export async function loadDesignConfig(options = {}) {
     const path = options.filePath ?? join(rootDir, DEFAULT_CONFIG_PATH);
     try {
         const raw = await readFile(path, 'utf-8');
+        const parseYaml = await loadDesignConfigYaml();
         const parsed = parseYaml(raw);
         const warnings = [];
         const config = normalizeDesignConfig(parsed, warnings);
@@ -97,6 +98,12 @@ export async function loadDesignConfig(options = {}) {
         throw new Error(`Failed to load design config at ${path}: ${error.message}`);
     }
 }
+async function loadDesignConfigYaml() {
+    if (!designConfigYamlLoader) {
+        designConfigYamlLoader = import('js-yaml').then((module) => module.load);
+    }
+    return await designConfigYamlLoader;
+}
 export function shouldActivateDesignPipeline(result, env = process.env) {
     return selectDesignPipeline(result, env).shouldRun;
 }

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

@@ -1,2 +1,2 @@
-// Deprecated shim: keep exports stable while stdio tracking moves into packages/orchestrator.
+// Deprecated shim: keep exports stable for published importers while stdio tracking lives in packages/orchestrator.
 export * from '../../orchestrator/src/exec/stdio.js';