yuurei 0.0.1

package/dist/run/pipeline.js

@@ -0,0 +1,246 @@
+import { rm, writeFile } from 'node:fs/promises';
+import { NoopCostModel } from '../cost/noop.js';
+import { installSignalCleanup } from './signals.js';
+import { resolveCell } from '../cell/resolver.js';
+import { collectArtifacts, DEFAULT_ARTIFACT_MAX_BYTES, writeArtifactManifest, } from '../artifact/collector.js';
+import { createIsolation, createVerifiedIsolation } from '../isolation/index.js';
+import { toProfileManifest } from '../profile/manifest.js';
+import { getRuntime } from '../runtime/registry.js';
+import { writeTrace } from '../trace/writer.js';
+import { redactFile } from '../trace/redact.js';
+import { TRACE_SCHEMA_VERSION } from '../trace/schema.js';
+import { createUniqueRunLayout } from './layout.js';
+/**
+ * The single place that orders a run's execution:
+ * resolve → isolate → verify (fail-closed) → prepare → execute →
+ * normalize → write trace → collect artifacts. No other module should
+ * re-implement this ordering (design doc §12.2 fail-closed principle).
+ */
+export async function runPipeline(input) {
+    const cell = await resolveCell(input);
+    const { runId, layout } = await createUniqueRunLayout(input.yuureiDir);
+    const isolation = (input.createIsolation ?? createIsolation)(input.isolationStrategy);
+    let context;
+    try {
+        context = await createVerifiedIsolation(isolation, cell);
+    }
+    catch (error) {
+        // Isolation verification failed (§12.2 fail-closed). The run dir was
+        // already created; remove it so no partial directory is left behind.
+        await rm(layout.runDir, { recursive: true, force: true }).catch(() => { });
+        throw error;
+    }
+    context.keep = input.keep;
+    let prepared;
+    let scrubbed = false;
+    let disposed = false;
+    let traceWritten = false;
+    let runDirRemoved = false;
+    const warn = (message) => input.onWarning?.(message);
+    /**
+     * Every credential path an adapter writes during `prepare()` is registered
+     * here at the moment of the write. The scrub reads from this sink rather
+     * than from `prepared.credentialFilePaths`, which only exists once
+     * prepare() has returned — so a signal or throw between the write and the
+     * return no longer strands credential material (design doc §9.2, audit
+     * Finding 1).
+     */
+    const registeredCredentialPaths = new Set();
+    const scrubCredentials = async () => {
+        // Credential material should never survive a run, even under `--keep` —
+        // `--keep` preserves config/logs for debugging, never bridged auth
+        // material. Best-effort, not a guarantee: a failed deletion is reported
+        // via onWarning (naming the residual path) rather than silently
+        // swallowed. Shared by the finally block and the signal handler, guarded
+        // so a signal arriving mid-cleanup can't double-scrub and double-report.
+        if (scrubbed)
+            return;
+        scrubbed = true;
+        await Promise.all([...registeredCredentialPaths].map(async (path) => {
+            try {
+                await rm(path, { force: true });
+            }
+            catch (error) {
+                warn(`failed to scrub credential file, it may still be present on disk: ${path} (${error instanceof Error ? error.message : String(error)})`);
+            }
+        }));
+    };
+    /**
+     * `discardKept` overrides the context's own `keep` for this disposal only.
+     * Passed as a value rather than written back onto `context`, so the decision
+     * is visible at the call site instead of as a side effect on shared state.
+     */
+    const disposeContext = async (discardKept = false) => {
+        if (disposed)
+            return;
+        disposed = true;
+        await isolation.dispose(discardKept ? { ...context, keep: false } : context);
+    };
+    const removeRunDir = async () => {
+        if (runDirRemoved)
+            return;
+        runDirRemoved = true;
+        try {
+            await rm(layout.runDir, { recursive: true, force: true });
+        }
+        catch (error) {
+            warn(`failed to remove partial run directory: ${layout.runDir} (${error instanceof Error ? error.message : String(error)})`);
+        }
+    };
+    /**
+     * The actual cleanup lifecycle, run exactly once. `cleanup` below memoizes
+     * this promise so that every caller — the finally block and the signal
+     * handler — awaits the *same* in-flight lifecycle. Without the memoization,
+     * a caller arriving while another caller's scrub/dispose is mid-await would
+     * short-circuit through the boolean guards (`scrubbed`/`disposed` are set
+     * before their awaits complete), return immediately, and let the signal
+     * handler's `process.exit()` fire before the first caller's in-flight
+     * rm/dispose had settled.
+     */
+    const runCleanup = async () => {
+        // Scrub before dispose() so this runs regardless of which branch above
+        // threw, and so a signal killing the process mid-dispose never leaves
+        // credential material behind.
+        await scrubCredentials();
+        // `prepared` only exists once prepare() has returned. If the run ended
+        // before that point AND the adapter registered no credential paths, we
+        // cannot rule out an unregistered credential write — removing the whole
+        // root is the only safe choice under `--keep` (§9.2). Once a path is
+        // registered the scrub handled it above, so the rest of the root may be
+        // kept for debugging.
+        const startedRuntime = prepared !== undefined;
+        const cannotIdentifyCredentials = !startedRuntime && registeredCredentialPaths.size === 0;
+        if (cannotIdentifyCredentials && context.keep) {
+            warn(`run ended before the runtime started; removing the isolation directory despite --keep, because credential material written during setup cannot be identified: ${context.rootDir}`);
+        }
+        // If no trace was written (signal-interrupted or threw before writeTrace),
+        // remove the partial run directory so no undocumented directory is left
+        // that cannot be consumed by `yuurei trace show`. This must run even when
+        // isolation.dispose() rejects: a disposal failure must not strand the run
+        // directory as if the run were complete (review #116). disposeContext
+        // itself never throws from here — its rejection propagates out of
+        // runCleanup after the run directory has been handled.
+        try {
+            await disposeContext(cannotIdentifyCredentials);
+        }
+        finally {
+            if (!traceWritten) {
+                await removeRunDir();
+            }
+        }
+    };
+    let cleanupPromise = null;
+    const cleanup = () => {
+        cleanupPromise ??= runCleanup();
+        return cleanupPromise;
+    };
+    const signalCleanup = installSignalCleanup({ cleanup });
+    let primaryError;
+    try {
+        const runtime = (input.resolveRuntime ?? getRuntime)(cell.runtimeId);
+        prepared = await runtime.prepare(cell, context, (path) => registeredCredentialPaths.add(path));
+        const result = await runtime.execute(prepared, input.timeoutMs ?? null);
+        const fragment = await runtime.normalize(result, { runtimeVersion: prepared.runtimeVersion });
+        for (const w of fragment.warnings ?? [])
+            warn(w);
+        const costModel = new NoopCostModel();
+        const costEstimate = await costModel.estimate({
+            runtimeId: cell.runtimeId,
+            model: cell.requestedModel,
+            tokensIn: fragment.usage['input_tokens'] ?? null,
+            tokensOut: fragment.usage['output_tokens'] ?? null,
+        });
+        const knownCredentialValues = prepared.credentialValuesToRedact;
+        const maxArtifactBytes = input.maxArtifactBytes ?? DEFAULT_ARTIFACT_MAX_BYTES;
+        const redactLog = async (inputPath, outputPath) => {
+            try {
+                return await redactFile(inputPath, outputPath, knownCredentialValues, maxArtifactBytes);
+            }
+            catch (err) {
+                if (err.code === 'ENOENT') {
+                    await writeFile(outputPath, '', 'utf8');
+                    return false;
+                }
+                throw err;
+            }
+        };
+        const [stdoutTruncated, stderrTruncated] = await Promise.all([
+            redactLog(result.stdoutPath, layout.stdoutPath),
+            redactLog(result.stderrPath, layout.stderrPath),
+        ]);
+        // Collect artifacts and persist every durable output BEFORE the trace is
+        // written. trace.json is the completion marker: it is written last, so a
+        // failure in any step above leaves a run directory with no trace.json,
+        // which cleanup removes and `yuurei trace show` cannot consume. The
+        // artifact list in the trace is derived from the manifest, so the two can
+        // never disagree (#111).
+        const manifest = await collectArtifacts(layout.runDir, ['stdout.log', 'stderr.log'], {
+            maxBytes: maxArtifactBytes,
+            truncatedPaths: [
+                ...(stdoutTruncated ? ['stdout.log'] : []),
+                ...(stderrTruncated ? ['stderr.log'] : []),
+            ],
+        });
+        await writeArtifactManifest(layout.runDir, manifest);
+        // Identity, not content: §10.1 records a digest of the profile content,
+        // and §10.2 keeps a profile's own secrets out of the durable run dir.
+        await writeFile(layout.resolvedProfilePath, JSON.stringify(toProfileManifest(cell.resolvedProfile), null, 2), 'utf8');
+        const trace = {
+            schema_version: TRACE_SCHEMA_VERSION,
+            run_id: runId,
+            started_at: result.startedAt,
+            finished_at: result.finishedAt,
+            runtime: fragment.runtime,
+            model: { requested: cell.requestedModel, resolved: fragment.model.resolved },
+            profile: { name: cell.resolvedProfile.name, digest: cell.resolvedProfile.digest },
+            task: { source: cell.resolvedTask.source, digest: cell.resolvedTask.digest },
+            isolation: { strategy: context.strategy, verified: true },
+            execution: {
+                exit_code: fragment.execution.exitCode,
+                signal: fragment.execution.signal,
+                duration_ms: fragment.execution.durationMs,
+                timed_out: result.timedOut,
+            },
+            usage: fragment.usage,
+            cost: costEstimate.amount === null
+                ? null
+                : { amount: costEstimate.amount, currency: costEstimate.currency ?? 'USD' },
+            // The actual artifacts just collected — mirrors artifacts.json rather
+            // than a placeholder empty list.
+            artifacts: manifest.artifacts.map(({ path, kind }) => ({ path, kind })),
+        };
+        await writeTrace(layout.runDir, trace);
+        traceWritten = true;
+        return { runId, runDir: layout.runDir, cell, trace };
+    }
+    catch (error) {
+        primaryError = error;
+        throw error;
+    }
+    finally {
+        // The finally block and the signal handler share ONE memoized cleanup
+        // promise (see `cleanup` above), so a signal arriving while this block is
+        // mid-cleanup joins the in-flight lifecycle instead of starting a second
+        // one: the handler's `await options.cleanup()` waits for the same
+        // scrub/dispose this block is awaiting, and its `process.exit()` fires
+        // only after both have settled. The handler stays installed until the
+        // cleanup has finished so a signal in that window is caught rather than
+        // taking the default disposition mid-rm; it is uninstalled last, closing
+        // the tiny post-completion window where an unrelated signal would be a
+        // no-op handler on an already-finished run.
+        try {
+            if (primaryError !== undefined) {
+                // The run already failed; a cleanup failure must not mask the primary
+                // error — report it via onWarning and let the original error propagate.
+                await cleanup().catch((cleanupError) => warn(`cleanup failed after the run failed: ${cleanupError instanceof Error ? cleanupError.message : String(cleanupError)}`));
+            }
+            else {
+                await cleanup();
+            }
+        }
+        finally {
+            signalCleanup.uninstall();
+        }
+    }
+}
+//# sourceMappingURL=pipeline.js.map

package/dist/run/pipeline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pipeline.js","sourceRoot":"","sources":["../../src/run/pipeline.ts"],"names":[],"mappings":"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"}

package/dist/run/signals.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Exit codes for dying to a caught signal, using the shell convention of
+ * 128 + signal number (SIGINT is 2, SIGTERM is 15). A parent shell or CI
+ * runner watching `yuurei run` sees the same code it would see for a
+ * normally-killed child, rather than yuurei reporting its own error code for
+ * an interruption it handled itself.
+ */
+export declare const SIGNAL_EXIT_CODES: Record<string, number>;
+/**
+ * Maps a signal name to the shell-convention exit code (128 + signal number).
+ * Handles SIGINT (130) and SIGTERM (143) by the well-known table; falls back
+ * to 128 for any other signal so the process never exits 0 for a killed run.
+ */
+export declare function exitCodeForSignal(signal: string): number;
+export interface SignalCleanupOptions {
+    /**
+     * Cleans up the active run (credential scrub + isolation dispose) and
+     * reports any non-fatal failure via the same warning channel the normal
+     * finally block uses. Must be safe to call more than once.
+     */
+    cleanup: () => Promise<void>;
+}
+export interface SignalCleanupHandle {
+    /**
+     * Removes both handlers so a signal arriving after the run completed
+     * normally hits the default disposition instead of re-entering the
+     * cleanup/exit path. The pipeline calls this from its finally block.
+     */
+    uninstall(): void;
+}
+/**
+ * Installs best-effort cleanup on SIGINT/SIGTERM for the duration of the
+ * active run. The handler runs the same guarded cleanup the pipeline's
+ * finally block runs, then exits with the shell-convention code for the
+ * received signal (130 for SIGINT, 143 for SIGTERM). This is what makes a
+ * signal-killed run clean up credential material and the isolation temp dir
+ * that an async try/finally alone would leave behind — the finally block
+ * cannot be entered once the signal's default action fires.
+ *
+ * The pipeline's finally block awaits the same cleanup promise before it
+ * returns, so the handler's `process.exit()` never preempts an in-flight
+ * dispose — the exit fires only after the cleanup has run. The first signal
+ * to arrive removes both handlers before cleaning up, so a second signal
+ * during cleanup keeps the default disposition (genuinely kills the process)
+ * rather than racing a second `process.exit()`; the finally block's
+ * `uninstall()` removes both handlers after a normal completion so an
+ * unrelated signal arriving after the run hits the default disposition.
+ *
+ * Deliberately not a guarantee: SIGKILL (and power loss / hard crash) still
+ * bypasses this, which is tracked separately.
+ */
+export declare function installSignalCleanup(options: SignalCleanupOptions): SignalCleanupHandle;
+//# sourceMappingURL=signals.d.ts.map

package/dist/run/signals.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.d.ts","sourceRoot":"","sources":["../../src/run/signals.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,eAAO,MAAM,iBAAiB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAGpD,CAAC;AAEF;;;;GAIG;AACH,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAExD;AAED,MAAM,WAAW,oBAAoB;IACnC;;;;OAIG;IACH,OAAO,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAC;CAC9B;AAED,MAAM,WAAW,mBAAmB;IAClC;;;;OAIG;IACH,SAAS,IAAI,IAAI,CAAC;CACnB;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,oBAAoB,GAAG,mBAAmB,CAiCvF"}

package/dist/run/signals.js

@@ -0,0 +1,74 @@
+import process from 'node:process';
+/**
+ * Exit codes for dying to a caught signal, using the shell convention of
+ * 128 + signal number (SIGINT is 2, SIGTERM is 15). A parent shell or CI
+ * runner watching `yuurei run` sees the same code it would see for a
+ * normally-killed child, rather than yuurei reporting its own error code for
+ * an interruption it handled itself.
+ */
+export const SIGNAL_EXIT_CODES = {
+    SIGINT: 130,
+    SIGTERM: 143,
+};
+/**
+ * Maps a signal name to the shell-convention exit code (128 + signal number).
+ * Handles SIGINT (130) and SIGTERM (143) by the well-known table; falls back
+ * to 128 for any other signal so the process never exits 0 for a killed run.
+ */
+export function exitCodeForSignal(signal) {
+    return SIGNAL_EXIT_CODES[signal] ?? 128;
+}
+/**
+ * Installs best-effort cleanup on SIGINT/SIGTERM for the duration of the
+ * active run. The handler runs the same guarded cleanup the pipeline's
+ * finally block runs, then exits with the shell-convention code for the
+ * received signal (130 for SIGINT, 143 for SIGTERM). This is what makes a
+ * signal-killed run clean up credential material and the isolation temp dir
+ * that an async try/finally alone would leave behind — the finally block
+ * cannot be entered once the signal's default action fires.
+ *
+ * The pipeline's finally block awaits the same cleanup promise before it
+ * returns, so the handler's `process.exit()` never preempts an in-flight
+ * dispose — the exit fires only after the cleanup has run. The first signal
+ * to arrive removes both handlers before cleaning up, so a second signal
+ * during cleanup keeps the default disposition (genuinely kills the process)
+ * rather than racing a second `process.exit()`; the finally block's
+ * `uninstall()` removes both handlers after a normal completion so an
+ * unrelated signal arriving after the run hits the default disposition.
+ *
+ * Deliberately not a guarantee: SIGKILL (and power loss / hard crash) still
+ * bypasses this, which is tracked separately.
+ */
+export function installSignalCleanup(options) {
+    const handlers = new Map();
+    const uninstall = () => {
+        for (const [signal, handler] of handlers) {
+            process.off(signal, handler);
+        }
+        handlers.clear();
+    };
+    for (const [signal, exitCode] of Object.entries(SIGNAL_EXIT_CODES)) {
+        const handler = async () => {
+            // First signal wins: removing both handlers here means a second signal
+            // during cleanup keeps the default action (kills the process) instead
+            // of being re-entered or racing a second process.exit().
+            uninstall();
+            try {
+                // cleanup is memoized, so this awaits the same lifecycle the
+                // pipeline's finally block is awaiting — process.exit() below cannot
+                // preempt an in-flight scrub/dispose.
+                await options.cleanup();
+            }
+            finally {
+                // Exit with the signal code regardless of whether cleanup itself
+                // failed (a failed cleanup reports its own onWarning; the run was
+                // still killed by the signal).
+                process.exit(exitCode);
+            }
+        };
+        handlers.set(signal, handler);
+        process.on(signal, handler);
+    }
+    return { uninstall };
+}
+//# sourceMappingURL=signals.js.map

package/dist/run/signals.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"signals.js","sourceRoot":"","sources":["../../src/run/signals.ts"],"names":[],"mappings":"AAAA,OAAO,OAAO,MAAM,cAAc,CAAC;AAEnC;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAA2B;IACvD,MAAM,EAAE,GAAG;IACX,OAAO,EAAE,GAAG;CACb,CAAC;AAEF;;;;GAIG;AACH,MAAM,UAAU,iBAAiB,CAAC,MAAc;IAC9C,OAAO,iBAAiB,CAAC,MAAM,CAAC,IAAI,GAAG,CAAC;AAC1C,CAAC;AAoBD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,MAAM,UAAU,oBAAoB,CAAC,OAA6B;IAChE,MAAM,QAAQ,GAAG,IAAI,GAAG,EAA+B,CAAC;IAExD,MAAM,SAAS,GAAG,GAAG,EAAE;QACrB,KAAK,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,IAAI,QAAQ,EAAE,CAAC;YACzC,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC/B,CAAC;QACD,QAAQ,CAAC,KAAK,EAAE,CAAC;IACnB,CAAC,CAAC;IAEF,KAAK,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,iBAAiB,CAAC,EAAE,CAAC;QACnE,MAAM,OAAO,GAAG,KAAK,IAAI,EAAE;YACzB,uEAAuE;YACvE,sEAAsE;YACtE,yDAAyD;YACzD,SAAS,EAAE,CAAC;YACZ,IAAI,CAAC;gBACH,6DAA6D;gBAC7D,qEAAqE;gBACrE,sCAAsC;gBACtC,MAAM,OAAO,CAAC,OAAO,EAAE,CAAC;YAC1B,CAAC;oBAAS,CAAC;gBACT,iEAAiE;gBACjE,kEAAkE;gBAClE,+BAA+B;gBAC/B,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YACzB,CAAC;QACH,CAAC,CAAC;QACF,QAAQ,CAAC,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;QAC9B,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,CAAC;IAED,OAAO,EAAE,SAAS,EAAE,CAAC;AACvB,CAAC"}

package/dist/runtime/claude-code/args.d.ts

@@ -0,0 +1,8 @@
+import type { ResolvedCell } from '../../cell/types.js';
+/**
+ * Builds the non-interactive CLI invocation for Claude Code. Kept isolated
+ * from the rest of the codebase so a future CLI flag change only touches
+ * this file (design doc §6.1: adapter-internal conventions must not leak).
+ */
+export declare function buildClaudeCodeArgs(cell: ResolvedCell): string[];
+//# sourceMappingURL=args.d.ts.map

package/dist/runtime/claude-code/args.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.d.ts","sourceRoot":"","sources":["../../../src/runtime/claude-code/args.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAExD;;;;GAIG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,GAAG,MAAM,EAAE,CAMhE"}

package/dist/runtime/claude-code/args.js

@@ -0,0 +1,13 @@
+/**
+ * Builds the non-interactive CLI invocation for Claude Code. Kept isolated
+ * from the rest of the codebase so a future CLI flag change only touches
+ * this file (design doc §6.1: adapter-internal conventions must not leak).
+ */
+export function buildClaudeCodeArgs(cell) {
+    const args = ['--print', '--output-format', 'json', cell.resolvedTask.content];
+    if (cell.requestedModel) {
+        args.push('--model', cell.requestedModel);
+    }
+    return args;
+}
+//# sourceMappingURL=args.js.map

package/dist/runtime/claude-code/args.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"args.js","sourceRoot":"","sources":["../../../src/runtime/claude-code/args.ts"],"names":[],"mappings":"AAEA;;;;GAIG;AACH,MAAM,UAAU,mBAAmB,CAAC,IAAkB;IACpD,MAAM,IAAI,GAAG,CAAC,SAAS,EAAE,iBAAiB,EAAE,MAAM,EAAE,IAAI,CAAC,YAAY,CAAC,OAAO,CAAC,CAAC;IAC/E,IAAI,IAAI,CAAC,cAAc,EAAE,CAAC;QACxB,IAAI,CAAC,IAAI,CAAC,SAAS,EAAE,IAAI,CAAC,cAAc,CAAC,CAAC;IAC5C,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/dist/runtime/claude-code/index.d.ts

@@ -0,0 +1,11 @@
+import type { IsolationContext } from '../../isolation/types.js';
+import type { ResolvedCell } from '../../cell/types.js';
+import type { NormalizationContext, NormalizedTraceFragment, PreparedRun, RegisterCredentialPath, Runtime, RuntimeDetection, RuntimeResult } from '../types.js';
+export declare class ClaudeCodeRuntime implements Runtime {
+    id(): string;
+    detect(): Promise<RuntimeDetection>;
+    prepare(cell: ResolvedCell, isolation: IsolationContext, _registerCredentialPath: RegisterCredentialPath): Promise<PreparedRun>;
+    execute(run: PreparedRun, timeoutMs: number | null): Promise<RuntimeResult>;
+    normalize(result: RuntimeResult, context: NormalizationContext): Promise<NormalizedTraceFragment>;
+}
+//# sourceMappingURL=index.d.ts.map

package/dist/runtime/claude-code/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/runtime/claude-code/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAEjE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAGxD,OAAO,KAAK,EACV,oBAAoB,EACpB,uBAAuB,EACvB,WAAW,EACX,sBAAsB,EACtB,OAAO,EACP,gBAAgB,EAChB,aAAa,EACd,MAAM,aAAa,CAAC;AA4CrB,qBAAa,iBAAkB,YAAW,OAAO;IAC/C,EAAE,IAAI,MAAM;IAIN,MAAM,IAAI,OAAO,CAAC,gBAAgB,CAAC;IAsBnC,OAAO,CACX,IAAI,EAAE,YAAY,EAClB,SAAS,EAAE,gBAAgB,EAC3B,uBAAuB,EAAE,sBAAsB,GAC9C,OAAO,CAAC,WAAW,CAAC;IAmCjB,OAAO,CAAC,GAAG,EAAE,WAAW,EAAE,SAAS,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,aAAa,CAAC;IAY3E,SAAS,CACb,MAAM,EAAE,aAAa,EACrB,OAAO,EAAE,oBAAoB,GAC5B,OAAO,CAAC,uBAAuB,CAAC;CA2DpC"}

package/dist/runtime/claude-code/index.js

@@ -0,0 +1,167 @@
+import { mkdir, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { configRootOf } from '../../isolation/config-root.js';
+import { detectViaVersionFlag, isVersionAtLeast } from '../detect.js';
+import { execCapture } from '../exec.js';
+import { writeFileTree } from '../../util/fs.js';
+import { assertNoReservedConfigPath } from '../reserved-paths.js';
+import { buildClaudeCodeArgs } from './args.js';
+import { claudeConfigDir } from './paths.js';
+const RUNTIME_ID = 'claude-code';
+const COMMAND = 'claude';
+const MIN_SUPPORTED_VERSION = [2, 0, 0];
+/**
+ * Claude Code resolves its credential store to `<config dir>/.credentials.json`
+ * (verified against 2.1.267: a token planted there is read, parsed and sent to
+ * the API). Unlike Codex there is no bridged credential *file* of yuurei's own
+ * to protect -- the reservation exists because the isolated run holds no
+ * credential at all under subscription login, so a profile-supplied one would
+ * be used unconditionally.
+ */
+const CLAUDE_RESERVED_CONFIG_PATHS = ['.credentials.json'];
+const CLAUDE_CREDENTIAL_ENV_KEYS = ['ANTHROPIC_API_KEY', 'ANTHROPIC_AUTH_TOKEN'];
+/**
+ * Approved method (design doc §9.2) for Claude Code: forward an explicitly-set
+ * API key or long-lived token from the parent environment. There is no
+ * credential *file* to reference — the interactive session token lives in the
+ * OS keychain, which §10.2 forbids reading. Operators who authenticated via
+ * subscription login run `claude setup-token` once and export the result.
+ * Never reads the keychain, never copies any part of the real ~/.claude.
+ * Returns the values actually forwarded, so the pipeline can redact them
+ * from persisted logs without needing to know their env var names.
+ */
+function bridgeClaudeCredentials(env) {
+    const forwardedValues = [];
+    for (const key of CLAUDE_CREDENTIAL_ENV_KEYS) {
+        const value = process.env[key];
+        if (value) {
+            env[key] = value;
+            forwardedValues.push(value);
+        }
+    }
+    return forwardedValues;
+}
+export class ClaudeCodeRuntime {
+    id() {
+        return RUNTIME_ID;
+    }
+    async detect() {
+        const detection = await detectViaVersionFlag(COMMAND);
+        const authUsable = detection.installed && CLAUDE_CREDENTIAL_ENV_KEYS.some((key) => Boolean(process.env[key]));
+        return {
+            ...detection,
+            versionSupported: isVersionAtLeast(detection.version, MIN_SUPPORTED_VERSION),
+            authUsable,
+            ...(detection.installed && authUsable === false
+                ? {
+                    authGuidance: 'Claude Code uses the OS credential store for interactive login, which yuurei never reads (design doc §9.2/§10.2). ' +
+                        'For subscription login, run `claude setup-token` once, then in this shell export the result as ANTHROPIC_AUTH_TOKEN. ' +
+                        'Re-run `yuurei doctor` and look for authUsable: true. ' +
+                        'Note: `claude auth status` may report loggedIn: true while yuurei reports authUsable: false — those check different stores. ' +
+                        'A shell export applies only to that shell and its child processes; do not persist the token in a profile, task, or committed file. ' +
+                        'Verify the variable is set without printing its value: [ -n "$ANTHROPIC_AUTH_TOKEN" ] && echo present || echo absent',
+                }
+                : {}),
+        };
+    }
+    async prepare(cell, isolation, _registerCredentialPath) {
+        const env = { ...isolation.env };
+        const configDir = claudeConfigDir(configRootOf(isolation));
+        await mkdir(configDir, { recursive: true, mode: 0o700 });
+        // Reject before anything is written, rather than relying on write order to
+        // paper over the collision (§9.2). Claude Code resolves its credential
+        // store from CLAUDE_CONFIG_DIR, which is exactly the directory the profile
+        // is materialized into.
+        assertNoReservedConfigPath(configDir, cell.resolvedProfile.content.configFiles, CLAUDE_RESERVED_CONFIG_PATHS);
+        await writeFileTree(configDir, cell.resolvedProfile.content.configFiles);
+        const credentialValuesToRedact = bridgeClaudeCredentials(env);
+        env['CLAUDE_CONFIG_DIR'] = configDir;
+        const detection = await this.detect();
+        return {
+            runtimeId: RUNTIME_ID,
+            command: COMMAND,
+            args: buildClaudeCodeArgs(cell),
+            env,
+            cwd: isolation.rootDir,
+            isolation,
+            cell,
+            runtimeVersion: detection.version,
+            // Credentials here are env vars only (bridgeClaudeCredentials above) —
+            // nothing is ever written to disk, so there is no path to register for
+            // the scrub.
+            credentialValuesToRedact,
+        };
+    }
+    async execute(run, timeoutMs) {
+        return execCapture({
+            command: run.command,
+            args: run.args,
+            env: run.env,
+            cwd: run.cwd,
+            stdoutPath: join(run.isolation.rootDir, 'stdout.log'),
+            stderrPath: join(run.isolation.rootDir, 'stderr.log'),
+            ...(timeoutMs !== null ? { timeoutMs } : {}),
+        });
+    }
+    async normalize(result, context) {
+        const durationMs = new Date(result.finishedAt).getTime() - new Date(result.startedAt).getTime();
+        let usage = {};
+        const warnings = [];
+        try {
+            const stdout = await readFile(result.stdoutPath, 'utf8');
+            let parsed;
+            try {
+                parsed = JSON.parse(stdout.trim());
+            }
+            catch {
+                warnings.push('claude-code: stdout was not valid JSON — usage unobserved');
+                parsed = undefined;
+            }
+            if (parsed !== undefined) {
+                if (typeof parsed === 'object' && parsed !== null) {
+                    const obj = parsed;
+                    const usageRaw = obj['usage'];
+                    if (typeof usageRaw === 'object' && usageRaw !== null) {
+                        const u = usageRaw;
+                        const pick = (key) => {
+                            const v = u[key];
+                            return typeof v === 'number' ? v : null;
+                        };
+                        usage = {
+                            input_tokens: pick('input_tokens'),
+                            output_tokens: pick('output_tokens'),
+                            cache_creation_input_tokens: pick('cache_creation_input_tokens'),
+                            cache_read_input_tokens: pick('cache_read_input_tokens'),
+                        };
+                    }
+                    else {
+                        warnings.push('claude-code: stdout JSON had no usage field — usage unobserved');
+                    }
+                }
+                else {
+                    warnings.push('claude-code: stdout JSON was not an object — usage unobserved');
+                }
+            }
+        }
+        catch (err) {
+            const code = err.code;
+            if (code === 'ENOENT') {
+                // Missing stdout is expected for killed/timed-out runs; warn only on normal exit
+                if (result.exitCode === 0 && result.signal === null && !result.timedOut) {
+                    warnings.push('claude-code: stdout absent after normal exit — usage unobserved');
+                }
+            }
+            else {
+                warnings.push(`claude-code: stdout unreadable (${err instanceof Error ? err.message : String(err)}) — usage unobserved`);
+            }
+        }
+        return {
+            runtime: { id: RUNTIME_ID, version: context.runtimeVersion },
+            model: { requested: '', resolved: null },
+            execution: { exitCode: result.exitCode, signal: result.signal, durationMs },
+            usage,
+            ...(warnings.length > 0 ? { warnings } : {}),
+        };
+    }
+}
+//# sourceMappingURL=index.js.map

package/dist/runtime/claude-code/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/runtime/claude-code/index.ts"],"names":[],"mappings":"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"}

package/dist/runtime/claude-code/paths.d.ts

@@ -0,0 +1,3 @@
+/** Claude Code's config root under a given HOME directory (real or isolated). */
+export declare function claudeConfigDir(homeDir: string): string;
+//# sourceMappingURL=paths.d.ts.map

package/dist/runtime/claude-code/paths.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.d.ts","sourceRoot":"","sources":["../../../src/runtime/claude-code/paths.ts"],"names":[],"mappings":"AAEA,iFAAiF;AACjF,wBAAgB,eAAe,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAEvD"}

package/dist/runtime/claude-code/paths.js

@@ -0,0 +1,6 @@
+import { join } from 'node:path';
+/** Claude Code's config root under a given HOME directory (real or isolated). */
+export function claudeConfigDir(homeDir) {
+    return join(homeDir, '.claude');
+}
+//# sourceMappingURL=paths.js.map

package/dist/runtime/claude-code/paths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"paths.js","sourceRoot":"","sources":["../../../src/runtime/claude-code/paths.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC,iFAAiF;AACjF,MAAM,UAAU,eAAe,CAAC,OAAe;IAC7C,OAAO,IAAI,CAAC,OAAO,EAAE,SAAS,CAAC,CAAC;AAClC,CAAC"}