@fungi.computer/truffle 0.0.0-stage → 0.2.0

package/dist/private-local-session-discovery.js

@@ -0,0 +1,278 @@
+import { readdir, realpath, stat } from "node:fs/promises";
+import { basename, dirname, join, resolve } from "node:path";
+import * as Effect from "effect/Effect";
+import { parseModelPreferenceJson } from "@fungi.computer/shiitake/model-preference";
+import { z } from "zod";
+import { readAgentDefaultModelJson } from "./private-local-agent-default-model.js";
+import { localAgentFolderSchema, resolveAgentFolder, } from "./private-local-sandbox-policy.js";
+import { logEvent } from "./log-event.js";
+import { readSessionSummaries, } from "@fungi.computer/shiitake/effect";
+import { createPrivateSqliteOwner, openPrivateReadOnlySqliteDatabase, privateSqliteFailureCode, } from "./private-sqlite-owner.js";
+function compareSummaries(left, right) {
+    return (right.updatedAt - left.updatedAt ||
+        right.createdAt - left.createdAt ||
+        left.title.localeCompare(right.title) ||
+        left.databasePath.localeCompare(right.databasePath) ||
+        left.sessionId.localeCompare(right.sessionId));
+}
+class LocalSessionDiscoveryError extends Error {
+    kind;
+    constructor(kind, options) {
+        super("Local session store could not be read", options);
+        this.kind = kind;
+    }
+}
+function sqliteProblemKind(code) {
+    if (code === "busy" || code === "locked")
+        return "in_use";
+    if (code === "corrupt" || code === "not_a_database")
+        return "corrupt";
+    return "unreadable";
+}
+function problemKind(cause) {
+    return cause instanceof LocalSessionDiscoveryError
+        ? cause.kind
+        : sqliteProblemKind(privateSqliteFailureCode(cause));
+}
+async function immediateStoreCandidates(root, relative) {
+    const directory = resolve(root, relative);
+    let entries;
+    try {
+        entries = await readdir(directory, { withFileTypes: true });
+    }
+    catch (cause) {
+        if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
+            return [];
+        throw cause;
+    }
+    return Promise.all(entries
+        .filter((entry) => (entry.isDirectory() || entry.isSymbolicLink()) &&
+        entry.name.length > 0)
+        .map(async (entry) => {
+        const path = join(directory, entry.name, "agent.sqlite");
+        try {
+            const metadata = await stat(path);
+            if (!metadata.isFile())
+                return undefined;
+            return { path };
+        }
+        catch (cause) {
+            if (cause instanceof Error &&
+                "code" in cause &&
+                cause.code === "ENOENT")
+                return undefined;
+            throw cause;
+        }
+    })).then((values) => values.filter((value) => value !== undefined));
+}
+/** The one plain phrase for a store written before the current schema, with how to reset it. */
+export function unreadableStoreReason(agentId) {
+    return `predates the current schema; move .fungi/agents/${agentId} aside to reset it`;
+}
+/**
+ * Whether a store's Agent is archived. A store this cannot read counts as
+ * not archived, so discovery still reports it as a problem.
+ */
+export function isArchivedStore(path) {
+    try {
+        return readPrivateLocalAgentProfile(path).archived;
+    }
+    catch (cause) {
+        if (!(cause instanceof LocalStoreSchemaError))
+            logEvent("store-archived", cause);
+        return false;
+    }
+}
+export async function listPrivateLocalAgentStores(root, visibility = "active") {
+    const candidates = await immediateStoreCandidates(root, ".fungi/agents");
+    const paths = new Set();
+    for (const candidate of candidates) {
+        try {
+            const path = await realpath(candidate.path);
+            if (visibility === "all" ||
+                isArchivedStore(path) === (visibility === "archived"))
+                paths.add(path);
+        }
+        catch (cause) {
+            if (cause instanceof Error && "code" in cause && cause.code === "ENOENT")
+                continue;
+            throw cause;
+        }
+    }
+    return [...paths];
+}
+const storedProfileSchema = z.strictObject({
+    name: z.string().nullable(),
+    createdBy: z.string().nullable(),
+    archived: z.union([z.literal(0), z.literal(1)]),
+    requireSandbox: z.union([z.literal(0), z.literal(1)]),
+    folder: localAgentFolderSchema,
+    model: z.string(),
+});
+/** A Local or Woodstock store outside the current schema; Local never migrates it. */
+export class LocalStoreSchemaError extends Error {
+    databasePath;
+    name = "LocalStoreSchemaError";
+    constructor(databasePath, options) {
+        super(`Agent store ${databasePath} is incompatible with this version of Fungi. To reset, stop the owning Fungi service, then move this database, its .owner.sqlite sidecar and any associated SQLite journal files aside together. Create a fresh Agent; existing Sessions are not migrated. Keep the moved files if you need their data.`, options);
+        this.databasePath = databasePath;
+    }
+}
+/**
+ * One Agent store's chosen display name, default model, whether it is
+ * archived and the Agent that created it (absent when a human made it), read
+ * without opening a host.
+ */
+export function readPrivateLocalAgentProfile(path) {
+    const database = openPrivateReadOnlySqliteDatabase(path);
+    try {
+        const columns = database
+            .prepare("PRAGMA table_info(private_local_identity)")
+            .all();
+        if (!["name", "created_by", "archived", "require_sandbox", "folder"].every((required) => columns.some((column) => column.name === required)))
+            throw new LocalStoreSchemaError(path);
+        const identity = database
+            .prepare("SELECT name, created_by, archived, require_sandbox, folder FROM private_local_identity WHERE singleton = 1")
+            .get();
+        const stored = storedProfileSchema.parse({
+            name: identity?.name,
+            createdBy: identity?.created_by,
+            archived: identity?.archived,
+            requireSandbox: identity?.require_sandbox,
+            folder: identity?.folder,
+            model: readAgentDefaultModelJson(database),
+        });
+        return {
+            name: stored.name ?? undefined,
+            createdBy: stored.createdBy,
+            archived: stored.archived === 1,
+            requireSandbox: stored.requireSandbox === 1,
+            folder: stored.folder,
+            model: parseModelPreferenceJson(stored.model),
+        };
+    }
+    finally {
+        database.close();
+    }
+}
+export async function readPrivateLocalSessionSummaries(path) {
+    const database = openPrivateReadOnlySqliteDatabase(path);
+    try {
+        database.exec("PRAGMA foreign_keys = ON");
+        let sqliteFailure;
+        const owner = createPrivateSqliteOwner(database, (code) => {
+            sqliteFailure = code;
+        });
+        const summaries = [];
+        let after;
+        try {
+            do {
+                const page = await Effect.runPromise(readSessionSummaries(owner, after));
+                for (const row of page.sessions) {
+                    // One unreadable Session marks this store corrupt, as before.
+                    if (row.kind === "unavailable")
+                        throw new LocalSessionDiscoveryError("corrupt");
+                    summaries.push({
+                        sessionId: row.sessionId,
+                        title: row.title,
+                        createdAt: row.createdAt,
+                        updatedAt: row.updatedAt,
+                        databasePath: path,
+                    });
+                }
+                after = page.next;
+            } while (after !== undefined);
+        }
+        catch (cause) {
+            if (cause instanceof LocalSessionDiscoveryError)
+                throw cause;
+            throw new LocalSessionDiscoveryError(sqliteProblemKind(sqliteFailure), {
+                cause,
+            });
+        }
+        return summaries.sort(compareSummaries);
+    }
+    finally {
+        database.close();
+    }
+}
+/**
+ * Discover existing folder sessions without opening or reconciling a host.
+ * Archived Agents and their Sessions are left out, so no picker or "newest
+ * Session" choice can land on one; `archived` lists only those instead.
+ */
+export async function readPrivateLocalSessionDiscovery(invocationRoot, request = {}) {
+    request.signal?.throwIfAborted();
+    const root = await realpath(resolve(invocationRoot));
+    const paths = await listPrivateLocalAgentStores(root, request.archived === true ? "archived" : "active");
+    const discovered = [];
+    const agents = [];
+    const profiles = new Map();
+    const problems = [];
+    for (const path of paths) {
+        request.signal?.throwIfAborted();
+        const agentId = basename(dirname(path));
+        try {
+            const summaries = await readPrivateLocalSessionSummaries(path);
+            discovered.push(...summaries);
+            let profile;
+            let unreadable;
+            try {
+                profile = readPrivateLocalAgentProfile(path);
+                resolveAgentFolder(root, profile.folder);
+                profiles.set(agentId, profile);
+            }
+            catch (cause) {
+                // Shown on the row so the user knows to reset the store; opening it
+                // refuses with the same error.
+                if (!(cause instanceof LocalStoreSchemaError))
+                    throw cause;
+                unreadable = unreadableStoreReason(agentId);
+            }
+            agents.push({
+                agentId,
+                name: profile?.name,
+                unreadable,
+                databasePath: path,
+                sessionCount: summaries.length,
+                updatedAt: summaries[0]?.updatedAt,
+            });
+        }
+        catch (cause) {
+            problems.push({ kind: problemKind(cause) });
+            agents.push({ agentId, databasePath: path, sessionCount: 0 });
+        }
+    }
+    discovered.sort(compareSummaries);
+    // The wire carries identity; clients derive the “made by” label from names.
+    const labelled = agents.map((agent) => {
+        const createdBy = profiles.get(agent.agentId)?.createdBy;
+        if (createdBy === undefined)
+            return agent;
+        return {
+            ...agent,
+            createdBy,
+        };
+    });
+    return { root, agents: labelled, sessions: discovered, problems };
+}
+/** Project the service-owned discovery into choices that resume through it. */
+export function projectPrivateLocalSessionDiscovery(discovered, connect) {
+    const sessions = discovered.sessions.map(({ databasePath, sessionId, ...display }) => Object.freeze({
+        ...display,
+        databasePath,
+        sessionId,
+        resume: (resumeRequest) => connect({
+            invocationRoot: discovered.root,
+            databasePath,
+            sessionId,
+            fungiMcp: resumeRequest?.fungiMcp,
+            requireSandbox: resumeRequest?.requireSandbox,
+        }, resumeRequest),
+    }));
+    return Object.freeze({
+        agents: Object.freeze(discovered.agents),
+        sessions: Object.freeze(sessions),
+        problems: Object.freeze(discovered.problems),
+    });
+}

package/dist/private-local-shiitake-host.d.ts

@@ -0,0 +1,44 @@
+import type { ShiitakeAgent, ShiitakeSession } from "@fungi.computer/shiitake";
+import type { ShiitakeEventSourceConstructor } from "@fungi.computer/shiitake/client";
+import { openPrivateLocalRuntimeHost, type PrivateLocalRuntimeHostOptions } from "./private-local-runtime-host.js";
+export type PrivateLocalShiitakeServer = Readonly<{
+    baseUrl: string;
+    close: () => Promise<void>;
+}>;
+export type PrivateLocalShiitakeServerOpener = (fetch: (request: Request) => Response | Promise<Response>) => PrivateLocalShiitakeServer;
+export type PrivateLocalShiitakeHostOpener = (input: PrivateLocalRuntimeHostOptions) => Promise<PrivateLocalShiitakeHost>;
+/** One private loopback Hono owner plus a neutral client mounted on it. */
+export type PrivateLocalShiitakeHost = Readonly<{
+    /** Stable Local directory identity of this authorized Agent. */
+    agentId: string;
+    /** Canonical file path owned by the server-backed local host. */
+    databasePath: string;
+    /** Private loopback origin for another neutral Shiitake client. */
+    baseUrl: string;
+    /** Client-owned neutral Session; close only releases client watches. */
+    client: ShiitakeAgent;
+    session: ShiitakeSession;
+    /** Stop the transport before releasing the RuntimeHost and database. */
+    close: () => Promise<void>;
+}>;
+/** Open one bounded private local Hono host on a loopback-only ephemeral port. */
+export declare function openPrivateLocalShiitakeHost(input: PrivateLocalRuntimeHostOptions, openServer: PrivateLocalShiitakeServerOpener, openHost?: typeof openPrivateLocalRuntimeHost, eventSource?: ShiitakeEventSourceConstructor): Promise<PrivateLocalShiitakeHost>;
+/** Explicit static input for one independently owned local worker route. */
+export type PrivateLocalShiitakeWorkerInput = Readonly<{
+    name: string;
+    owner: PrivateLocalRuntimeHostOptions;
+}>;
+/** One mounted route and its resolved durable Agent store. */
+export type PrivateLocalShiitakeWorkerRoute = Readonly<{
+    name: string;
+    routePath: string;
+    databasePath: string;
+}>;
+/** One physical server hosting a static batch of independent local owners. */
+export type PrivateLocalShiitakeWorkerBatch = Readonly<{
+    baseUrl: string;
+    workers: readonly PrivateLocalShiitakeWorkerRoute[];
+    close: () => Promise<void>;
+}>;
+/** Mount a static batch of Local Agents behind exactly one maintained Hono server. */
+export declare function openPrivateLocalShiitakeWorkerBatch(inputs: readonly PrivateLocalShiitakeWorkerInput[], openServer: PrivateLocalShiitakeServerOpener, openHost?: typeof openPrivateLocalRuntimeHost): Promise<PrivateLocalShiitakeWorkerBatch>;

package/dist/private-local-shiitake-host.js

@@ -0,0 +1,143 @@
+import { logEvent } from "./log-event.js";
+import { Hono } from "hono";
+import * as Schema from "effect/Schema";
+import { createShiitakeClient } from "@fungi.computer/shiitake/client";
+import { createShiitakeHttpRoutes } from "@fungi.computer/shiitake/http";
+import { openPrivateLocalRuntimeHost, } from "./private-local-runtime-host.js";
+function asPrivateShiitakeFailure(cause, message) {
+    return cause instanceof Error ? cause : new Error(message, { cause });
+}
+function aggregatePrivateShiitakeFailures(failures, message) {
+    if (failures.length === 1) {
+        const [failure] = failures;
+        if (failure === undefined)
+            throw new Error("Missing private Shiitake failure");
+        return failure;
+    }
+    return new AggregateError(failures, message);
+}
+async function capturePrivateShiitakeCloseFailure(failures, close, message) {
+    try {
+        await close();
+    }
+    catch (cause) {
+        logEvent(message, cause);
+        failures.push(asPrivateShiitakeFailure(cause, message));
+    }
+}
+async function closePrivateShiitakeResources(failures, client, server, owner) {
+    if (client !== undefined)
+        await capturePrivateShiitakeCloseFailure(failures, client.close, "Private Shiitake client close failed");
+    if (server !== undefined)
+        await capturePrivateShiitakeCloseFailure(failures, server.close, "Private Shiitake server close failed");
+    await capturePrivateShiitakeCloseFailure(failures, owner.close, "Private Shiitake owner close failed");
+}
+/** Open one bounded private local Hono host on a loopback-only ephemeral port. */
+export async function openPrivateLocalShiitakeHost(input, openServer, openHost = openPrivateLocalRuntimeHost, eventSource) {
+    const owner = await openHost(input);
+    const routes = createShiitakeHttpRoutes((sessionId) => owner.getSession(sessionId), owner.listSessions, owner.createSession, owner.deleteSession, () => owner.extensions);
+    const fetch = (request) => routes.fetch(request);
+    let server;
+    let client;
+    try {
+        server = openServer(fetch);
+        const mountedServer = server;
+        const clientOptions = eventSource === undefined
+            ? { baseUrl: mountedServer.baseUrl }
+            : { baseUrl: mountedServer.baseUrl, eventSource };
+        const mountedClient = createShiitakeClient(clientOptions);
+        client = mountedClient;
+        let closing;
+        return Object.freeze({
+            agentId: owner.agentId,
+            databasePath: owner.databasePath,
+            baseUrl: mountedServer.baseUrl,
+            client: mountedClient,
+            session: mountedClient.session("main"),
+            close: () => {
+                closing ??= (async () => {
+                    const failures = [];
+                    await closePrivateShiitakeResources(failures, mountedClient, mountedServer, owner);
+                    if (failures.length > 0)
+                        throw aggregatePrivateShiitakeFailures(failures, "Private Shiitake host close failed");
+                })();
+                return closing;
+            },
+        });
+    }
+    catch (cause) {
+        const failures = [
+            asPrivateShiitakeFailure(cause, "Private Shiitake host initialization failed"),
+        ];
+        await closePrivateShiitakeResources(failures, client, server, owner);
+        throw aggregatePrivateShiitakeFailures(failures, "Private Shiitake host initialization failed");
+    }
+}
+const localWorkerNameSchema = Schema.String.pipe(Schema.check(Schema.isMinLength(1)), Schema.check(Schema.isPattern(/^[A-Za-z0-9][A-Za-z0-9_-]*$/u)));
+const decodeLocalWorkerName = Schema.decodeUnknownResult(localWorkerNameSchema);
+function validateLocalWorkerInputs(inputs) {
+    if (inputs.length === 0)
+        throw new Error("Private local Shiitake worker batch cannot be empty");
+    const names = new Set();
+    return inputs.map((input) => {
+        const decoded = decodeLocalWorkerName(input.name);
+        if (decoded._tag === "Failure")
+            throw new Error("Invalid private local Shiitake worker route identity: " + input.name);
+        if (names.has(decoded.success))
+            throw new Error("Duplicate private local Shiitake worker route identity: " +
+                decoded.success);
+        names.add(decoded.success);
+        return Object.freeze({ ...input, name: decoded.success });
+    });
+}
+async function closePrivateLocalWorkerBatch(failures, server, owners) {
+    if (server !== undefined)
+        await capturePrivateShiitakeCloseFailure(failures, server.close, "Private Shiitake worker server close failed");
+    for (const { owner } of owners)
+        await capturePrivateShiitakeCloseFailure(failures, owner.close, "Private Shiitake worker owner close failed");
+}
+/** Mount a static batch of Local Agents behind exactly one maintained Hono server. */
+export async function openPrivateLocalShiitakeWorkerBatch(inputs, openServer, openHost = openPrivateLocalRuntimeHost) {
+    const validated = validateLocalWorkerInputs(inputs);
+    const owners = [];
+    let server;
+    try {
+        const app = new Hono();
+        const workers = [];
+        for (const input of validated) {
+            const owner = await openHost(input.owner);
+            owners.push({ name: input.name, owner });
+            const routes = createShiitakeHttpRoutes((sessionId) => owner.getSession(sessionId), owner.listSessions, owner.createSession, owner.deleteSession, () => owner.extensions);
+            const routePath = "/workers/" + input.name;
+            app.route(routePath, routes);
+            workers.push(Object.freeze({
+                name: input.name,
+                routePath,
+                databasePath: owner.databasePath,
+            }));
+        }
+        server = openServer((request) => app.fetch(request));
+        const mountedServer = server;
+        let closing;
+        return Object.freeze({
+            baseUrl: mountedServer.baseUrl,
+            workers: Object.freeze(workers),
+            close: () => {
+                closing ??= (async () => {
+                    const failures = [];
+                    await closePrivateLocalWorkerBatch(failures, mountedServer, owners);
+                    if (failures.length > 0)
+                        throw aggregatePrivateShiitakeFailures(failures, "Private Shiitake worker batch close failed");
+                })();
+                return closing;
+            },
+        });
+    }
+    catch (cause) {
+        const failures = [
+            asPrivateShiitakeFailure(cause, "Private Shiitake worker batch initialization failed"),
+        ];
+        await closePrivateLocalWorkerBatch(failures, server, owners);
+        throw aggregatePrivateShiitakeFailures(failures, "Private Shiitake worker batch initialization failed");
+    }
+}

package/dist/private-local-startup-model.d.ts

@@ -0,0 +1,51 @@
+import { getSupportedThinkingLevels, type Api, type Model, type Models, type ThinkingLevel } from "@earendil-works/pi-ai";
+import { type ModelPreference } from "@fungi.computer/shiitake/model-preference";
+/** Which layer decided a startup model: a Session override, the Agent default, or the available login. */
+export type LocalStartupModelSource = "session" | "agent" | "available";
+/** The one model choice a run or a new chat starts from, before it is checked against its provider. */
+export type LocalStartupChoice = Readonly<{
+    preference: ModelPreference;
+    source: LocalStartupModelSource;
+}>;
+/** The effective model a new chat of one Agent starts with. */
+export type LocalStartupModel = Readonly<{
+    providerId: string;
+    modelId: string;
+    reasoning: ThinkingLevel | undefined;
+    source: LocalStartupModelSource;
+}>;
+/** Validate a requested thinking level against the registered model. */
+export declare function validateLocalReasoning(model: Parameters<typeof getSupportedThinkingLevels>[0], requested: ThinkingLevel | undefined): void;
+/** Local's default is medium, clamped through Pi's model capabilities. */
+export declare function defaultLocalReasoning(model: Parameters<typeof getSupportedThinkingLevels>[0]): ThinkingLevel | undefined;
+/**
+ * The thinking level a chosen model runs with: the choice's own level, else
+ * the opener's level when this model supports it, else Local's default.
+ */
+export declare function startupReasoning(selected: Model<Api>, preference: ModelPreference, ownerReasoning?: ThinkingLevel): ThinkingLevel | undefined;
+/** Resolve explicit layers without checking logins or discovering models. */
+export declare function resolveKnownLocalStartupChoice(input: Readonly<{
+    session: ModelPreference | null;
+    agent: ModelPreference | null;
+}>): LocalStartupChoice | null;
+/**
+ * Resolve the explicit choice, or discover the available login. An explicit
+ * layer never falls through on an auth failure; the caller reports it.
+ */
+export declare function resolveLocalStartupChoice(input: Readonly<{
+    models: Models;
+    session: ModelPreference | null;
+    agent: ModelPreference | null;
+    signal: AbortSignal;
+}>): Promise<LocalStartupChoice | null>;
+/**
+ * The model a new chat of the Agent at `databasePath` starts with; no store
+ * means a new Agent, which starts from the available login. A store that
+ * predates the current schema fails loudly. The landing and a
+ * fresh Session both resolve through this chain.
+ */
+export declare function resolveAgentStartupModel(input: Readonly<{
+    models: Models;
+    databasePath: string | undefined;
+    signal: AbortSignal;
+}>): Promise<LocalStartupModel | null>;

package/dist/private-local-startup-model.js

@@ -0,0 +1,86 @@
+import { clampThinkingLevel, getSupportedThinkingLevels, } from "@earendil-works/pi-ai";
+import {} from "@fungi.computer/shiitake/model-preference";
+import { readPrivateLocalAgentProfile } from "./private-local-session-discovery.js";
+import { defaultLocalModel } from "./private-local-default-model.js";
+/** Validate a requested thinking level against the registered model. */
+export function validateLocalReasoning(model, requested) {
+    if (requested === undefined)
+        return;
+    const supported = getSupportedThinkingLevels(model).filter((level) => level !== "off");
+    if (!supported.includes(requested))
+        throw new Error("Reasoning level " +
+            requested +
+            " is not supported by " +
+            model.provider +
+            "/" +
+            model.id +
+            "; supported levels: " +
+            (supported.join(", ") || "none"));
+}
+/** Local's default is medium, clamped through Pi's model capabilities. */
+export function defaultLocalReasoning(model) {
+    const level = clampThinkingLevel(model, "medium");
+    return level === "off" ? undefined : level;
+}
+/**
+ * The thinking level a chosen model runs with: the choice's own level, else
+ * the opener's level when this model supports it, else Local's default.
+ */
+export function startupReasoning(selected, preference, ownerReasoning) {
+    return (preference.reasoning ??
+        (ownerReasoning !== undefined &&
+            getSupportedThinkingLevels(selected).includes(ownerReasoning)
+            ? ownerReasoning
+            : defaultLocalReasoning(selected)));
+}
+/** Resolve explicit layers without checking logins or discovering models. */
+export function resolveKnownLocalStartupChoice(input) {
+    if (input.session !== null)
+        return { preference: input.session, source: "session" };
+    if (input.agent !== null)
+        return { preference: input.agent, source: "agent" };
+    return null;
+}
+/**
+ * Resolve the explicit choice, or discover the available login. An explicit
+ * layer never falls through on an auth failure; the caller reports it.
+ */
+export async function resolveLocalStartupChoice(input) {
+    const known = resolveKnownLocalStartupChoice(input);
+    if (known !== null)
+        return known;
+    const available = await defaultLocalModel(input.models, input.signal);
+    return available === null
+        ? null
+        : { preference: available, source: "available" };
+}
+/**
+ * The model a new chat of the Agent at `databasePath` starts with; no store
+ * means a new Agent, which starts from the available login. A store that
+ * predates the current schema fails loudly. The landing and a
+ * fresh Session both resolve through this chain.
+ */
+export async function resolveAgentStartupModel(input) {
+    const agent = input.databasePath === undefined
+        ? null
+        : readPrivateLocalAgentProfile(input.databasePath).model;
+    const choice = await resolveLocalStartupChoice({
+        models: input.models,
+        session: null,
+        agent,
+        signal: input.signal,
+    });
+    if (choice === null)
+        return null;
+    const { providerId, modelId } = choice.preference;
+    const selected = input.models.getModel(providerId, modelId);
+    return {
+        providerId,
+        modelId,
+        // A catalog not loaded yet cannot name a level; the run resolves it later.
+        reasoning: selected === undefined
+            ? choice.preference.reasoning
+            : startupReasoning(selected, choice.preference),
+        source: choice.source,
+    };
+}

package/dist/private-local-stop-all.d.ts

@@ -0,0 +1,27 @@
+import { z } from "zod";
+/** The service reports each attempted Agent, including partial failures. */
+export declare const stopAllResultSchema: z.ZodObject<{
+    rootAgentId: z.ZodString;
+    agents: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        outcome: z.ZodEnum<{
+            stopped: "stopped";
+            idle: "idle";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        agentId: z.ZodString;
+        name: z.ZodString;
+        outcome: z.ZodLiteral<"failed">;
+        reason: z.ZodString;
+    }, z.core.$strict>], "outcome">>;
+    discoveryFailures: z.ZodArray<z.ZodObject<{
+        agentId: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type StopAllResult = z.infer<typeof stopAllResultSchema>;
+export declare const stopAllRequestSchema: z.ZodObject<{
+    invocationRoot: z.ZodString;
+    agentId: z.ZodString;
+}, z.core.$strict>;

package/dist/private-local-stop-all.js

@@ -0,0 +1,26 @@
+import { z } from "zod";
+/** The service reports each attempted Agent, including partial failures. */
+export const stopAllResultSchema = z.strictObject({
+    rootAgentId: z.string(),
+    agents: z.array(z.discriminatedUnion("outcome", [
+        z.strictObject({
+            agentId: z.string(),
+            name: z.string(),
+            outcome: z.enum(["stopped", "idle"]),
+        }),
+        z.strictObject({
+            agentId: z.string(),
+            name: z.string(),
+            outcome: z.literal("failed"),
+            reason: z.string(),
+        }),
+    ])),
+    discoveryFailures: z.array(z.strictObject({
+        agentId: z.string(),
+        reason: z.string(),
+    })),
+});
+export const stopAllRequestSchema = z.strictObject({
+    invocationRoot: z.string().min(1),
+    agentId: z.string().min(1),
+});

package/dist/private-local-ui-attachment.d.ts

@@ -0,0 +1,19 @@
+import type { Json } from "@fungi.computer/shiitake/extensions";
+import { z } from "zod";
+export declare const localUiAttachmentLifetimeSchema: z.ZodEnum<{
+    watch: "watch";
+    connection: "connection";
+}>;
+export type LocalUiAttachmentLifetime = z.infer<typeof localUiAttachmentLifetimeSchema>;
+/** Host-held authority; a JSON identity or pending id cannot create one. */
+export type LocalUiAttachment = Readonly<{
+    sessionId: string;
+    signal: AbortSignal;
+    close: () => void;
+}>;
+export declare function createLocalUiAttachment(sessionId: string, lifetime?: LocalUiAttachmentLifetime): LocalUiAttachment;
+export declare function startLocalUiWatch(attachment: LocalUiAttachment, sessionId: string): (() => void) | undefined;
+/** Authority lasts for one command, not model work that might wake later. */
+export declare function runLocalUiCommand(attachment: LocalUiAttachment, sessionId: string, body: () => Promise<Json>): Promise<Json>;
+/** Consume host authority before registering the post-commit continuation. */
+export declare function consumeLocalUiCommand(sessionId: string): ((complete: (committed: boolean) => Promise<Json>) => void) | undefined;