@zenera/cli 1.1.35 → 1.1.37

package/dist/engine.js

@@ -1,306 +1,20 @@
-import { AgentRunner, FilePayloadStore, SANDBOX_MOUNT, SKILLS_MOUNT, Workspace, assertState, buildRunReport, exaTools, fileTools, lastText, loadProject, memoryDir, readProjectConfig, renderReportHtml, sandboxTools, turns, } from '@zenera/neo';
-import { existsSync } from 'node:fs';
-import { writeFile } from 'node:fs/promises';
-import { resolve } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { auditModels, describeIssue } from "./audit.js";
-import { loadProjectEnv } from "./env.js";
-import { readJson, writeJson } from "./home.js";
-import { KeyStore, assertUsable } from "./keys.js";
-import { projectMounts } from "./projects.js";
-import { buildSandbox, preflight, teardown, usesSandbox } from "./sandbox.js";
-import { acquire, createRun, readSessionMeta, writeRunMeta, writeSessionMeta, } from "./session.js";
-import { CliError, EXIT, invalidError, warn } from "./term.js";
+import { describeIssue, openEngine, runEngine, } from '@zenera/engine';
+import { preflight } from "./sandbox.js";
+import { bold, dim, warn } from "./term.js";
 import { traceMermaid } from "./trace.js";
-/**
- * Wires the library to a session directory. Every store is file-backed and
- * rooted inside `.data/`, so a session is self-contained: copy the directory
- * and the whole conversation, its memory and its blobs travel with it.
- */
-export async function open(opts) {
-    // Before the keyring, so the project's own file wins over the machine's
-    // keys, and before the load, so `${VAR}` in agents.yaml can name anything
-    // in it. The real environment still beats both.
-    const env = loadProjectEnv(opts.project.dir);
-    const keys = await KeyStore.open();
-    keys.materialize();
-    assertUsable(keys);
-    // Said before the load, because the load stops at the first model it cannot
-    // build: one SDK's words about one model, when the useful answer is which
-    // of the project's models are reachable and which are not.
-    for (const issue of auditModels(opts.project.dir, keys)) {
-        if (!opts.quiet) {
-            warn(describeIssue(issue));
-        }
-    }
-    const meta = await readSessionMeta(opts.session);
-    const workspace = resolve(meta.workspace);
-    const payloads = new FilePayloadStore({ dir: opts.session.blobs, id: 'file' });
-    // The config is read before the project is loaded because the sandbox is
-    // configured by it and the tools have to exist before selectors can be
-    // resolved against them. They are always registered, whether or not anyone
-    // selects them: a project that names `sandbox:*` against an empty tool list
-    // fails to load with "unknown tool", which would be a lie.
-    let sandbox;
-    let project;
-    let files;
-    let memory;
-    try {
-        const { root, config } = readProjectConfig(opts.project.dir);
-        // Naming a directory declares the graph, but it cannot bind anyone to
-        // it — so say when the run is pointed at a memory no agent will touch.
-        if (opts.memoryDir && !opts.quiet && !config.agents.some((a) => a.memory)) {
-            warn('--memory names a directory no agent uses — none has `memory: true`');
-        }
-        memory = memoryDir(root, config, opts.memoryDir);
-        // Assets and the skill catalog are mounted for both, under one name.
-        const mounts = projectMounts(root, config, opts.memoryDir);
-        sandbox = buildSandbox({
-            config,
-            root,
-            session: opts.session,
-            workspace,
-            readOnly: opts.readOnly,
-            image: opts.image,
-            keys: opts.keys,
-            env: env?.names,
-            mounts,
-            ...(opts.disposable ? { persist: false } : {}),
-        });
-        const workspaceOptions = {
-            root: workspace,
-            readOnly: opts.readOnly,
-            mount: sandbox.spec.workdir ?? SANDBOX_MOUNT,
-            mounts,
-        };
-        // The same view the file tools have, so a path the agent just wrote
-        // resolves the same way when it asks memory to keep a copy.
-        files = new Workspace(workspaceOptions);
-        project = await loadProject(opts.project.dir, {
-            tools: [
-                // Both groups are pointed at one directory, so both are told the
-                // one name for it: whatever `run_command` prints a path as,
-                // `read_file` accepts.
-                ...fileTools(workspaceOptions),
-                ...sandboxTools(sandbox.pool),
-                // Registered whether or not a key exists: the credential is
-                // read when a tool is called, so a project that names `exa:*`
-                // loads on a machine that cannot yet search, and says so on the
-                // turn that tried.
-                ...exaTools(),
-            ],
-            skillsAt: SKILLS_MOUNT,
-            memoryDir: opts.memoryDir,
-            memoryReadOnly: opts.memoryReadOnly,
-            payloads,
-            resolveFile: (path) => files.within(path),
-        });
-    }
-    catch (err) {
-        throw invalidError(err instanceof Error ? err.message : String(err), `while loading ${opts.project.dir}`);
-    }
-    // Asked here rather than at the first `run_command`, so a host with no
-    // container engine costs an error instead of a round trip. Nothing is
-    // started: the container itself waits until something actually runs.
-    if (usesSandbox(project)) {
-        await preflight(sandbox, opts.yes);
-    }
-    // `recordRequests` is what makes the report show the exact bytes sent
-    // rather than a reconstruction. It costs state size, and a CLI run is
-    // written to disk once and inspected by a human — exactly the case the
-    // library leaves it off for by default.
-    //
-    // `--model` becomes the runner's fallback rather than an alias, so it
-    // overrides the config's `model:` without touching agents that pinned one.
-    const runner = project.runner({
-        recordRequests: true,
-        model: opts.model ? project.models.model(opts.model) : undefined,
+// ---------------------------------------------------------------------------
+// `@zenera/engine` as the terminal hosts it: warnings in colour on stderr, a
+// podman that can be installed on the spot, and a graph beside every run.
+// ---------------------------------------------------------------------------
+export { envelope, mounts, } from '@zenera/engine';
+export function open(opts) {
+    return openEngine({
+        logger: { warn },
+        onIssue: (issue) => warn(describeIssue(issue, { bold, dim })),
+        preflight,
+        graph: traceMermaid,
+        ...opts,
     });
-    const state = await loadState(opts.session);
-    const lock = acquire(opts.session);
-    return {
-        project,
-        runner,
-        name: opts.project.name,
-        workspace,
-        workspaceMount: sandbox.spec.workdir ?? SANDBOX_MOUNT,
-        files,
-        readOnly: Boolean(opts.readOnly),
-        session: opts.session,
-        memory,
-        state,
-        sandbox,
-        lock,
-        close: async () => {
-            await teardown(sandbox.pool);
-            project.close();
-            lock.release();
-        },
-    };
-}
-async function loadState(session) {
-    if (!existsSync(session.state)) {
-        return undefined;
-    }
-    const json = await readJson(session.state, undefined);
-    try {
-        return assertState(json);
-    }
-    catch {
-        throw invalidError(`${session.state} is not a usable run state`, 'start a fresh session with --new');
-    }
-}
-/** Every tree the agent can see, the workspace first. */
-export function mounts(engine) {
-    return [
-        { host: engine.workspace, at: engine.workspaceMount, readOnly: engine.readOnly },
-        ...engine.sandbox.mounts.map((m) => ({
-            host: m.host,
-            at: m.at,
-            readOnly: Boolean(m.readOnly),
-        })),
-    ];
-}
-/**
- * What one finished run looks like to a program: `zen run --json` prints it,
- * and a batch writes one beside every item. The same function on purpose — a
- * batch whose items were shaped differently would make every consumer of a
- * single run a special case.
- */
-export function envelope(engine, outcome) {
-    return {
-        session: { id: engine.session.id, dir: engine.session.dir },
-        run: {
-            id: outcome.run.id,
-            dir: outcome.run.dir,
-            input: outcome.run.input,
-            output: outcome.run.output,
-            state: outcome.run.state,
-            meta: outcome.run.meta,
-            ...(outcome.report ? { report: outcome.report } : {}),
-            ...(outcome.graph ? { graph: outcome.graph } : {}),
-        },
-        mounts: mounts(engine),
-        agent: outcome.result.agent,
-        stopReason: outcome.result.stopReason,
-        durationMs: outcome.durationMs,
-        usage: outcome.result.usage,
-        output: outcome.text,
-    };
-}
-/**
- * One turn. The session's state decides whether this starts a run or continues
- * one — which is the whole of what `resume` used to be, and why it is not a
- * command.
- */
-export async function run(engine, input, onEvent, signal) {
-    const startedAt = new Date();
-    const stream = engine.state
-        ? engine.runner.send(engine.state, input, { signal })
-        : engine.runner.run(engine.project.entry, input, { signal });
-    if (onEvent) {
-        for await (const event of stream) {
-            onEvent(event);
-        }
-    }
-    const result = await stream.final();
-    const durationMs = Date.now() - startedAt.getTime();
-    engine.state = result.state;
-    const outcome = await record(engine, input, result, startedAt, durationMs);
-    if (result.stopReason === 'failed') {
-        throw new CliError(result.state.error ?? 'the run failed', EXIT.failed, `report: ${outcome.run.report}`);
-    }
-    return outcome;
-}
-/**
- * Everything a finished turn leaves behind. The session state is written first:
- * if the report fails to render, the conversation is still resumable, which is
- * the ordering that loses least.
- */
-async function record(engine, input, result, startedAt, durationMs) {
-    const { session } = engine;
-    writeJson(session.state, result.state, 0o644);
-    const meta = await readSessionMeta(session);
-    meta.lastRunAt = new Date().toISOString();
-    meta.title ??= title(input);
-    writeSessionMeta(session, meta);
-    const run = createRun(session);
-    const text = await lastText(result.state, engine.runner.services.payloads);
-    await writeFile(run.input, `${asText(input)}\n`, 'utf8');
-    await writeFile(run.output, `${text}\n`, 'utf8');
-    writeJson(run.state, result.state, 0o644);
-    let report;
-    try {
-        const built = await buildRunReport(result.state, engine.runner.services.payloads, {
-            title: `${engine.name} · ${run.id}`,
-            architecture: await engine.runner.describe(),
-            memory: engine.runner.services.memory?.store,
-            mounts: [
-                { at: engine.workspaceMount, href: pathToFileURL(engine.files.root).href },
-                ...engine.files.mounts.map((m) => ({ at: m.at, href: pathToFileURL(m.host).href })),
-            ],
-        });
-        await writeFile(run.report, renderReportHtml(built), 'utf8');
-        report = run.report;
-    }
-    catch {
-        // A report is a convenience. Losing it must not lose the run.
-    }
-    // The same trajectory for the other reader. `report.html` is for a person;
-    // this is what `zen inspect graph` prints, written down while the state is
-    // already in hand — a batch of a hundred items is otherwise a hundred more
-    // commands to run before anything can be read.
-    let graph;
-    try {
-        await writeFile(run.graph, traceMermaid(result.state, {
-            runId: run.id,
-            dir: run.dir,
-            workspace: engine.workspace,
-            memory: engine.memory,
-        }), 'utf8');
-        graph = run.graph;
-    }
-    catch {
-        // Same rule as the report: a view of the run is not the run.
-    }
-    writeRunMeta(run, {
-        version: 1,
-        id: run.id,
-        session: session.id,
-        startedAt: startedAt.toISOString(),
-        finishedAt: new Date().toISOString(),
-        durationMs,
-        agent: result.agent,
-        stopReason: result.stopReason,
-        turns: turns(result.state),
-        usage: result.usage,
-        workspace: engine.workspace,
-        memory: engine.memory,
-        error: result.state.error,
-    });
-    return { run, result, text, durationMs, report, graph };
-}
-function asText(input) {
-    if (typeof input === 'string') {
-        return input;
-    }
-    return input
-        .map((part) => {
-        if (typeof part === 'string') {
-            return part;
-        }
-        if ('text' in part && typeof part.text === 'string') {
-            return part.text;
-        }
-        // A media shorthand is a single key; naming it is more useful in a
-        // transcript than printing the url or the base64 behind it.
-        return `[${Object.keys(part)[0] ?? 'part'}]`;
-    })
-        .join('\n');
-}
-/** A session's label in a picker: the first thing that was ever asked of it. */
-function title(input) {
-    const text = asText(input).replace(/\s+/g, ' ').trim();
-    return text.length > 60 ? `${text.slice(0, 57)}…` : text;
 }
+export const run = runEngine;
 //# sourceMappingURL=engine.js.map

package/dist/history.js

@@ -1,7 +1,7 @@
+import { sessionsDir } from '@zenera/engine';
 import { randomUUID } from 'node:crypto';
 import { appendFileSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
 import { dirname, join } from 'node:path';
-import { sessionsDir } from "./projects.js";
 // ---------------------------------------------------------------------------
 // The prompt's history
 //

package/dist/lib.d.ts

@@ -1,10 +1,9 @@
+export { assertNotEmpty, assertOwner, assertPrivate, assertUsable, describe, ensureDir, ensureHome, envNames, envOf, form, home, isOwner, isProvider, keyId, KeyStore, mask, OWNERS, parseRef, paths, PROVIDERS, readJson, SERVICES, SHAPES, writeJson, type CredentialForm, type KeyCheck, type KeyEntry, type KeyOwner, type Liveness, type Provider, type Service, } from '@zenera/engine';
 export { extract, invokedAs, one, parse, split, type Parsed, type Split } from './args.ts';
 export { bannerArt, printBanner, type BannerText } from './banner.ts';
 export { Cache, items as cacheItems, cacheKey, kinds as cacheKinds, clear as clearCache, NO_CACHE, sweep as sweepCache, type CacheEntry, type CacheItem, type CacheKind, type CacheOptions, type CacheStore, type Swept, } from './cache.ts';
 export { CATALOG_TTL_MS, CURATED, fetchCatalog, loadCatalog, loadCatalogs, matches, PREFERRED, type Catalog, type CatalogEntry, type CatalogOptions, type Filters, type Role, } from './catalog.ts';
 export type { Command, Context } from './command.ts';
-export { assertPrivate, ensureDir, ensureHome, home, paths, readJson, writeJson } from './home.ts';
-export { assertNotEmpty, assertOwner, assertUsable, describe, envNames, envOf, form, isOwner, isProvider, keyId, KeyStore, mask, OWNERS, parseRef, PROVIDERS, SERVICES, SHAPES, type CredentialForm, type KeyCheck, type KeyEntry, type KeyOwner, type Liveness, type Provider, type Service, } from './keys.ts';
 export { probe, probeAll } from './liveness.ts';
 export { engineDisk, ensurePodmanReady, ownedContainers, podmanStatus, removeContainers, type DiskLine, type EngineDisk, type OwnedContainer, type PodmanOptions, type PodmanStatus, } from './podman.ts';
 export { ago, bold, CliError, count, credentialError, cyan, dim, EXIT, fail, green, invalidError, isInteractive, italic, json, note, pad, red, table, underline, usageError, warn, write, writeAll, yellow, type ExitCode, } from './term.ts';

package/dist/lib.js

@@ -21,12 +21,11 @@
 // writers go to stdout/stderr. That vocabulary belongs to startup. A server
 // must not let a `CliError` escape into a request handler.
 // ---------------------------------------------------------------------------
+export { assertNotEmpty, assertOwner, assertPrivate, assertUsable, describe, ensureDir, ensureHome, envNames, envOf, form, home, isOwner, isProvider, keyId, KeyStore, mask, OWNERS, parseRef, paths, PROVIDERS, readJson, SERVICES, SHAPES, writeJson, } from '@zenera/engine';
 export { extract, invokedAs, one, parse, split } from "./args.js";
 export { bannerArt, printBanner } from "./banner.js";
 export { Cache, items as cacheItems, cacheKey, kinds as cacheKinds, clear as clearCache, NO_CACHE, sweep as sweepCache, } from "./cache.js";
 export { CATALOG_TTL_MS, CURATED, fetchCatalog, loadCatalog, loadCatalogs, matches, PREFERRED, } from "./catalog.js";
-export { assertPrivate, ensureDir, ensureHome, home, paths, readJson, writeJson } from "./home.js";
-export { assertNotEmpty, assertOwner, assertUsable, describe, envNames, envOf, form, isOwner, isProvider, keyId, KeyStore, mask, OWNERS, parseRef, PROVIDERS, SERVICES, SHAPES, } from "./keys.js";
 export { probe, probeAll } from "./liveness.js";
 export { engineDisk, ensurePodmanReady, ownedContainers, podmanStatus, removeContainers, } from "./podman.js";
 export { ago, bold, CliError, count, credentialError, cyan, dim, EXIT, fail, green, invalidError, isInteractive, italic, json, note, pad, red, table, underline, usageError, warn, write, writeAll, yellow, } from "./term.js";

package/dist/liveness.d.ts

@@ -1,5 +1,5 @@
+import { type KeyCheck, type KeyEntry, type KeyStore } from '@zenera/engine';
 import { type Embedder, type Model } from '@zenera/neo';
-import { type KeyCheck, type KeyEntry, type KeyStore } from './keys.ts';
 export declare function classify(err: unknown): KeyCheck;
 /**
  * The cheapest authenticated call each SDK has. Nothing here reads a model or

package/dist/liveness.js

@@ -1,5 +1,5 @@
+import { envOf, SHAPES, } from '@zenera/engine';
 import { createModel, EXA_BASE_URL, GATEWAY_KEY_HEADER, isUnfunded, ModelRegistry, text, vertexRoute, } from '@zenera/neo';
-import { envOf, SHAPES, } from "./keys.js";
 // ---------------------------------------------------------------------------
 // Liveness
 //

package/dist/meta/host.d.ts

@@ -1,8 +1,7 @@
+export { envOf, paths, PROVIDERS, readJson, writeJson, type KeyEntry, type KeyStore, type Provider, } from '@zenera/engine';
 export { invokedAs, parse } from '../args.ts';
 export { loadCatalogs } from '../catalog.ts';
 export type { EventLine } from '../eventlog.ts';
-export { paths, readJson, writeJson } from '../home.ts';
-export { envOf, PROVIDERS, type KeyEntry, type KeyStore, type Provider } from '../keys.ts';
 export { PROVIDER_NAMES, splitRef } from '../modelref.ts';
 export { duration } from '../narrate.ts';
 export { rankModels } from '../rank.ts';

package/dist/meta/host.js

@@ -5,10 +5,9 @@
 // other, so the layer can leave for a package of its own by turning this into
 // a dependency. `test/meta-boundary.test.ts` holds the line.
 // ---------------------------------------------------------------------------
+export { envOf, paths, PROVIDERS, readJson, writeJson, } from '@zenera/engine';
 export { invokedAs, parse } from "../args.js";
 export { loadCatalogs } from "../catalog.js";
-export { paths, readJson, writeJson } from "../home.js";
-export { envOf, PROVIDERS } from "../keys.js";
 export { PROVIDER_NAMES, splitRef } from "../modelref.js";
 export { duration } from "../narrate.js";
 export { rankModels } from "../rank.js";

package/dist/meta/launch.js

@@ -143,7 +143,9 @@ export function absorb(event, out, sink, width) {
 export async function launch(opts) {
     const shown = opts.sink ?? windowSink();
     const sink = opts.log ? tee(shown, opts.log) : shown;
-    const width = opts.width ?? Math.max(40, (process.stderr.columns ?? 100) - 4);
+    // Without a terminal nothing wraps, and a cut line is lost from the log too.
+    const width = opts.width ??
+        (process.stderr.isTTY ? Math.max(40, (process.stderr.columns ?? 100) - 4) : Infinity);
     const start = opts.spawn ?? nodeSpawn;
     const out = { answer: '', exitCode: 0, events: [] };
     const child = start(opts.binary.command, [...opts.binary.args, ...opts.args], {

package/dist/modelref.d.ts

@@ -1,4 +1,4 @@
-import type { Provider } from './keys.ts';
+import type { Provider } from '@zenera/engine';
 export declare const PROVIDER_NAMES: ReadonlySet<string>;
 /**
  * `vertex/gemini-3.8-flash` splits; `gpt-5.6-sol` does not. Only a known provider

package/dist/podman.d.ts

@@ -1,5 +1,5 @@
+import { type ResolvedBuild } from '@zenera/engine';
 import { runProcess } from '@zenera/neo';
-import type { ResolvedBuild } from './image.ts';
 import { CliError } from './term.ts';
 export interface PodmanOptions {
     /** the image the project needs on disk before the first run */

package/dist/podman.js

@@ -1,8 +1,8 @@
+import { isBusy, isProjectDir, Registry, sessionIds, sessionsDir, } from '@zenera/engine';
 import { pidAlive, runProcess, SandboxError } from '@zenera/neo';
 import { readdirSync, readFileSync, statSync } from 'node:fs';
 import { homedir, platform } from 'node:os';
 import { join } from 'node:path';
-import { isBusy, isProjectDir, Registry, sessionIds, sessionsDir } from "./projects.js";
 import { CliError, confirm, dim, EXIT, isInteractive, note, progress } from "./term.js";
 const DEFAULT_MACHINE_CPUS = 2;
 const DEFAULT_MACHINE_MEMORY = 2048;

package/dist/resolve.d.ts

@@ -1,5 +1,5 @@
-import * as Projects from './projects.ts';
-import { type SessionPaths } from './session.ts';
+import * as Projects from '@zenera/engine';
+import { type SessionPaths } from '@zenera/engine';
 export interface Wanted {
     project?: string;
     session?: string;

package/dist/resolve.js

@@ -1,8 +1,7 @@
+import * as Projects from '@zenera/engine';
+import { createSession, listSessions, readSessionMeta, requireSession, sessionPaths, stamp, } from '@zenera/engine';
 import { existsSync } from 'node:fs';
 import { isAbsolute, relative, resolve, sep } from 'node:path';
-import { stamp } from "./ids.js";
-import * as Projects from "./projects.js";
-import { createSession, listSessions, readSessionMeta, requireSession, sessionPaths, } from "./session.js";
 import * as term from "./term.js";
 import { ago, bold, cyan, dim, usageError, yellow } from "./term.js";
 // ---------------------------------------------------------------------------

package/dist/resources.js

@@ -1,8 +1,8 @@
+import { isProjectDir, Registry, sessionIds, sessionsDir } from '@zenera/engine';
 import { runProcess } from '@zenera/neo';
 import { cpus as hostCpus, platform as hostPlatform, totalmem } from 'node:os';
 import { basename, join } from 'node:path';
 import { idleContainers, ownedContainers } from "./podman.js";
-import { isProjectDir, Registry, sessionIds, sessionsDir } from "./projects.js";
 import { ago, bytes } from "./term.js";
 import { wrap } from "./tui/wrap.js";
 const MIB = 1024 * 1024;

package/dist/sandbox.d.ts

@@ -1,62 +1,4 @@
-import { SandboxPool, type AgentProject, type ProjectConfig, type SandboxMount, type SandboxSpec } from '@zenera/neo';
-import { type ResolvedBuild } from './image.ts';
-import type { SessionPaths } from './session.ts';
-export interface SandboxSetup {
-    pool: SandboxPool;
-    /** the resolved base spec, for `zn sandbox status` and the image pre-warm */
-    spec: SandboxSpec;
-    image: string;
-    /** the Dockerfile behind `image`, when it came from one */
-    build?: ResolvedBuild;
-    /** host side of the container's `$HOME`, created only if it is ever needed */
-    home: string;
-    /** every tree bound into the container besides the workspace itself */
-    mounts: readonly SandboxMount[];
-}
-export interface SandboxInputs {
-    config: ProjectConfig;
-    session: SessionPaths;
-    workspace: string;
-    /** the project directory, which `build:` paths are relative to */
-    root: string;
-    readOnly?: boolean;
-    /**
-     * Trees to mount besides the workspace and the home — the project's assets
-     * and its skill catalog. The same array goes to the file tools, so a path
-     * a command prints is a path `read_file` accepts.
-     */
-    mounts?: readonly SandboxMount[];
-    /** `--image` */
-    image?: string;
-    /** `--no-keys`: refuse to forward credentials, whatever the config says */
-    keys?: boolean;
-    /**
-     * Names from the project's `.env`, forwarded into the container the same
-     * way a credential is — by name, so the value stays out of the argv.
-     *
-     * They travel with the keys rather than beside them: a `.env` is where an
-     * api token lives, so `--no-keys` has to withhold it too or the flag is a
-     * promise it does not keep.
-     */
-    env?: readonly string[];
-    /** `false` overrides every `persist:` in the config, the agents' included */
-    persist?: boolean;
-}
-export declare function buildSandbox(opts: SandboxInputs): SandboxSetup;
-/**
- * Whether anything in this project can reach a shell.
- *
- * Read off the *resolved* tool lists rather than off the config's selectors,
- * because `sandbox:*`, `*` and a bare name all mean the same thing by the time
- * the loader is done, and only one of those three is greppable.
- */
-export declare function usesSandbox(project: AgentProject): boolean;
-/**
- * Asked before the first turn rather than at the first tool call, so a missing
- * container engine costs nothing instead of costing a round trip and half a
- * plan. A project that never shells out never gets here at all.
- */
+import type { SandboxSetup } from '@zenera/engine';
+/** The engine's preflight on a terminal: podman is offered for install and started if needed. */
 export declare function preflight(setup: SandboxSetup, yes?: boolean): Promise<void>;
-/** Best-effort teardown: losing a container must never lose a run. */
-export declare function teardown(pool: SandboxPool): Promise<void>;
 //# sourceMappingURL=sandbox.d.ts.map