@zenera/cli 1.1.36 → 1.1.37

package/dist/projects.d.ts

@@ -1,91 +0,0 @@
-import { type ProjectConfig, type SandboxMount } from '@zenera/neo';
-/** Whether a directory is a project: whether the loader has something to read. */
-export declare function isProjectDir(dir: string): boolean;
-/** A project resolved on disk. */
-export interface Project {
-    dir: string;
-    /** what it is called: the registry's name, or the directory's own */
-    name: string;
-}
-/**
- * The trees a run mounts besides the workspace itself.
- *
- * One array, handed to the file tools and to the container both, because the
- * two have to agree on the name: a path `run_command` prints has to be a path
- * `read_file` takes. Everything here is read-only — material an agent consults
- * and does not edit — and the paths are resolved, because the podman machine on
- * macOS shares the real path or nothing.
- */
-export declare function projectMounts(root: string, config: ProjectConfig, memoryAt?: string): SandboxMount[];
-/** Walks up from `start` looking for a project configuration. */
-export declare function findUp(start: string): Promise<Project | undefined>;
-export declare function openDir(dir: string): Promise<Project>;
-/**
- * A name from the registry, or a path. A value that looks like either is tried
- * as both, path first, because a directory that exists is unambiguous evidence
- * and a stale registry entry is not.
- */
-export declare function open(nameOrDir: string): Promise<Project>;
-/**
- * `open` where a miss is an answer rather than an error. It exists for the one
- * place a word might be a project name and might be something else entirely —
- * `zen run <project>` against `zen run <prompt>` — and the difference decides
- * how the rest of the line is read.
- */
-export declare function find(nameOrDir: string): Promise<Project | undefined>;
-/** The project a bare command means: the one you are standing in. */
-export declare function current(cwd?: string): Promise<Project | undefined>;
-export interface RegistryEntry {
-    name: string;
-    path: string;
-    addedAt: string;
-}
-export declare class Registry {
-    #private;
-    private constructor();
-    static open(): Promise<Registry>;
-    get entries(): readonly RegistryEntry[];
-    find(name: string): RegistryEntry | undefined;
-    findPath(dir: string): RegistryEntry | undefined;
-    /** Idempotent: re-registering the same directory refreshes it in place. */
-    add(name: string, dir: string): RegistryEntry;
-    remove(name: string): boolean;
-    /** Drops entries whose directory is gone. Returns what it dropped. */
-    prune(): RegistryEntry[];
-    save(): void;
-}
-export interface ProjectSummary {
-    name: string;
-    path: string;
-    /** false when the directory has gone away since it was registered */
-    present: boolean;
-    sessions: number;
-    runs: number;
-    lastRunAt?: string;
-    /** a session currently held by a live process */
-    busy: boolean;
-}
-export declare function summarize(entry: RegistryEntry): Promise<ProjectSummary>;
-export declare const sessionsDir: (projectDir: string) => string;
-/** Session ids, oldest first. Only well-formed stamps count as sessions. */
-export declare function sessionIds(projectDir: string): string[];
-export declare function runIds(sessionDir: string): string[];
-/**
- * When this project was last worked in, as a stamp, or `undefined` for one
- * that never has been. Session and run ids are stamps in the same format, so
- * the newest of either compares directly — and reading directory NAMES is what
- * keeps this cheap enough to ask of every registered project before drawing a
- * chooser.
- */
-export declare function lastUsedAt(projectDir: string): string | undefined;
-/**
- * What a tree occupies, in allocated blocks rather than in bytes, because a
- * sparse file costs what it was given and not what it claims. Symlinks are
- * counted and never followed: a link out of the tree is not part of it, and
- * one that points back in would otherwise be counted twice — or forever.
- */
-export declare function dirSize(dir: string): number;
-/** True when a session's lock names a process that is still alive. */
-export declare function isBusy(sessionDir: string): boolean;
-export declare function projectName(dir: string): string;
-//# sourceMappingURL=projects.d.ts.map

package/dist/projects.js

@@ -1,303 +0,0 @@
-import { ASSETS_MOUNT, assetsDir, FILES_DIR, MEMORY_MOUNT, memoryDir, pidAlive, skillDirs, skillMounts, SKILLS_MOUNT, } from '@zenera/neo';
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync } from 'node:fs';
-import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
-import { paths, readJson, writeJson } from "./home.js";
-import { isStamp } from "./ids.js";
-import { invalidError, usageError } from "./term.js";
-// ---------------------------------------------------------------------------
-// Projects
-//
-// The directory is the truth, and what makes a directory a project is the one
-// file the runtime cannot do without: `agents.yaml`. There is no marker file
-// beside it — that would be a second thing to keep in sync, holding a name the
-// directory already has.
-//
-// `~/.zenera/neo/projects.json` is an index so that `zen list` and `zen open` do
-// not have to search the filesystem, and it is allowed to be wrong: every entry
-// can be rebuilt by pointing `zen` at the directory again, and an entry whose
-// path has vanished is reported, not fatal.
-// ---------------------------------------------------------------------------
-/**
- * The loader's own names, in its own order — `packages/neo/src/project/load.ts`.
- * Anything the library would load, `zen` finds.
- */
-const CONFIG_NAMES = ['agents.yaml', 'agents.yml', 'agents/agents.yaml', 'agents/agents.yml'];
-/** Whether a directory is a project: whether the loader has something to read. */
-export function isProjectDir(dir) {
-    return CONFIG_NAMES.some((name) => existsSync(join(dir, name)));
-}
-/**
- * The trees a run mounts besides the workspace itself.
- *
- * One array, handed to the file tools and to the container both, because the
- * two have to agree on the name: a path `run_command` prints has to be a path
- * `read_file` takes. Everything here is read-only — material an agent consults
- * and does not edit — and the paths are resolved, because the podman machine on
- * macOS shares the real path or nothing.
- */
-export function projectMounts(root, config, memoryAt) {
-    const mounts = [];
-    const assets = assetsDir(root, config);
-    if (assets) {
-        mounts.push({ host: realpathSync(assets), at: ASSETS_MOUNT, readOnly: true });
-    }
-    // The catalog goes in whole, at fixed names, before anything is loaded: a
-    // container's mounts are decided when it is created, so a skill folder
-    // cannot be added at the moment `skill_load` asks for it.
-    for (const dir of skillMounts(skillDirs(root, config), SKILLS_MOUNT)) {
-        mounts.push({ host: realpathSync(dir.path), at: dir.at, readOnly: true });
-    }
-    const memory = memoryDir(root, config, memoryAt);
-    if (memory) {
-        // Created here because the mount is decided before the project is
-        // loaded, and podman would refuse a source that does not exist yet.
-        const files = join(memory, FILES_DIR);
-        mkdirSync(files, { recursive: true });
-        mounts.push({ host: realpathSync(files), at: MEMORY_MOUNT, readOnly: true });
-    }
-    return mounts;
-}
-// ---------------------------------------------------------------------------
-// The project directory
-// ---------------------------------------------------------------------------
-/**
- * What a project answers to. The registry is asked first, so one registered
- * under a name of its own keeps it; the directory's name answers for a project
- * that was never registered — which is a working project, just not a listed one.
- */
-async function nameOf(dir) {
-    return (await Registry.open()).findPath(dir)?.name ?? basename(dir);
-}
-// ---------------------------------------------------------------------------
-// Finding one
-// ---------------------------------------------------------------------------
-/** Walks up from `start` looking for a project configuration. */
-export async function findUp(start) {
-    let dir = resolve(start);
-    for (;;) {
-        if (isProjectDir(dir)) {
-            return { dir, name: await nameOf(dir) };
-        }
-        const parent = dirname(dir);
-        if (parent === dir) {
-            return undefined;
-        }
-        dir = parent;
-    }
-}
-export async function openDir(dir) {
-    const at = resolve(dir);
-    if (!isProjectDir(at)) {
-        throw invalidError(`${at} is not a project`, `no ${CONFIG_NAMES[0]} — run: zen init`);
-    }
-    return { dir: at, name: await nameOf(at) };
-}
-/**
- * A name from the registry, or a path. A value that looks like either is tried
- * as both, path first, because a directory that exists is unambiguous evidence
- * and a stale registry entry is not.
- */
-export async function open(nameOrDir) {
-    if (isAbsolute(nameOrDir) || nameOrDir.startsWith('.') || existsSync(nameOrDir)) {
-        return openDir(nameOrDir);
-    }
-    const entry = (await Registry.open()).find(nameOrDir);
-    if (!entry) {
-        throw usageError(`no project named "${nameOrDir}"`, 'see: zen list');
-    }
-    return openDir(entry.path);
-}
-/**
- * `open` where a miss is an answer rather than an error. It exists for the one
- * place a word might be a project name and might be something else entirely —
- * `zen run <project>` against `zen run <prompt>` — and the difference decides
- * how the rest of the line is read.
- */
-export async function find(nameOrDir) {
-    if (isAbsolute(nameOrDir) || nameOrDir.startsWith('.') || existsSync(nameOrDir)) {
-        const dir = resolve(nameOrDir);
-        return isProjectDir(dir) ? { dir, name: await nameOf(dir) } : undefined;
-    }
-    const entry = (await Registry.open()).find(nameOrDir);
-    return entry ? openDir(entry.path) : undefined;
-}
-/** The project a bare command means: the one you are standing in. */
-export async function current(cwd = process.cwd()) {
-    return findUp(cwd);
-}
-export class Registry {
-    #file;
-    constructor(file) {
-        this.#file = file;
-    }
-    static async open() {
-        const file = await readJson(paths.projects(), {
-            version: 1,
-            projects: [],
-        });
-        return new Registry({ version: 1, projects: file.projects ?? [] });
-    }
-    get entries() {
-        return this.#file.projects;
-    }
-    find(name) {
-        return this.#file.projects.find((p) => p.name === name);
-    }
-    findPath(dir) {
-        const at = resolve(dir);
-        return this.#file.projects.find((p) => resolve(p.path) === at);
-    }
-    /** Idempotent: re-registering the same directory refreshes it in place. */
-    add(name, dir) {
-        const path = resolve(dir);
-        const existing = this.find(name);
-        if (existing && resolve(existing.path) !== path) {
-            throw usageError(`a different project is already named "${name}"`, `it lives at ${existing.path} — use --name`);
-        }
-        const byPath = this.findPath(path);
-        if (byPath) {
-            byPath.name = name;
-            return byPath;
-        }
-        const entry = { name, path, addedAt: new Date().toISOString() };
-        this.#file.projects.push(entry);
-        return entry;
-    }
-    remove(name) {
-        const at = this.#file.projects.findIndex((p) => p.name === name);
-        if (at < 0) {
-            return false;
-        }
-        this.#file.projects.splice(at, 1);
-        return true;
-    }
-    /** Drops entries whose directory is gone. Returns what it dropped. */
-    prune() {
-        const gone = this.#file.projects.filter((p) => !isProjectDir(p.path));
-        this.#file.projects = this.#file.projects.filter((p) => !gone.includes(p));
-        return gone;
-    }
-    save() {
-        writeJson(paths.projects(), this.#file, 0o600);
-    }
-}
-export async function summarize(entry) {
-    const base = {
-        name: entry.name,
-        path: entry.path,
-        present: false,
-        sessions: 0,
-        runs: 0,
-        busy: false,
-    };
-    if (!isProjectDir(entry.path)) {
-        return base;
-    }
-    const summary = { ...base, present: true };
-    for (const session of sessionIds(entry.path)) {
-        summary.sessions++;
-        const dir = join(entry.path, 'sessions', session);
-        if (isBusy(dir)) {
-            summary.busy = true;
-        }
-        const ids = runIds(dir);
-        summary.runs += ids.length;
-        const newest = ids.at(-1);
-        if (newest && (!summary.lastRunAt || newest > summary.lastRunAt)) {
-            summary.lastRunAt = newest;
-        }
-    }
-    return summary;
-}
-// ---------------------------------------------------------------------------
-// Sessions and runs
-//
-// Kept here rather than in session.ts because listing them is a read-only
-// question about a directory, and `zen list` must be able to ask it without
-// pulling in the runtime.
-// ---------------------------------------------------------------------------
-export const sessionsDir = (projectDir) => join(projectDir, 'sessions');
-/** Session ids, oldest first. Only well-formed stamps count as sessions. */
-export function sessionIds(projectDir) {
-    return stampedChildren(sessionsDir(projectDir));
-}
-export function runIds(sessionDir) {
-    return stampedChildren(join(sessionDir, 'runs'));
-}
-/**
- * When this project was last worked in, as a stamp, or `undefined` for one
- * that never has been. Session and run ids are stamps in the same format, so
- * the newest of either compares directly — and reading directory NAMES is what
- * keeps this cheap enough to ask of every registered project before drawing a
- * chooser.
- */
-export function lastUsedAt(projectDir) {
-    let last;
-    for (const id of sessionIds(projectDir)) {
-        const newest = runIds(join(sessionsDir(projectDir), id)).at(-1) ?? id;
-        if (!last || newest > last) {
-            last = newest;
-        }
-    }
-    return last;
-}
-function stampedChildren(dir) {
-    if (!existsSync(dir)) {
-        return [];
-    }
-    return readdirSync(dir, { withFileTypes: true })
-        .filter((e) => e.isDirectory() && isStamp(e.name))
-        .map((e) => e.name)
-        .sort();
-}
-/**
- * What a tree occupies, in allocated blocks rather than in bytes, because a
- * sparse file costs what it was given and not what it claims. Symlinks are
- * counted and never followed: a link out of the tree is not part of it, and
- * one that points back in would otherwise be counted twice — or forever.
- */
-export function dirSize(dir) {
-    let total = 0;
-    const stack = [dir];
-    while (stack.length > 0) {
-        const at = stack.pop();
-        let entries;
-        try {
-            entries = readdirSync(at, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            const path = join(at, entry.name);
-            if (entry.isDirectory()) {
-                stack.push(path);
-                continue;
-            }
-            try {
-                total += lstatSync(path).blocks * 512;
-            }
-            catch {
-                // Gone between the listing and the stat: a live session is
-                // writing, which is normal and not worth failing a report for.
-            }
-        }
-    }
-    return total;
-}
-/** True when a session's lock names a process that is still alive. */
-export function isBusy(sessionDir) {
-    const path = join(sessionDir, '.lock');
-    try {
-        const { pid } = JSON.parse(readFileSync(path, 'utf8'));
-        return typeof pid === 'number' && pidAlive(pid);
-    }
-    catch {
-        // Absent, unreadable or malformed: nothing is holding it.
-        return false;
-    }
-}
-export function projectName(dir) {
-    return basename(resolve(dir));
-}
-//# sourceMappingURL=projects.js.map

package/dist/session.d.ts

@@ -1,112 +0,0 @@
-export interface SessionPaths {
-    id: string;
-    dir: string;
-    /** what the agent can see and write */
-    workspace: string;
-    data: string;
-    /** the live, resumable state — rewritten after every run */
-    state: string;
-    blobs: string;
-    runs: string;
-    lock: string;
-    meta: string;
-}
-export declare function sessionPaths(projectDir: string, id: string): SessionPaths;
-export interface SessionMeta {
-    version: 1;
-    id: string;
-    createdAt: string;
-    /**
-     * Absolute path the agent's file tools are rooted at. Recorded so resuming
-     * never re-asks and never silently moves — a session that quietly changed
-     * what "the workspace" meant between turns would be unexplainable.
-     */
-    workspace: string;
-    lastRunAt?: string;
-    title?: string;
-}
-export declare function createSession(projectDir: string, id: string, workspace: string): SessionPaths;
-export declare function readSessionMeta(p: SessionPaths): Promise<SessionMeta>;
-export declare function writeSessionMeta(p: SessionPaths, meta: SessionMeta): void;
-export interface SessionSummary {
-    id: string;
-    createdAt?: string;
-    runs: number;
-    lastRunAt?: string;
-    busy: boolean;
-    title?: string;
-}
-/** Newest first — the order a picker wants. */
-export declare function listSessions(projectDir: string): Promise<SessionSummary[]>;
-export declare function newestSession(projectDir: string): string | undefined;
-export declare function requireSession(projectDir: string, id: string): SessionPaths;
-export interface Held {
-    release(): void;
-}
-export declare function acquire(p: SessionPaths): Held;
-export interface RunPaths {
-    id: string;
-    dir: string;
-    input: string;
-    output: string;
-    state: string;
-    report: string;
-    /** the same run as one Mermaid flowchart, for a model to read */
-    graph: string;
-    meta: string;
-}
-export declare function runPaths(session: SessionPaths, id: string): RunPaths;
-export declare function createRun(session: SessionPaths): RunPaths;
-/**
- * The same paths, reached from a directory instead of from a pair of ids.
- *
- * `zen run --json` hands back a run directory, and a caller holding one has no
- * reason to take it apart again to ask a second question about the same run.
- * The layout is fixed, so the ids can be read back out of the path — and both
- * still go through `isStamp`, so a path from anywhere cannot name a directory
- * this layout would never have produced.
- *
- * The session comes back too, not only the run: blobs are stored per session,
- * so anything that resolves a payload needs both halves — and the project, so
- * a command reached this way can still read the project's config.
- */
-export declare function runPathsAt(dir: string): {
-    project: string;
-    session: SessionPaths;
-    run: RunPaths;
-};
-export interface RunMeta {
-    version: 1;
-    id: string;
-    session: string;
-    startedAt: string;
-    finishedAt: string;
-    durationMs: number;
-    agent: string;
-    stopReason: string;
-    turns: number;
-    usage: unknown;
-    workspace: string;
-    memory?: string;
-    error?: string;
-}
-export declare function writeRunMeta(p: RunPaths, meta: RunMeta): void;
-/**
- * Partial, because a run killed before it recorded anything still has a
- * directory, and every field here is worth having on its own.
- */
-export declare function readRunMeta(p: RunPaths): Promise<Partial<RunMeta>>;
-export interface RunSummary {
-    id: string;
-    startedAt?: string;
-    finishedAt?: string;
-    agent?: string;
-    stopReason?: string;
-    error?: string;
-}
-/** Newest first — the order a picker wants. */
-export declare function listRuns(session: SessionPaths): Promise<RunSummary[]>;
-export declare function newestRun(session: SessionPaths): string | undefined;
-/** A path to show a human: relative when that is shorter, absolute otherwise. */
-export declare function display(path: string, from?: string): string;
-//# sourceMappingURL=session.d.ts.map

package/dist/session.js

@@ -1,188 +0,0 @@
-import { claimLock, ownLock } from '@zenera/neo';
-import { existsSync, mkdirSync, rmSync } from 'node:fs';
-import { basename, dirname, join, relative, resolve } from 'node:path';
-import { readJson, writeJson } from "./home.js";
-import { isStamp, stamp, stampInstant } from "./ids.js";
-import { isBusy, runIds, sessionIds, sessionsDir } from "./projects.js";
-import { CliError, EXIT, invalidError, usageError } from "./term.js";
-export function sessionPaths(projectDir, id) {
-    if (!isStamp(id)) {
-        throw usageError(`"${id}" is not a session id`, 'ids look like 20260825-143012-a7f3');
-    }
-    const dir = join(sessionsDir(projectDir), id);
-    const data = join(dir, '.data');
-    return {
-        id,
-        dir,
-        workspace: join(dir, 'workspace'),
-        data,
-        state: join(data, 'state.json'),
-        blobs: join(data, 'blobs'),
-        runs: join(dir, 'runs'),
-        lock: join(dir, '.lock'),
-        meta: join(data, 'session.json'),
-    };
-}
-// ---------------------------------------------------------------------------
-// Creating and finding
-// ---------------------------------------------------------------------------
-export function createSession(projectDir, id, workspace) {
-    const p = sessionPaths(projectDir, id);
-    mkdirSync(p.data, { recursive: true });
-    mkdirSync(p.runs, { recursive: true });
-    mkdirSync(resolve(workspace), { recursive: true });
-    const meta = {
-        version: 1,
-        id: p.id,
-        createdAt: new Date().toISOString(),
-        workspace: resolve(workspace),
-    };
-    writeJson(p.meta, meta, 0o644);
-    return p;
-}
-export async function readSessionMeta(p) {
-    const meta = await readJson(p.meta, {});
-    return {
-        version: 1,
-        id: p.id,
-        createdAt: meta.createdAt ?? new Date().toISOString(),
-        // Sessions from before the workspace was recorded fall back to their
-        // own directory, which is where it would have been.
-        workspace: meta.workspace ?? p.workspace,
-        lastRunAt: meta.lastRunAt,
-        title: meta.title,
-    };
-}
-export function writeSessionMeta(p, meta) {
-    writeJson(p.meta, meta, 0o644);
-}
-/** Newest first — the order a picker wants. */
-export async function listSessions(projectDir) {
-    const out = [];
-    for (const id of sessionIds(projectDir).reverse()) {
-        const p = sessionPaths(projectDir, id);
-        const meta = await readSessionMeta(p);
-        const ids = runIds(p.dir);
-        out.push({
-            id,
-            createdAt: meta.createdAt,
-            runs: ids.length,
-            lastRunAt: meta.lastRunAt,
-            busy: isBusy(p.dir),
-            title: meta.title,
-        });
-    }
-    return out;
-}
-export function newestSession(projectDir) {
-    return sessionIds(projectDir).at(-1);
-}
-export function requireSession(projectDir, id) {
-    const p = sessionPaths(projectDir, id);
-    if (!existsSync(p.dir)) {
-        throw invalidError(`no session ${id}`, 'see: zen list --sessions');
-    }
-    return p;
-}
-export function acquire(p) {
-    claimLock(p.lock, ownLock(), (held) => new CliError(`session ${p.id} is already running (pid ${held.pid})`, EXIT.failed, 'wait for it, or start another with --new'), 2);
-    let released = false;
-    const release = () => {
-        if (released) {
-            return;
-        }
-        released = true;
-        rmSync(p.lock, { force: true });
-    };
-    return { release };
-}
-export function runPaths(session, id) {
-    if (!isStamp(id)) {
-        throw usageError(`"${id}" is not a run id`);
-    }
-    const dir = join(session.runs, id);
-    return {
-        id,
-        dir,
-        input: join(dir, 'input.md'),
-        output: join(dir, 'output.md'),
-        state: join(dir, 'state.json'),
-        report: join(dir, 'report.html'),
-        graph: join(dir, 'graph.mmd'),
-        meta: join(dir, 'meta.json'),
-    };
-}
-export function createRun(session) {
-    const p = runPaths(session, stamp());
-    mkdirSync(p.dir, { recursive: true });
-    return p;
-}
-/**
- * The same paths, reached from a directory instead of from a pair of ids.
- *
- * `zen run --json` hands back a run directory, and a caller holding one has no
- * reason to take it apart again to ask a second question about the same run.
- * The layout is fixed, so the ids can be read back out of the path — and both
- * still go through `isStamp`, so a path from anywhere cannot name a directory
- * this layout would never have produced.
- *
- * The session comes back too, not only the run: blobs are stored per session,
- * so anything that resolves a payload needs both halves — and the project, so
- * a command reached this way can still read the project's config.
- */
-export function runPathsAt(dir) {
-    const full = resolve(dir);
-    const runId = basename(full);
-    const sessionDir = dirname(dirname(full));
-    const wrong = () => usageError(`${display(full)} is not a run directory`, 'runs live at <project>/sessions/<session>/runs/<run>');
-    if (!isStamp(runId) || !isStamp(basename(sessionDir)) || basename(dirname(full)) !== 'runs') {
-        throw wrong();
-    }
-    const project = dirname(dirname(sessionDir));
-    const session = sessionPaths(project, basename(sessionDir));
-    const run = runPaths(session, runId);
-    if (resolve(run.dir) !== full) {
-        throw wrong();
-    }
-    if (!existsSync(run.state)) {
-        throw invalidError(`run ${runId} has no state.json`, 'only a run that got far enough to save state can be inspected');
-    }
-    return { project, session, run };
-}
-export function writeRunMeta(p, meta) {
-    writeJson(p.meta, meta, 0o644);
-}
-/**
- * Partial, because a run killed before it recorded anything still has a
- * directory, and every field here is worth having on its own.
- */
-export async function readRunMeta(p) {
-    return await readJson(p.meta, {});
-}
-/** Newest first — the order a picker wants. */
-export async function listRuns(session) {
-    const out = [];
-    for (const id of runIds(session.dir).reverse()) {
-        // A run killed before it recorded anything still has an id, and the id
-        // says when it started, so it is listable without its meta.
-        const meta = await readRunMeta(runPaths(session, id));
-        out.push({
-            id,
-            startedAt: meta.startedAt ?? stampInstant(id),
-            finishedAt: meta.finishedAt,
-            agent: meta.agent,
-            stopReason: meta.stopReason,
-            error: meta.error,
-        });
-    }
-    return out;
-}
-export function newestRun(session) {
-    return runIds(session.dir).at(-1);
-}
-/** A path to show a human: relative when that is shorter, absolute otherwise. */
-export function display(path, from = process.cwd()) {
-    const rel = relative(from, path);
-    return !rel.startsWith('..') && rel.length < path.length ? rel || '.' : path;
-}
-//# sourceMappingURL=session.js.map