@alisio/core 0.6.0 → 0.7.0

package/dist/eval/verifiers.js

@@ -0,0 +1,264 @@
+/**
+ * Deterministic, local verifiers of the reliability lab (specs/010 D4). A verifier answers
+ * `pass`, `fail` or `error`; `error` means it could not run (bad path, missing input, command that
+ * cannot start) and is never folded into `fail`. Details never echo file contents.
+ *
+ * `command` runs a subprocess with a clean environment and a timeout. A subprocess is NOT a
+ * sandbox: suites are trusted repository code and the command runs with the user's privileges.
+ */
+import { spawn } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, lstatSync, readdirSync, readFileSync, readlinkSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { EvalPathError, resolveInside, unsafeRelativeReason } from "./paths.js";
+const IGNORED_DIRS = new Set([".git", "node_modules"]);
+const MAX_COMMAND_OUTPUT = 1_000_000;
+const sha256 = (data) => createHash("sha256").update(data).digest("hex");
+/**
+ * Hashes every file under `dir` (symlinks by their target text, never followed). `.git` and
+ * `node_modules` are skipped at any depth: they are tooling state, not task output.
+ */
+export function snapshotTree(dir) {
+    const files = {};
+    const walk = (current, prefix) => {
+        for (const entry of readdirSync(current, { withFileTypes: true })) {
+            const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+            const full = join(current, entry.name);
+            if (entry.isSymbolicLink())
+                files[rel] = sha256(`symlink:${readlinkSync(full)}`);
+            else if (entry.isDirectory()) {
+                if (!IGNORED_DIRS.has(entry.name))
+                    walk(full, rel);
+            }
+            else if (entry.isFile())
+                files[rel] = sha256(readFileSync(full));
+        }
+    };
+    walk(dir, "");
+    const hash = sha256(Object.keys(files)
+        .sort()
+        .map((path) => `${path}\0${files[path]}`)
+        .join("\n"));
+    return { files, hash };
+}
+const result = (v, status, detail) => ({
+    id: v.id,
+    status,
+    ...(detail === undefined ? {} : { detail }),
+});
+function isMissing(error) {
+    return error?.code === "ENOENT";
+}
+function runCommand(v, cwd, tmpDir) {
+    return new Promise((resolve) => {
+        const [bin, ...args] = v.command;
+        if (bin === undefined)
+            return resolve(result(v, "error", "command is empty."));
+        if (!existsSync(cwd) || !statSync(cwd).isDirectory())
+            return resolve(result(v, "error", "working directory does not exist."));
+        const env = { PATH: process.env.PATH ?? "", NODE_NO_WARNINGS: "1" };
+        if (process.env.SystemRoot)
+            env.SystemRoot = process.env.SystemRoot;
+        if (tmpDir) {
+            env.HOME = tmpDir;
+            env.TMPDIR = tmpDir;
+        }
+        let stdout = "";
+        let timedOut = false;
+        let settled = false;
+        const done = (value) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timer);
+            resolve(value);
+        };
+        // The child leads its own process group (POSIX) so a timeout can stop grandchildren too.
+        const detached = process.platform !== "win32";
+        const child = spawn(bin, args, {
+            cwd,
+            env,
+            stdio: ["ignore", "pipe", "ignore"],
+            shell: false,
+            detached,
+        });
+        const timer = setTimeout(() => {
+            timedOut = true;
+            try {
+                if (detached && child.pid !== undefined)
+                    process.kill(-child.pid, "SIGKILL");
+                else
+                    child.kill("SIGKILL");
+            }
+            catch {
+                child.kill("SIGKILL");
+            }
+        }, v.timeoutMs);
+        child.stdout.on("data", (chunk) => {
+            if (stdout.length < MAX_COMMAND_OUTPUT)
+                stdout += chunk.toString("utf8");
+        });
+        child.on("error", (error) => done(result(v, "error", `command could not start: ${error.message}`)));
+        child.on("close", (code, signal) => {
+            // The command is the task's own check running agent-written code: a hang is the agent's
+            // failure, not an infrastructure error (a command that cannot start stays `error`).
+            if (timedOut)
+                return done(result(v, "fail", `command timed out after ${v.timeoutMs} ms.`));
+            const expected = v.expectExit ?? 0;
+            if (code !== expected)
+                return done(result(v, "fail", signal ? `terminated by ${signal}.` : `exit ${code}, expected exit ${expected}.`));
+            if (v.expectStdoutIncludes !== undefined && !stdout.includes(v.expectStdoutIncludes))
+                return done(result(v, "fail", "stdout does not include the expected text."));
+            done(result(v, "pass"));
+        });
+    });
+}
+function readTarget(path) {
+    try {
+        return { data: readFileSync(path) };
+    }
+    catch (error) {
+        if (isMissing(error))
+            return { missing: true };
+        throw error;
+    }
+}
+function diffTree(baseline, current) {
+    const added = [];
+    const deleted = [];
+    const modified = [];
+    for (const [path, hash] of Object.entries(current.files)) {
+        const before = baseline.files[path];
+        if (before === undefined)
+            added.push(path);
+        else if (before !== hash)
+            modified.push(path);
+    }
+    for (const path of Object.keys(baseline.files))
+        if (!(path in current.files))
+            deleted.push(path);
+    return { added, deleted, modified };
+}
+/** `a/b.ts` allows exactly that file; `a/` allows everything below the directory `a`. */
+const isAllowed = (path, allowed) => allowed.some((entry) => (entry.endsWith("/") ? path.startsWith(entry) : path === entry));
+function checkSequence(rule, events) {
+    switch (rule.type) {
+        case "before": {
+            const firstAt = events.findIndex((e) => e.tool === rule.first);
+            const thenAt = events.findIndex((e) => e.tool === rule.then);
+            if (thenAt === -1)
+                return { ok: true };
+            return firstAt !== -1 && firstAt < thenAt
+                ? { ok: true }
+                : { ok: false, detail: `"${rule.then}" was called without a prior "${rule.first}".` };
+        }
+        case "never":
+            return events.some((e) => e.tool === rule.tool)
+                ? { ok: false, detail: `"${rule.tool}" must never be called.` }
+                : { ok: true };
+        case "max-calls": {
+            const calls = events.filter((e) => e.tool === rule.tool).length;
+            return calls > rule.max
+                ? { ok: false, detail: `"${rule.tool}" was called ${calls} times, maximum ${rule.max}.` }
+                : { ok: true };
+        }
+        case "no-repeat-failure": {
+            const failed = new Set();
+            for (const e of events) {
+                if (e.tool !== rule.tool)
+                    continue;
+                const key = e.argsKey ?? "";
+                if (failed.has(key))
+                    return {
+                        ok: false,
+                        detail: `"${rule.tool}" repeated an identical call that had failed.`,
+                    };
+                if (!e.ok)
+                    failed.add(key);
+            }
+            return { ok: true };
+        }
+    }
+}
+async function evaluate(v, ctx) {
+    switch (v.kind) {
+        case "command":
+            return runCommand(v, ctx.cwd, ctx.tmpDir);
+        case "file-equals": {
+            const target = readTarget(resolveInside(ctx.cwd, v.path, "path"));
+            if ("missing" in target)
+                return result(v, "fail", `${v.path} does not exist.`);
+            return sha256(target.data) === v.sha256.toLowerCase()
+                ? result(v, "pass")
+                : result(v, "fail", `${v.path} sha256 differs from the expected value.`);
+        }
+        case "file-contains": {
+            const target = readTarget(resolveInside(ctx.cwd, v.path, "path"));
+            if ("missing" in target)
+                return result(v, "fail", `${v.path} does not exist.`);
+            return target.data.toString("utf8").includes(v.text)
+                ? result(v, "pass")
+                : result(v, "fail", `${v.path} does not contain the expected text.`);
+        }
+        case "file-absent": {
+            const absolute = resolveInside(ctx.cwd, v.path, "path");
+            try {
+                lstatSync(absolute);
+            }
+            catch (error) {
+                if (isMissing(error))
+                    return result(v, "pass");
+                throw error;
+            }
+            return result(v, "fail", `${v.path} exists.`);
+        }
+        case "tree-diff-within": {
+            if (!ctx.baseline)
+                return result(v, "error", "no fixture snapshot was provided to compare against.");
+            for (const entry of v.allowed) {
+                const reason = unsafeRelativeReason(entry);
+                if (reason)
+                    return result(v, "error", `allowed entry "${entry}" ${reason}.`);
+            }
+            const { added, deleted, modified } = diffTree(ctx.baseline, snapshotTree(ctx.cwd));
+            const outside = (paths) => paths.filter((p) => !isAllowed(p, v.allowed)).sort();
+            const parts = [
+                ["modified", outside(modified)],
+                ["added", outside(added)],
+                ["deleted", outside(deleted)],
+            ]
+                .filter(([, paths]) => paths.length > 0)
+                .map(([label, paths]) => `${label}: ${paths.join(", ")}`);
+            return parts.length === 0
+                ? result(v, "pass")
+                : result(v, "fail", `changes outside the allowed list (${parts.join("; ")}).`);
+        }
+        case "tool-sequence": {
+            if (!ctx.toolEvents)
+                return result(v, "error", "no tool events were recorded for this run.");
+            const checked = checkSequence(v.rule, ctx.toolEvents);
+            return checked.ok ? result(v, "pass") : result(v, "fail", checked.detail);
+        }
+        default:
+            return result(v, "error", `unknown verifier kind "${v.kind}".`);
+    }
+}
+/** Runs one verifier; anything that prevents a verdict (including exceptions) is `error`. */
+export async function runVerifier(v, ctx) {
+    try {
+        return await evaluate(v, ctx);
+    }
+    catch (error) {
+        const detail = error instanceof EvalPathError
+            ? error.message
+            : `verifier could not run: ${error.code ?? error.message}`;
+        return result(v, "error", detail);
+    }
+}
+/** Runs the verifiers in order (sequentially: `command` verifiers may share the working directory). */
+export async function runVerifiers(verifiers, ctx) {
+    const results = [];
+    for (const v of verifiers)
+        results.push(await runVerifier(v, ctx));
+    return results;
+}

package/dist/forge/javascript/hosts/worker-host.d.ts

@@ -2,6 +2,15 @@ import type { IsolateHost, IsolateSession } from "../../ports.ts";
 export declare const WORKER_TERMINATE_AFTER_MS = 50;
 /** The worker entry next to this file: `.ts` when running from sources, `.js` from `dist`. */
 export declare function workerEntryUrl(base?: string): URL;
+/**
+ * Node flags for the worker. A `.ts` entry (running from sources) needs type stripping, which Node
+ * enables by default only from 22.18; on 22.16-22.17 the worker would fail to load its entry. Bun
+ * runs TypeScript natively.
+ */
+export declare function workerExecArgv(entry: URL, runtime?: {
+    bun?: string;
+    typescript?: unknown;
+}): string[];
 export interface WorkerHostOptions {
     module: WebAssembly.Module;
     /** Overrides the entry (tests of failure paths). */

package/dist/forge/javascript/hosts/worker-host.js

@@ -17,6 +17,19 @@ export function workerEntryUrl(base = import.meta.url) {
     const extension = base.endsWith(".ts") ? "ts" : "js";
     return new URL(`./worker-entry.${extension}`, base);
 }
+/**
+ * Node flags for the worker. A `.ts` entry (running from sources) needs type stripping, which Node
+ * enables by default only from 22.18; on 22.16-22.17 the worker would fail to load its entry. Bun
+ * runs TypeScript natively.
+ */
+export function workerExecArgv(entry, runtime = {
+    bun: process.versions.bun,
+    typescript: process.features.typescript,
+}) {
+    if (!entry.pathname.endsWith(".ts") || runtime.bun || runtime.typescript)
+        return [];
+    return ["--experimental-strip-types", "--disable-warning=ExperimentalWarning"];
+}
 export class WorkerIsolateHost {
     kind = "worker";
     #options;
@@ -31,8 +44,10 @@ export class WorkerIsolateHost {
             module: this.#options.module,
             flag: flagBuffer,
         };
-        const worker = new Worker(this.#options.entry ?? workerEntryUrl(), {
+        const entry = this.#options.entry ?? workerEntryUrl();
+        const worker = new Worker(entry, {
             workerData: data,
+            execArgv: workerExecArgv(entry),
             env: {},
             stdout: true,
             stderr: true,

package/dist/forge/kernel.js

@@ -9,7 +9,8 @@
  * deadline and cancellation with the host's OWN clock, the output bound and the single terminal
  * state. The engine only knows how to run code in an isolate.
  */
-import { createHash, randomUUID } from "node:crypto";
+import { createHash } from "node:crypto";
+import { newUuid } from "../runtime/ids.js";
 import { CapabilityBroker } from "./broker.js";
 import { BudgetLedger } from "./budget.js";
 import { ForgeError, isForgeError } from "./errors.js";
@@ -42,7 +43,7 @@ export class ExecutionKernel {
         const now = deps.now ?? Date.now;
         const call = invocation.call;
         const startedAt = now();
-        const id = (deps.newId ?? (() => `fx_${randomUUID()}`))();
+        const id = (deps.newId ?? (() => `fx_${newUuid()}`))();
         const config = deps.config();
         const descriptors = deps.engines.descriptors();
         const language = invocation.language ?? "javascript";

package/dist/index.d.ts

@@ -41,6 +41,21 @@ export { ToolRegistry } from "./core/registry.ts";
 export { RunClock } from "./core/run-clock.ts";
 export { AgentRunner, type CompactionResult, defaultTokenBudget, type RunnerOptions, type RunnerSettingsPatch, type RunOptions, } from "./core/runner.ts";
 export { CircuitBreaker, type CircuitBreakerOptions, type CircuitState, DECISION_LIMITS, DEFAULT_DECISIONS_CONFIG, type DecisionAttempt, DecisionError, type DecisionMetricEntry, DecisionMetrics, type DecisionMetricsSnapshot, type DecisionOutcome, DecisionRegistry, DecisionService, type DecisionServiceDeps, type DecisionStatus, type DecisionsConfig, formatDecisionStatsSection, formatDecisionsReport, HEALTH_TIMEOUT_MS, type RegisteredDecisionProvider, splitSupported, validateAnswers, validateRequest, } from "./decisions/index.ts";
+export { canonicalJson, hashCanonical } from "./eval/canonical.ts";
+export { CASSETTE_SUFFIX, type Cassette, type CassetteCall, CassetteFormatError, type CassetteHeader, type CassetteMeta, CassetteRecorder, CassetteWriteError, MAX_CASSETTE_BYTES, MAX_CASSETTE_DIR_BYTES, parseCassette, RecordingProvider, ReplayDivergenceError, ReplayExhausted, ReplayProvider, ReplayUnconsumedError, readCassette, serializeCassette, type WriteOptions, writeCassette, } from "./eval/cassette.ts";
+export { type Conditions, compareReports, compareVariants, EvalCompareError, type EvalComparison, type Interval, type MetricDelta, parseReport, renderComparisonMarkdown, renderVariantComparisonMarkdown, type TaskComparison, type TokenComparison, type VariantComparison, type Verdict, } from "./eval/compare.ts";
+export { CONFIG_HASH_COVERAGE, type ConfigHashExtras, checkTaskPolicy, computeConfigHash, type EvalApplication, EvalBudgetExceeded, type EvalRunMode, EvalRunRefusedError, type InvokerPermissions, type RunTaskOptions, runTask, } from "./eval/engine.ts";
+export { buildExportBundle, type EvalExportBundle, EvalExportRefusedError, type ExportContext, } from "./eval/export.ts";
+export { computeFingerprint, type FingerprintDiff, type FingerprintDiffEntry, } from "./eval/fingerprint.ts";
+export { EvalPathError, resolveInside } from "./eval/paths.ts";
+export { interleaveVariants, mulberry32, type PlannedRun, planRuns, type VariantStep, } from "./eval/plan.ts";
+export { type BuildReportOptions, buildReport, EvalReportError, estimateRunCost, lowPowerTasks, MIN_POWER_K, renderReportMarkdown, } from "./eval/report.ts";
+export { type RunEvaluationOptions, type RunEvaluationResult, type RunVariantsOptions, runEvaluation, runVariantEvaluations, } from "./eval/run-suite.ts";
+export { findSecrets, redactSecrets } from "./eval/secrets.ts";
+export { median, passAtK, passPowK, sampleVariance, wilsonInterval, } from "./eval/stats.ts";
+export { EvalSuiteError, type LoadedSuite, loadSuite, MAX_VERIFIER_TIMEOUT_MS, } from "./eval/suite.ts";
+export { applyConfigOverrides, EvalVariantError, loadVariantsFile, resolveVariants, type VariantsFile, } from "./eval/variants.ts";
+export { runVerifier, runVerifiers, snapshotTree, type ToolEvent, type TreeSnapshot, type VerifierContext, type VerifierResult, type VerifierStatus, } from "./eval/verifiers.ts";
 export { type ExtensionConflict, ExtensionRegistry } from "./extensions/registry.ts";
 export { ForgeError } from "./forge/errors.ts";
 export { downloadSize as pyodideDownloadSize, inspectPyodide, installPyodide, PyodideIntegrityError, pyodideDir, } from "./forge/python/pyodide-install.ts";
@@ -69,7 +84,7 @@ export { type ExternalDirectoryDecision, type ExternalDirectoryHandler, type Ext
 export { BlobStore, type BlobStoreOptions, BlobTooLarge } from "./runtime/blobs.ts";
 export { clipLines, unifiedPatch } from "./runtime/diff.ts";
 export { exists, fileSize, readHead, readJson, readText, which } from "./runtime/fs.ts";
-export { newId, ulid } from "./runtime/ids.ts";
+export { type IdSource, newId, newUuid, seededIdSource, setIdSource, ulid, } from "./runtime/ids.ts";
 export { defaultGlobalRoots, isPathSpec, PLUGIN_KEYWORD, resolvePluginSpec, } from "./runtime/modules.ts";
 export { findWorkspace, inside, outsideRootsMessage, safePath, workspaceKey, } from "./runtime/paths.ts";
 export { isMissingCommand, type ProcessResult, RIPGREP_INSTALL_HINT, runProcess, } from "./runtime/process.ts";

package/dist/index.js

@@ -40,6 +40,21 @@ export { ToolRegistry } from "./core/registry.js";
 export { RunClock } from "./core/run-clock.js";
 export { AgentRunner, defaultTokenBudget, } from "./core/runner.js";
 export { CircuitBreaker, DECISION_LIMITS, DEFAULT_DECISIONS_CONFIG, DecisionError, DecisionMetrics, DecisionRegistry, DecisionService, formatDecisionStatsSection, formatDecisionsReport, HEALTH_TIMEOUT_MS, splitSupported, validateAnswers, validateRequest, } from "./decisions/index.js";
+export { canonicalJson, hashCanonical } from "./eval/canonical.js";
+export { CASSETTE_SUFFIX, CassetteFormatError, CassetteRecorder, CassetteWriteError, MAX_CASSETTE_BYTES, MAX_CASSETTE_DIR_BYTES, parseCassette, RecordingProvider, ReplayDivergenceError, ReplayExhausted, ReplayProvider, ReplayUnconsumedError, readCassette, serializeCassette, writeCassette, } from "./eval/cassette.js";
+export { compareReports, compareVariants, EvalCompareError, parseReport, renderComparisonMarkdown, renderVariantComparisonMarkdown, } from "./eval/compare.js";
+export { CONFIG_HASH_COVERAGE, checkTaskPolicy, computeConfigHash, EvalBudgetExceeded, EvalRunRefusedError, runTask, } from "./eval/engine.js";
+export { buildExportBundle, EvalExportRefusedError, } from "./eval/export.js";
+export { computeFingerprint, } from "./eval/fingerprint.js";
+export { EvalPathError, resolveInside } from "./eval/paths.js";
+export { interleaveVariants, mulberry32, planRuns, } from "./eval/plan.js";
+export { buildReport, EvalReportError, estimateRunCost, lowPowerTasks, MIN_POWER_K, renderReportMarkdown, } from "./eval/report.js";
+export { runEvaluation, runVariantEvaluations, } from "./eval/run-suite.js";
+export { findSecrets, redactSecrets } from "./eval/secrets.js";
+export { median, passAtK, passPowK, sampleVariance, wilsonInterval, } from "./eval/stats.js";
+export { EvalSuiteError, loadSuite, MAX_VERIFIER_TIMEOUT_MS, } from "./eval/suite.js";
+export { applyConfigOverrides, EvalVariantError, loadVariantsFile, resolveVariants, } from "./eval/variants.js";
+export { runVerifier, runVerifiers, snapshotTree, } from "./eval/verifiers.js";
 export { ExtensionRegistry } from "./extensions/registry.js";
 export { ForgeError } from "./forge/errors.js";
 export { downloadSize as pyodideDownloadSize, inspectPyodide, installPyodide, PyodideIntegrityError, pyodideDir, } from "./forge/python/pyodide-install.js";
@@ -68,7 +83,7 @@ export { PathAccess, } from "./runtime/access.js";
 export { BlobStore, BlobTooLarge } from "./runtime/blobs.js";
 export { clipLines, unifiedPatch } from "./runtime/diff.js";
 export { exists, fileSize, readHead, readJson, readText, which } from "./runtime/fs.js";
-export { newId, ulid } from "./runtime/ids.js";
+export { newId, newUuid, seededIdSource, setIdSource, ulid, } from "./runtime/ids.js";
 export { defaultGlobalRoots, isPathSpec, PLUGIN_KEYWORD, resolvePluginSpec, } from "./runtime/modules.js";
 export { findWorkspace, inside, outsideRootsMessage, safePath, workspaceKey, } from "./runtime/paths.js";
 export { isMissingCommand, RIPGREP_INSTALL_HINT, runProcess, } from "./runtime/process.js";

package/dist/plan/exit-plan.js

@@ -15,6 +15,7 @@ import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { textResult } from "@alisio/sdk";
 import { EXIT_PLAN_TOOL } from "../core/opt-in.js";
+import { newUuid } from "../runtime/ids.js";
 import { objectSchema } from "../tools/standard.js";
 import { DIAGRAM_MAX_BYTES, DIAGRAM_MAX_NODES, validateDiagrams, } from "./diagrams.js";
 import { buildPlanManifest } from "./manifest.js";
@@ -118,7 +119,7 @@ export function registerExitPlan(registry, deps) {
                 throw new Error("exit_plan needs the whole plan in the `plan` field");
             const sessionId = context.session;
             const title = planTitle(plan, input.title);
-            const planId = crypto.randomUUID();
+            const planId = newUuid();
             const reviewable = !!sessionId && deps.ui.interactive() && !deps.readOnly;
             const revision = sessionId ? nextPlanRevision(deps.store, sessionId) : 1;
             const previous = sessionId

package/dist/runtime/ids.d.ts

@@ -6,3 +6,24 @@
 export declare function ulid(now?: number): string;
 /** A prefixed id such as `art_01J…` or `exec_01J…`. */
 export declare const newId: (prefix: string, now?: number) => string;
+/**
+ * A replacement for the random identifiers the runtime generates (session ids, plan ids, forge
+ * execution ids, `ulid`-based ids). The reliability lab installs a seeded one while it records or
+ * replays a cassette so the requests a run sends do not depend on fresh randomness. Nothing
+ * installs one in normal use, and then every function here behaves exactly as before.
+ */
+export interface IdSource {
+    /** A UUID (the shape of `crypto.randomUUID()`). */
+    uuid(): string;
+    /** The 26-character body of a `ulid` (the argument is the caller's clock, which a source may ignore). */
+    ulid(now?: number): string;
+}
+/** Installs (or, with `undefined`, removes) the process-wide id source. */
+export declare function setIdSource(source?: IdSource): void;
+/** A random v4 UUID, or the next one of the installed id source. */
+export declare const newUuid: () => string;
+/**
+ * A deterministic source: the n-th UUID (and the n-th ULID) depends only on `seed`. UUIDs are
+ * v4-shaped; ULIDs carry a counter in their time part, so they stay sortable by creation order.
+ */
+export declare function seededIdSource(seed: string): IdSource;

package/dist/runtime/ids.js

@@ -1,4 +1,4 @@
-import { randomBytes } from "node:crypto";
+import { createHash, randomBytes, randomUUID } from "node:crypto";
 /** Crockford base32 (no I, L, O, U), the ULID alphabet. */
 const ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 /**
@@ -7,6 +7,8 @@ const ALPHABET = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
  * millisecond sort arbitrarily, which is fine for row ids and folder names.
  */
 export function ulid(now = Date.now()) {
+    if (installed)
+        return installed.ulid(now);
     let time = "";
     let t = Math.max(0, Math.floor(now));
     for (let i = 0; i < 10; i++) {
@@ -30,3 +32,41 @@ export function ulid(now = Date.now()) {
 }
 /** A prefixed id such as `art_01J…` or `exec_01J…`. */
 export const newId = (prefix, now) => `${prefix}_${ulid(now)}`;
+let installed;
+/** Installs (or, with `undefined`, removes) the process-wide id source. */
+export function setIdSource(source) {
+    installed = source;
+}
+/** A random v4 UUID, or the next one of the installed id source. */
+export const newUuid = () => (installed ? installed.uuid() : randomUUID());
+/**
+ * A deterministic source: the n-th UUID (and the n-th ULID) depends only on `seed`. UUIDs are
+ * v4-shaped; ULIDs carry a counter in their time part, so they stay sortable by creation order.
+ */
+export function seededIdSource(seed) {
+    let uuids = 0;
+    let ulids = 0;
+    const digest = (kind, n) => createHash("sha256").update(`${seed}\0${kind}\0${n}`).digest();
+    return {
+        uuid() {
+            const bytes = digest("uuid", uuids++).subarray(0, 16);
+            bytes[6] = ((bytes[6] ?? 0) & 0x0f) | 0x40;
+            bytes[8] = ((bytes[8] ?? 0) & 0x3f) | 0x80;
+            const hex = bytes.toString("hex");
+            return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20)}`;
+        },
+        ulid() {
+            let time = "";
+            let t = ulids;
+            for (let i = 0; i < 10; i++) {
+                time = (ALPHABET[t % 32] ?? "0") + time;
+                t = Math.floor(t / 32);
+            }
+            const bytes = digest("ulid", ulids++);
+            let random = "";
+            for (let i = 0; i < 16; i++)
+                random += ALPHABET[(bytes[i] ?? 0) & 31];
+            return time + random;
+        },
+    };
+}

package/dist/runtime/store.js

@@ -1,4 +1,5 @@
 import { textResult, } from "@alisio/sdk";
+import { newUuid } from "./ids.js";
 import { isProcessAlive } from "./process.js";
 import { openDatabase } from "./sqlite.js";
 const alive = isProcessAlive;
@@ -327,7 +328,7 @@ export class SQLiteStore {
         return current;
     }
     create(workspace, provider, model) {
-        const id = crypto.randomUUID();
+        const id = newUuid();
         const now = Date.now();
         this.db
             .prepare("INSERT INTO sessions(id,workspace,provider,model,created_at,updated_at) VALUES(?,?,?,?,?,?)")
@@ -367,7 +368,7 @@ export class SQLiteStore {
             .map((r) => this.row(r));
     }
     createChild(record) {
-        const id = record.id ?? crypto.randomUUID();
+        const id = record.id ?? newUuid();
         const now = Date.now();
         this.db
             .prepare(`INSERT INTO sessions(id,workspace,provider,model,parent_id,depth,agent,status,title,usage,options,created_at,updated_at)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@alisio/core",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Embeddable provider-agnostic Alisio agent core: tool loop, context compaction, local tools, MCP, plugin host and SQLite session store. Runs on Node >=22.16 and Bun.",
   "author": "Gustavo Gutiérrez",
   "license": "MIT",
@@ -45,7 +45,7 @@
     "node": ">=22.16"
   },
   "dependencies": {
-    "@alisio/sdk": "0.6.0",
+    "@alisio/sdk": "0.7.0",
     "@mixmark-io/domino": "2.2.0",
     "@modelcontextprotocol/client": "2.1.0",
     "ajv": "8.20.0",