@mcoda/codali 0.1.134 → 0.1.135-codali.4

package/dist/docdex/ManagedDocdex.js

@@ -0,0 +1,215 @@
+import { createServer } from "node:http";
+import { spawn } from "node:child_process";
+import { promises as fs } from "node:fs";
+import { createHash, randomBytes } from "node:crypto";
+import { registerSecretValue, StreamingSecretRedactor } from "../runtime/SecretRedaction.js";
+import path from "node:path";
+import { setTimeout as delay } from "node:timers/promises";
+import { DocdexClient } from "./DocdexClient.js";
+import { runtimeFileHash } from "./ManagedRuntime.js";
+const listen = (server) => new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", () => { server.removeListener("error", reject); resolve(server.address().port); });
+});
+const closeServer = async (server) => {
+    if (!server)
+        return;
+    server.closeAllConnections();
+    await new Promise(resolve => server.close(() => resolve()));
+};
+/** A private Docdex process whose inference is routed through the owning controller. */
+export class ManagedDocdex {
+    constructor(options) {
+        this.options = options;
+        this.diagnostic = "";
+        this.activeRequests = 0;
+        this.lifetime = new AbortController();
+    }
+    async start() {
+        this.options.signal?.throwIfAborted();
+        if (this.child || this.bridge)
+            throw new Error("Managed Docdex already started");
+        if (this.options.binarySha256 && (!this.options.binary || await runtimeFileHash(this.options.binary) !== this.options.binarySha256))
+            throw new Error("Managed Docdex runtime checksum mismatch; run codali doctor before continuing");
+        const { embeddings } = this.options;
+        const root = path.join(this.options.stateRoot, embeddings.space.id);
+        await embeddings.pin(root);
+        await fs.mkdir(root, { recursive: true, mode: 0o700 });
+        this.launchDirectory = await fs.mkdtemp(path.join(root, "launch-"));
+        const capability = randomBytes(32).toString("hex");
+        const authToken = randomBytes(32).toString("hex");
+        registerSecretValue(capability);
+        registerSecretValue(authToken);
+        const model = `codali-embedding-${embeddings.space.id}`;
+        const signal = AbortSignal.any([this.lifetime.signal, ...(this.options.signal ? [this.options.signal] : [])]);
+        const prefix = `/${capability}`;
+        this.bridge = createServer(async (request, response) => {
+            const send = (status, body) => { response.writeHead(status, { "content-type": "application/json" }); response.end(JSON.stringify(body)); };
+            if (request.headers.origin || !request.url?.startsWith(`${prefix}/`)) {
+                send(403, { error: "forbidden" });
+                return;
+            }
+            if (this.activeRequests >= 2) {
+                send(429, { error: "managed inference busy" });
+                return;
+            }
+            this.activeRequests++;
+            const requestAbort = new AbortController();
+            const onClose = () => { if (!response.writableEnded)
+                requestAbort.abort(); };
+            response.once("close", onClose);
+            try {
+                const route = request.url.slice(prefix.length);
+                if (request.method === "GET" && route === "/api/version") {
+                    send(200, { version: "codali-managed-v1" });
+                    return;
+                }
+                if (request.method === "GET" && route === "/api/tags") {
+                    send(200, { models: [{ name: "configured-docdex-helper", model: "configured-docdex-helper" }] });
+                    return;
+                }
+                if (request.method !== "POST") {
+                    send(405, { error: "method not allowed" });
+                    return;
+                }
+                let bytes = 0;
+                const chunks = [];
+                for await (const chunk of request) {
+                    bytes += chunk.length;
+                    if (bytes > 1048576) {
+                        send(413, { error: "request too large" });
+                        return;
+                    }
+                    chunks.push(Buffer.from(chunk));
+                }
+                const body = JSON.parse(Buffer.concat(chunks).toString());
+                const requestSignal = AbortSignal.any([signal, requestAbort.signal]);
+                if (route === "/v1/embeddings") {
+                    if (body.model !== model || !["query", "document"].includes(String(body.input_type))) {
+                        send(400, { error: "managed embedding identity and input_type are required" });
+                        return;
+                    }
+                    const input = typeof body.input === "string" ? [body.input] : body.input;
+                    if (!Array.isArray(input) || input.some(text => typeof text !== "string")) {
+                        send(400, { error: "invalid embedding input" });
+                        return;
+                    }
+                    const vectors = await embeddings.embed(input, body.input_type, requestSignal);
+                    send(200, { object: "list", model, data: vectors.map((embedding, index) => ({ object: "embedding", index, embedding })) });
+                    return;
+                }
+                if (body.model !== "configured-docdex-helper") {
+                    send(400, { error: "undeclared inference model" });
+                    return;
+                }
+                if (route === "/api/show") {
+                    send(200, { capabilities: ["completion"], model_info: { "general.architecture": "managed" } });
+                    return;
+                }
+                if (!["/api/chat", "/api/generate"].includes(route)) {
+                    send(404, { error: "unsupported managed inference operation" });
+                    return;
+                }
+                const messages = route === "/api/generate" && typeof body.prompt === "string"
+                    ? [{ role: "user", content: body.prompt }] : body.messages;
+                if (!Array.isArray(messages) || messages.length > 128 || messages.some(message => !message || !["system", "user", "assistant"].includes(message.role) || typeof message.content !== "string")) {
+                    send(400, { error: "invalid inference messages" });
+                    return;
+                }
+                const result = await this.options.provider.generate({ messages, signal: requestSignal, stream: false, maxTokens: 2048 });
+                send(200, { model: "configured-docdex-helper", created_at: new Date().toISOString(), done: true,
+                    message: { role: "assistant", content: result.message.content }, response: result.message.content,
+                    ...(result.usage ? { prompt_eval_count: result.usage.inputTokens, eval_count: result.usage.outputTokens } : {}) });
+            }
+            catch {
+                if (!response.headersSent)
+                    send(502, { error: "Managed inference failed; consult the owning session receipts" });
+            }
+            finally {
+                this.activeRequests--;
+                response.removeListener("close", onClose);
+            }
+        });
+        try {
+            const bridgePort = await listen(this.bridge);
+            const bridgeBase = `http://127.0.0.1:${bridgePort}${prefix}`;
+            const reservation = createServer();
+            const port = await listen(reservation);
+            await closeServer(reservation);
+            const configPath = path.join(this.launchDirectory, "config.toml");
+            const repositoryState = path.join(root, "repositories", createHash("sha256").update(path.resolve(this.options.workspaceRoot)).digest("hex"));
+            const config = `[core]\nglobal_state_dir = ${JSON.stringify(root)}\n[server]\nhttp_bind_addr = "127.0.0.1:${port}"\n[llm]\nprovider = "ollama"\nbase_url = ${JSON.stringify(bridgeBase)}\ndefault_model = "configured-docdex-helper"\nembedding_model = ${JSON.stringify(model)}\n[llm.delegation]\nenabled = false\nauto_enable = false\n[memory]\nenabled = true\n[memory.profile]\nembedding_model = "hash-embed-v1"\nembedding_dim = 768\n[memory.conversations]\nenabled = true\nauto_capture = false\n[memory.personal_preferences]\nenabled = false\n[memory.user_memory_sync]\nenabled = false\n`;
+            await fs.writeFile(configPath, config, { mode: 0o600, flag: "wx" });
+            const env = {};
+            for (const key of ["PATH", "HOME", "USER", "LOGNAME", "LANG", "TMPDIR", "SystemRoot"])
+                if (process.env[key])
+                    env[key] = process.env[key];
+            Object.assign(env, { DOCDEX_CONFIG_PATH: configPath, DOCDEX_AUTH_TOKEN: authToken,
+                DOCDEX_DAEMON_LOCK_PATH: path.join(this.launchDirectory, "daemon.lock"),
+                DOCDEX_MANAGED_INSTANCE: "1",
+                DOCDEX_HTTP_BASE_URL: `http://127.0.0.1:${port}`,
+                DOCDEX_EMBEDDING_PROVIDER: "llama-cpp", DOCDEX_EMBEDDING_BASE_URL: `${bridgeBase}/v1`, DOCDEX_EMBEDDING_MODEL: model,
+                DOCDEX_PROFILE_EMBEDDING_PROVIDER: "hash", DOCDEX_PROFILE_EMBEDDING_MODEL: "hash-embed-v1",
+                DOCDEX_PROFILE_STATE_DIR: path.join(this.options.stateRoot, "global-profile"),
+                DOCDEX_EMBEDDING_SEND_PURPOSE: "1", DOCDEX_EMBEDDING_STRICT: "1", DOCDEX_WEB_ENABLED: this.options.allowWeb ? "1" : "0",
+                DOCDEX_DISABLE_METRICS: "1", DOCDEX_WORKSPACE_METADATA: "0" });
+            this.child = spawn(this.options.binary ?? "docdexd", ["serve", "--repo", this.options.workspaceRoot, "--state-dir", repositoryState,
+                "--workspace-metadata=false", "--host", "127.0.0.1", "--port", String(port), "--enable-memory=true", "--enable-mcp", "--mcp-ipc", "off", "--preflight-check=false", "--log", "warn"], { env, stdio: ["ignore", "pipe", "pipe"], windowsHide: true });
+            let startError;
+            this.child.on("error", error => { startError = error; });
+            const diagnosticRedactor = new StreamingSecretRedactor();
+            const output = (chunk) => { this.diagnostic = (this.diagnostic + diagnosticRedactor.write(chunk.toString())).slice(-4000); };
+            this.child.stdout?.on("data", output);
+            this.child.stderr?.on("data", output);
+            this.abort = () => { this.child?.kill("SIGTERM"); };
+            signal.addEventListener("abort", this.abort, { once: true });
+            const baseUrl = `http://127.0.0.1:${port}`;
+            const deadline = Date.now() + (this.options.startupTimeoutMs ?? 90000);
+            this.options.onStatus?.("Starting private Docdex with configured embedding space");
+            while (true) {
+                signal.throwIfAborted();
+                if (startError || this.child.exitCode !== null || this.child.signalCode !== null)
+                    throw new Error(`Managed Docdex failed to start: ${startError?.message ?? this.diagnostic}`);
+                try {
+                    const response = await fetch(`${baseUrl}/v1/capabilities`, { headers: { authorization: `Bearer ${authToken}` }, signal: AbortSignal.any([signal, AbortSignal.timeout(1500)]) });
+                    if (response.ok) {
+                        const capabilities = await response.json();
+                        if (!["workspace_metadata_control", "embedding_input_type", "strict_repo_embeddings", "deterministic_profile_embeddings"].every(key => capabilities.managed_clients?.[key]))
+                            throw new Error("Managed Docdex capabilities missing");
+                        return new DocdexClient({ baseUrl, repoRoot: this.options.workspaceRoot, authToken, localSearchOnly: true, timeoutMs: 30000, signal: () => signal });
+                    }
+                }
+                catch (error) {
+                    if (error instanceof Error && error.message === "Managed Docdex capabilities missing")
+                        throw error;
+                }
+                if (Date.now() >= deadline)
+                    throw new Error(`Managed Docdex startup timed out: ${this.diagnostic}`);
+                await delay(200, undefined, { signal });
+            }
+        }
+        catch (error) {
+            await this.close();
+            throw error;
+        }
+    }
+    async close() {
+        this.lifetime.abort();
+        const child = this.child;
+        this.child = undefined;
+        if (child && child.exitCode === null && child.signalCode === null) {
+            const exited = new Promise(resolve => child.once("exit", () => resolve()));
+            child.kill("SIGTERM");
+            await Promise.race([exited, delay(3000)]);
+            if (child.exitCode === null && child.signalCode === null) {
+                child.kill("SIGKILL");
+                await Promise.race([exited, delay(1000)]);
+            }
+        }
+        await closeServer(this.bridge);
+        this.bridge = undefined;
+        if (this.launchDirectory)
+            await fs.rm(this.launchDirectory, { recursive: true, force: true });
+        this.launchDirectory = undefined;
+    }
+}

package/dist/docdex/ManagedRuntime.d.ts

@@ -0,0 +1,28 @@
+export interface ManagedRuntimeIdentity {
+    binary: string;
+    binarySha256: string;
+    version: string;
+}
+export interface ManagedRuntimeArtifact {
+    url: string;
+    archiveSha256: string;
+    binarySha256: string;
+}
+export interface ManagedRuntimeManifest {
+    schemaVersion: 1;
+    version?: string;
+    artifacts: Record<string, ManagedRuntimeArtifact>;
+}
+export declare const runtimeFileHash: (file: string) => Promise<string>;
+/** No daemon, repo initialization, model request or global configuration access. */
+export declare const inspectManagedDocdexRuntime: (binary: string, expectedSha256?: string, signal?: AbortSignal, redirected?: boolean) => Promise<ManagedRuntimeIdentity>;
+export declare const runtimePlatformKey: () => string;
+export declare const validateRuntimeManifest: (value: unknown) => ManagedRuntimeManifest;
+/** Content-addressed private install. A failed upgrade leaves existing versions untouched. */
+export declare const ensureManagedDocdexRuntime: (options?: {
+    binary?: string;
+    stateRoot?: string;
+    manifest?: ManagedRuntimeManifest;
+    signal?: AbortSignal;
+}) => Promise<ManagedRuntimeIdentity>;
+//# sourceMappingURL=ManagedRuntime.d.ts.map

package/dist/docdex/ManagedRuntime.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ManagedRuntime.d.ts","sourceRoot":"","sources":["../../src/docdex/ManagedRuntime.ts"],"names":[],"mappings":"AAUA,MAAM,WAAW,sBAAsB;IAAG,MAAM,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAC;CAAE;AAClG,MAAM,WAAW,sBAAsB;IAAG,GAAG,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,MAAM,CAAC;CAAE;AACrG,MAAM,WAAW,sBAAsB;IAAG,aAAa,EAAE,CAAC,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAC;CAAE;AAalI,eAAO,MAAM,eAAe,GAAU,MAAM,MAAM,KAAG,OAAO,CAAC,MAAM,CAKlE,CAAC;AAEF,oFAAoF;AACpF,eAAO,MAAM,2BAA2B,GAAU,QAAQ,MAAM,EAAE,iBAAiB,MAAM,EAAE,SAAS,WAAW,EAAE,oBAAkB,KAAG,OAAO,CAAC,sBAAsB,CA0BnK,CAAC;AAEF,eAAO,MAAM,kBAAkB,QAAO,MAOrC,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,sBAUxD,CAAC;AAkBF,8FAA8F;AAC9F,eAAO,MAAM,0BAA0B,GAAU,UAAS;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,SAAS,CAAC,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,sBAAsB,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAAO,KAAG,OAAO,CAAC,sBAAsB,CAkD/L,CAAC"}

package/dist/docdex/ManagedRuntime.js

@@ -0,0 +1,212 @@
+import { createHash } from "node:crypto";
+import { createReadStream, promises as fs } from "node:fs";
+import { execFile } from "node:child_process";
+import os from "node:os";
+import path from "node:path";
+import { withStateLock } from "../session/AtomicState.js";
+const FEATURES = ["workspace_metadata_control", "embedding_input_type", "strict_repo_embeddings", "deterministic_profile_embeddings"];
+const MAX_ARCHIVE_BYTES = 128 * 1024 * 1024;
+const MAX_BINARY_BYTES = 256 * 1024 * 1024;
+const cleanEnvironment = () => {
+    const env = {};
+    for (const key of ["PATH", "HOME", "USER", "LOGNAME", "TMPDIR", "SystemRoot"])
+        if (process.env[key])
+            env[key] = process.env[key];
+    return env;
+};
+const execute = (command, args, options) => new Promise((resolve, reject) => {
+    execFile(command, args, { ...options, env: cleanEnvironment(), encoding: "buffer", timeout: 30000, maxBuffer: options.maxBuffer ?? 64 * 1024, windowsHide: true }, (error, stdout) => {
+        if (error)
+            reject(new Error(`Docdex runtime command failed (${path.basename(command)}): ${error.code ?? "unknown"}`));
+        else
+            resolve(stdout);
+    });
+});
+export const runtimeFileHash = async (file) => {
+    const stat = await fs.lstat(file);
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > MAX_BINARY_BYTES)
+        throw new Error("Docdex runtime must be a bounded regular file");
+    const hash = createHash("sha256");
+    for await (const chunk of createReadStream(file))
+        hash.update(chunk);
+    return hash.digest("hex");
+};
+/** No daemon, repo initialization, model request or global configuration access. */
+export const inspectManagedDocdexRuntime = async (binary, expectedSha256, signal, redirected = false) => {
+    let resolved = binary;
+    if (!path.isAbsolute(binary)) {
+        if (binary.includes(path.sep))
+            throw new Error("Docdex binary must be an absolute path or a PATH command");
+        resolved = "";
+        for (const directory of (process.env.PATH ?? "").split(path.delimiter).filter(path.isAbsolute)) {
+            const candidate = path.join(directory, binary);
+            try {
+                await fs.access(candidate, fs.constants.X_OK);
+                resolved = candidate;
+                break;
+            }
+            catch { /* next trusted PATH entry */ }
+        }
+        if (!resolved)
+            throw new Error("No compatible Docdex runtime found on PATH");
+    }
+    resolved = await fs.realpath(resolved);
+    const binarySha256 = await runtimeFileHash(resolved);
+    if (expectedSha256 && expectedSha256 !== binarySha256)
+        throw new Error("Docdex runtime checksum mismatch");
+    const cwd = await fs.mkdtemp(path.join(os.tmpdir(), "codali-runtime-probe-"));
+    try {
+        const info = JSON.parse((await execute(resolved, ["runtime-info"], { cwd, signal })).toString());
+        if (info.schema_version !== 1 || typeof info.version !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(info.version) || !FEATURES.every(feature => info.managed_clients?.[feature] === true))
+            throw new Error("Docdex runtime lacks required managed-client capabilities");
+        if (typeof info.executable !== "string" || !path.isAbsolute(info.executable))
+            throw new Error("Docdex runtime did not identify its native executable");
+        const native = await fs.realpath(info.executable);
+        if (native !== resolved) {
+            if (redirected || expectedSha256)
+                throw new Error("Docdex runtime executable changed during qualification");
+            return inspectManagedDocdexRuntime(native, undefined, signal, true);
+        }
+        return { binary: resolved, binarySha256, version: info.version };
+    }
+    finally {
+        await fs.rm(cwd, { recursive: true, force: true });
+    }
+};
+export const runtimePlatformKey = () => {
+    if (process.platform === "darwin")
+        return `darwin-${process.arch}`;
+    if (process.platform === "linux") {
+        const report = process.report?.getReport();
+        return `linux-${process.arch}-${report?.header?.glibcVersionRuntime ? "gnu" : "musl"}`;
+    }
+    throw new Error(`Managed Codali runtime is not qualified for ${process.platform}-${process.arch}`);
+};
+export const validateRuntimeManifest = (value) => {
+    const manifest = value;
+    if (!manifest || manifest.schemaVersion !== 1 || !manifest.artifacts || typeof manifest.artifacts !== "object" || Array.isArray(manifest.artifacts))
+        throw new Error("Invalid Docdex runtime manifest");
+    if (manifest.version !== undefined && (typeof manifest.version !== "string" || !/^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?$/.test(manifest.version)))
+        throw new Error("Invalid Docdex release version");
+    for (const [platform, artifact] of Object.entries(manifest.artifacts)) {
+        if (!/^(linux-(x64|arm64)-(gnu|musl)|darwin-(x64|arm64))$/.test(platform) || !manifest.version || !artifact || typeof artifact.url !== "string" || typeof artifact.archiveSha256 !== "string" || typeof artifact.binarySha256 !== "string" || !/^[a-f0-9]{64}$/.test(artifact.archiveSha256) || !/^[a-f0-9]{64}$/.test(artifact.binarySha256))
+            throw new Error("Invalid pinned Docdex artifact");
+        const url = new URL(artifact.url);
+        if (url.origin !== "https://github.com" || url.username || url.password || url.search || url.hash || !url.pathname.startsWith(`/bekirdag/docdex/releases/download/v${manifest.version}/`) || !url.pathname.endsWith(".tar.gz"))
+            throw new Error("Docdex artifact must come from the pinned publisher release");
+    }
+    return manifest;
+};
+const download = async (artifact, destination, signal) => {
+    const response = await fetch(artifact.url, { signal: AbortSignal.any([AbortSignal.timeout(120000), ...(signal ? [signal] : [])]), credentials: "omit", referrerPolicy: "no-referrer" });
+    if (!response.ok || !response.body)
+        throw new Error(`Docdex runtime download failed (${response.status})`);
+    if (response.url && new URL(response.url).protocol !== "https:")
+        throw new Error("Insecure Docdex download redirect");
+    if (Number(response.headers.get("content-length")) > MAX_ARCHIVE_BYTES) {
+        await response.body.cancel();
+        throw new Error("Docdex runtime archive exceeds the download limit");
+    }
+    const handle = await fs.open(destination, "wx", 0o600);
+    const hash = createHash("sha256");
+    let bytes = 0;
+    try {
+        for await (const chunk of response.body) {
+            bytes += chunk.length;
+            if (bytes > MAX_ARCHIVE_BYTES)
+                throw new Error("Docdex runtime archive exceeds the download limit");
+            hash.update(chunk);
+            await handle.writeFile(chunk);
+        }
+        await handle.sync();
+        if (hash.digest("hex") !== artifact.archiveSha256)
+            throw new Error("Docdex runtime archive checksum mismatch");
+    }
+    finally {
+        await handle.close();
+    }
+};
+/** Content-addressed private install. A failed upgrade leaves existing versions untouched. */
+export const ensureManagedDocdexRuntime = async (options = {}) => {
+    if (options.binary)
+        return inspectManagedDocdexRuntime(options.binary, undefined, options.signal);
+    const manifest = validateRuntimeManifest(options.manifest ?? JSON.parse(await fs.readFile(new URL("../../config/docdex-runtime.json", import.meta.url), "utf8")));
+    const artifact = manifest.artifacts[runtimePlatformKey()];
+    if (!artifact) {
+        throw new Error("This build has no qualified Docdex release for this platform. Supply --docdex-binary with a compatible runtime or install a qualified Codali release.");
+    }
+    const root = path.resolve(options.stateRoot ?? path.join(os.homedir(), ".local", "state", "codali", "runtimes", "docdex"));
+    await fs.mkdir(root, { recursive: true, mode: 0o700 });
+    const rootStat = await fs.lstat(root);
+    if (!rootStat.isDirectory() || rootStat.isSymbolicLink() || rootStat.mode & 0o077 || (process.getuid && rootStat.uid !== process.getuid()))
+        throw new Error("Docdex runtime directory must be private and owned by the current user");
+    const destination = path.join(root, artifact.binarySha256);
+    return withStateLock(path.join(root, "install"), async () => {
+        options.signal?.throwIfAborted();
+        // The OS-owned lock is released after a killed installer. Only its private
+        // staging directories are disposable; committed versions are never pruned.
+        for (const entry of await fs.readdir(root, { withFileTypes: true })) {
+            if (/^\.install-[A-Za-z0-9]+$/.test(entry.name) && entry.isDirectory())
+                await fs.rm(path.join(root, entry.name), { recursive: true });
+        }
+        let cached = false;
+        try {
+            const directory = await fs.lstat(destination);
+            if (!directory.isDirectory() || directory.isSymbolicLink() || directory.mode & 0o077 || (process.getuid && directory.uid !== process.getuid()))
+                throw new Error("Docdex cached release must be a private directory");
+            cached = true;
+        }
+        catch (error) {
+            if (error.code !== "ENOENT")
+                throw error;
+        }
+        if (cached) {
+            if (await runtimeFileHash(path.join(destination, "docdexd")) !== artifact.binarySha256)
+                throw new Error("Docdex runtime checksum mismatch");
+            const info = await inspectManagedDocdexRuntime(path.join(destination, "docdexd"), artifact.binarySha256, options.signal);
+            if (info.version !== manifest.version)
+                throw new Error("Docdex runtime version does not match the manifest");
+            return info;
+        }
+        const staging = await fs.mkdtemp(path.join(root, ".install-"));
+        try {
+            const archive = path.join(staging, "runtime.tar.gz");
+            await download(artifact, archive, options.signal);
+            // Extract only the single pinned member to bytes, never paths from
+            // an archive. No package lifecycle scripts or machine-wide installers run.
+            const bytes = await execute("tar", ["-xOf", archive, "docdexd"], { cwd: staging, signal: options.signal, maxBuffer: MAX_BINARY_BYTES });
+            if (createHash("sha256").update(bytes).digest("hex") !== artifact.binarySha256)
+                throw new Error("Docdex extracted binary checksum mismatch");
+            const binary = path.join(staging, "docdexd");
+            const handle = await fs.open(binary, "wx", 0o700);
+            try {
+                await handle.writeFile(bytes);
+                await handle.sync();
+            }
+            finally {
+                await handle.close();
+            }
+            const info = await inspectManagedDocdexRuntime(binary, artifact.binarySha256, options.signal);
+            if (info.version !== manifest.version)
+                throw new Error("Docdex runtime version does not match the manifest");
+            options.signal?.throwIfAborted();
+            await fs.unlink(archive);
+            await fs.rename(staging, destination);
+            const directory = await fs.open(root, "r");
+            try {
+                await directory.sync();
+            }
+            catch (error) {
+                if (!["EINVAL", "ENOTSUP"].includes(error.code ?? ""))
+                    throw error;
+            }
+            finally {
+                await directory.close();
+            }
+            return { ...info, binary: await fs.realpath(path.join(destination, "docdexd")) };
+        }
+        finally {
+            await fs.rm(staging, { recursive: true, force: true });
+        }
+    }, 180000);
+};

package/dist/eval/EvaluationProcess.d.ts

@@ -0,0 +1,13 @@
+import type { OrchestrationConfig } from "../config/OrchestrationConfig.js";
+/** A trusted evaluator child runs the CLI itself, so it needs only the declared
+ * provider credentials. This is never used for model-requested shell tools. */
+export declare function evaluationEnvironment(config: OrchestrationConfig): NodeJS.ProcessEnv;
+export declare function runEvaluationProcess(options: {
+    file: string;
+    args: string[];
+    cwd: string;
+    config: OrchestrationConfig;
+    timeoutMs: number;
+    signal?: AbortSignal;
+}): Promise<void>;
+//# sourceMappingURL=EvaluationProcess.d.ts.map

package/dist/eval/EvaluationProcess.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"EvaluationProcess.d.ts","sourceRoot":"","sources":["../../src/eval/EvaluationProcess.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAE5E;+EAC+E;AAC/E,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAAC,UAAU,CAQpF;AAED,wBAAsB,oBAAoB,CAAC,OAAO,EAAE;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,EAAE,CAAC;IAAC,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,mBAAmB,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CA+BtL"}

package/dist/eval/EvaluationProcess.js

@@ -0,0 +1,76 @@
+import { spawn } from "node:child_process";
+import os from "node:os";
+import { safeProcessEnvironment } from "../tools/shell/AsyncProcess.js";
+/** A trusted evaluator child runs the CLI itself, so it needs only the declared
+ * provider credentials. This is never used for model-requested shell tools. */
+export function evaluationEnvironment(config) {
+    const env = { ...safeProcessEnvironment(), HOME: os.homedir() };
+    for (const provider of Object.values(config.providers)) {
+        if (!provider.credentialRef?.startsWith("env:"))
+            continue;
+        const key = provider.credentialRef.slice(4);
+        if (/^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && process.env[key] !== undefined)
+            env[key] = process.env[key];
+    }
+    return env;
+}
+export async function runEvaluationProcess(options) {
+    options.signal?.throwIfAborted();
+    if (!Number.isSafeInteger(options.timeoutMs) || options.timeoutMs < 1)
+        throw new Error("Invalid evaluator deadline");
+    await new Promise((resolve, reject) => {
+        const child = spawn(process.execPath, [options.file, ...options.args], { cwd: options.cwd, env: evaluationEnvironment(options.config),
+            detached: process.platform !== "win32", stdio: ["ignore", "pipe", "pipe"] });
+        let output = "";
+        let bytes = 0;
+        let failure;
+        let escalation;
+        const kill = (signal) => {
+            if (!child.pid)
+                return;
+            try {
+                if (process.platform !== "win32")
+                    process.kill(-child.pid, signal);
+                else
+                    child.kill(signal);
+            }
+            catch (error) {
+                if (error.code !== "ESRCH")
+                    child.kill(signal);
+            }
+        };
+        const stop = () => { kill("SIGTERM"); escalation ?? (escalation = setTimeout(() => kill("SIGKILL"), 3000)); escalation.unref(); };
+        const timeout = setTimeout(() => { failure = new Error("Evaluation stage deadline exceeded"); stop(); }, options.timeoutMs);
+        const capture = (chunk) => {
+            bytes += chunk.length;
+            if (bytes <= 131072)
+                output += chunk.toString("utf8");
+            else {
+                failure ?? (failure = new Error("Evaluation stage output exceeded its bound"));
+                stop();
+            }
+        };
+        child.stdout.on("data", capture);
+        child.stderr.on("data", capture);
+        options.signal?.addEventListener("abort", stop, { once: true });
+        if (options.signal?.aborted)
+            stop();
+        child.once("error", error => { failure = error; });
+        child.once("close", (code, signal) => {
+            clearTimeout(timeout);
+            if (escalation)
+                clearTimeout(escalation);
+            options.signal?.removeEventListener("abort", stop);
+            if (process.platform !== "win32")
+                kill("SIGKILL");
+            if (options.signal?.aborted)
+                reject(options.signal.reason ?? new Error("Evaluation cancelled"));
+            else if (failure)
+                reject(failure);
+            else if (code !== 0 || signal)
+                reject(new Error(output.slice(-8000) || `Evaluation exited ${code ?? signal}`));
+            else
+                resolve();
+        });
+    });
+}

package/dist/eval/LongWorkflowJourney.d.ts

@@ -0,0 +1,34 @@
+import type { WorkState } from "../session/WorkTypes.js";
+export declare const LONG_WORKFLOW_VERSION = "long-workflows-v2";
+export declare const longWorkflowScenarios: readonly [{
+    readonly id: "data-delivery";
+    readonly objective: "Deliver a reliable data-processing toolkit with exact money totals, validated imports, CSV export and additive record migration.";
+    readonly modules: readonly ["invoice-cents", "jsonl-import", "csv-export", "additive-record-migration"];
+}, {
+    readonly id: "service-adapters";
+    readonly objective: "Deliver a service-adapter toolkit with safe headers, bounded async execution, locale fallback and interval reservations.";
+    readonly modules: readonly ["header-normalization", "async-worker-pool", "locale-fallback", "interval-reservation"];
+}, {
+    readonly id: "billing-audit";
+    readonly objective: "Deliver a billing-readiness package: source-backed duplicate-submit and tenant-isolation reports, exact invoice totals and a data-preserving migration.";
+    readonly modules: readonly ["investigate-duplicate-submit", "investigate-tenant-key", "invoice-cents", "additive-record-migration"];
+}, {
+    readonly id: "localized-export";
+    readonly objective: "Deliver localized export adapters with CSV correctness, normalized headers and a source-backed fictional render-service upgrade report.";
+    readonly modules: readonly ["locale-fallback", "csv-export", "header-normalization", "research-pinned-upgrade"];
+}];
+export type LongWorkflowScenario = typeof longWorkflowScenarios[number];
+export declare const longWorkflowHash: () => string;
+export declare function longWorkflowPrompt(scenario: LongWorkflowScenario): string;
+/** One invocation is one OS process in the parent runner. Stage 2 deliberately
+ * checkpoints after a verified task, never during a pending side effect. */
+export declare function runLongWorkflowStage(descriptorPath: string, stage: number): Promise<void>;
+export declare function gradeLongWorkflowState(objective: string, state: WorkState, initial?: WorkState): string[];
+export declare function runLongWorkflowJourney(options: {
+    configPath: string;
+    outputRoot: string;
+    scenarioId: string;
+    signal?: AbortSignal;
+    onProgress?: (event: Record<string, unknown>) => void;
+}): Promise<void>;
+//# sourceMappingURL=LongWorkflowJourney.d.ts.map

package/dist/eval/LongWorkflowJourney.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LongWorkflowJourney.d.ts","sourceRoot":"","sources":["../../src/eval/LongWorkflowJourney.ts"],"names":[],"mappings":"AAUA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AAGzD,eAAO,MAAM,qBAAqB,sBAAsB,CAAC;AACzD,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;EAKxB,CAAC;AACX,MAAM,MAAM,oBAAoB,GAAG,OAAO,qBAAqB,CAAC,MAAM,CAAC,CAAC;AAExE,eAAO,MAAM,gBAAgB,cAAiN,CAAC;AAI/O,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,oBAAoB,GAAG,MAAM,CAGzE;AAMD;4EAC4E;AAC5E,wBAAsB,oBAAoB,CAAC,cAAc,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAmD/F;AAED,wBAAgB,sBAAsB,CAAC,SAAS,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE,OAAO,CAAC,EAAE,SAAS,GAAG,MAAM,EAAE,CA2BzG;AAED,wBAAsB,sBAAsB,CAAC,OAAO,EAAE;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,WAAW,CAAC;IAAC,UAAU,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAK,IAAI,CAAA;CAAE,GAAG,OAAO,CAAC,IAAI,CAAC,CAqDhN"}