@oharness/engine 0.1.0

package/dist/harness.js

@@ -0,0 +1,695 @@
+import { AuthManager } from "./auth/manager.js";
+import { ConfigError } from "./core/errors.js";
+import { apiKeyProvider, oauthProvider } from "./auth/providers/generic.js";
+import { Agent } from "./agent/agent.js";
+import { HookRegistry } from "./agent/hooks.js";
+import { Session } from "./agent/session.js";
+import { SessionStore } from "./agent/store.js";
+import { BUILTIN_SUBAGENTS, SubagentRegistry, loadMarkdownSubagents } from "./agent/subagent.js";
+import { SkillRegistry } from "./agent/skills.js";
+import { SettingsStore } from "./agent/settings.js";
+import { createPolicy } from "./agent/workspace.js";
+import { MemoryStore } from "./agent/memory.js";
+import { loadConfig, loadProjectConfig, loadProjectInstructions, mergeConfig } from "./config.js";
+import { discoverPlugins, pluginContributions } from "./plugins.js";
+import { McpManager } from "./mcp/manager.js";
+import { beginMcpLogin, forgetMcpAuth } from "./mcp/oauth.js";
+import { expandSecrets } from "./mcp/secrets.js";
+import { Scheduler } from "./schedule/scheduler.js";
+import { SyncClient } from "./sync/client.js";
+import { SessionMirror } from "./sync/mirror.js";
+import { isExcluded, resolveSync } from "./sync/settings.js";
+import { projectId } from "./storage/project.js";
+import { updateUserConfig } from "./config.js";
+import { ProviderRegistry } from "./providers/registry.js";
+import { loadCatalog, userCatalogPath } from "./providers/catalog.js";
+import { builtinTools } from "./tools/builtin/index.js";
+import { ToolRegistry } from "./tools/registry.js";
+import { appendFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { createLogger } from "./util/logger.js";
+/**
+ * Top-level facade: owns providers, tools, MCP connections, hooks and
+ * subagents, and hands out `Agent` instances bound to a `Session`.
+ *
+ * Construct it with `Harness.create()` rather than `new`, because MCP
+ * connection and config loading are async.
+ */
+export class Harness {
+    cwd;
+    config;
+    providers;
+    tools;
+    hooks;
+    subagents;
+    skills;
+    memory;
+    settings;
+    workspace;
+    mcp;
+    store;
+    auth;
+    catalog;
+    scheduler;
+    ephemeral;
+    /** Mirrors this project's transcripts, when sync is on and signed in. */
+    mirror;
+    syncState = {
+        on: false,
+        reason: "no-credential",
+    };
+    /** Active declarative plugin bundles, in their effective override order. */
+    plugins;
+    logger;
+    options;
+    projectInstructions;
+    constructor(opts, config, catalog, plugins = []) {
+        this.options = opts;
+        this.cwd = opts.cwd ?? process.cwd();
+        this.config = config;
+        this.logger = opts.logger ?? createLogger("harness", config.logLevel ?? "warn", opts.logSink);
+        this.auth = new AuthManager({ logger: this.logger });
+        for (const provider of opts.authProviders ?? [])
+            this.auth.register(provider);
+        // Subscription vendors declared in config become first-class auth providers.
+        for (const vendor of config.oauthProviders ?? []) {
+            this.auth.register(oauthProvider(vendor));
+        }
+        // The resolver is called on every request, so an expiring subscription
+        // token refreshes without the session noticing.
+        this.catalog = catalog;
+        this.plugins = plugins;
+        this.providers = ProviderRegistry.fromCatalog(catalog, {
+            creds: config.providers,
+            auth: (ctx) => this.auth.resolve(ctx),
+        });
+        // Every catalog provider gets an API-key login entry, so `auth login`
+        // covers whatever the catalog declares rather than a hardcoded three.
+        for (const entry of this.providers.listCatalogProviders()) {
+            if (this.auth.get(entry.id))
+                continue; // a richer provider already claimed it
+            this.auth.register(apiKeyProvider({
+                id: entry.id,
+                label: entry.label,
+                envVars: entry.envVars,
+                placeholder: entry.docsUrl ? `get one at ${entry.docsUrl}` : undefined,
+            }));
+        }
+        for (const vendor of config.openAiCompatible ?? []) {
+            this.providers.registerOpenAiCompatible(vendor);
+        }
+        for (const model of config.models ?? [])
+            this.providers.registerModel(model);
+        this.tools = new ToolRegistry().registerAll(builtinTools);
+        for (const tool of opts.tools ?? [])
+            this.tools.register(tool);
+        this.hooks = new HookRegistry(this.logger).loadShellHooks(config.hooks ?? {});
+        this.subagents = new SubagentRegistry([
+            ...BUILTIN_SUBAGENTS,
+            ...(config.subagents ?? []),
+        ]);
+        this.skills = new SkillRegistry(this.logger);
+        this.settings = new SettingsStore(this.cwd);
+        this.workspace = createPolicy(this.cwd, {
+            ...(config.workspaceMode !== undefined ? { mode: config.workspaceMode } : {}),
+            // Every directory a registry scans is one the agent can work in. A skill
+            // it is told about but cannot open is a skill it cannot follow, and one
+            // it cannot edit is a skill it cannot fix — `skillDirs` reaches outside
+            // the project by design, and stopping at the project boundary would put
+            // half of what the harness loads permanently out of reach.
+            //
+            // This includes the plugin directories read out of Claude Code's cache.
+            // Those belong to another program's installer, so the agent editing one
+            // edits something this harness did not put there; the alternative was a
+            // registry that advertises skills nobody can repair, and between the two
+            // this is the one that was asked for.
+            writableRoots: [
+                ...(config.writableRoots ?? []),
+                ...(config.skillDirs ?? []),
+                ...(config.agentDirs ?? []),
+            ],
+            ...(config.readableRoots !== undefined ? { readableRoots: config.readableRoots } : {}),
+        });
+        this.memory = new MemoryStore(config.memoryDir
+            ? path.resolve(this.cwd, config.memoryDir)
+            : path.join(this.cwd, ".oharness", "memory"));
+        this.mcp = new McpManager(this.logger, this.auth.store);
+        this.store = new SessionStore(config.sessionDir);
+        this.scheduler = new Scheduler(this, config.schedules ?? []);
+        this.ephemeral = opts.ephemeral === true;
+    }
+    static async create(opts = {}) {
+        const cwd = opts.cwd ?? process.cwd();
+        const baseConfig = opts.config ?? (await loadConfig(cwd));
+        const plugins = await discoverPlugins(cwd, baseConfig.plugins);
+        // Explicit user/project config is applied after plugins, so it can always
+        // tighten policy or replace a plugin's MCP server declaration.
+        const config = mergeConfig(pluginContributions(plugins), baseConfig);
+        // The catalog is data on disk, so it can be updated without a release.
+        const catalog = await loadCatalog(config.catalog ? [config.catalog] : []);
+        const harness = new Harness(opts, config, catalog, plugins);
+        harness.projectInstructions = await loadProjectInstructions(cwd, config.instructionsFile);
+        // Rules the user approved in earlier sessions live in settings files, not
+        // in the config the project checks in.
+        const persisted = await harness.settings.readAll();
+        harness.config.permissions = {
+            allow: [...(config.permissions?.allow ?? []), ...(persisted.allow ?? [])],
+            deny: [...(config.permissions?.deny ?? []), ...(persisted.deny ?? [])],
+            ask: [...(config.permissions?.ask ?? []), ...(persisted.ask ?? [])],
+        };
+        // Best effort: reclaiming disk should never block or fail a session.
+        if (config.sessionRetention && !opts.ephemeral) {
+            harness.store
+                .prune(config.sessionRetention)
+                .then((removed) => {
+                if (removed.length > 0) {
+                    harness.logger.info("pruned old sessions", { count: removed.length });
+                }
+            })
+                .catch((err) => harness.logger.warn("session pruning failed", { error: String(err) }));
+        }
+        await harness.skills.discover(cwd, config.skillDirs ?? []);
+        // Markdown definitions layer over the JSON ones, so a repo can drop in an
+        // agent file without editing config.
+        for (const definition of await loadMarkdownSubagents(cwd, config.agentDirs ?? [])) {
+            harness.subagents.register(definition);
+        }
+        if (config.mcpServers && Object.keys(config.mcpServers).length > 0) {
+            const statuses = await harness.mcp.connectAll(config.mcpServers);
+            harness.tools.registerAll(harness.mcp.tools());
+            for (const status of statuses) {
+                if (status.error) {
+                    harness.logger.warn("MCP server unavailable", {
+                        server: status.name,
+                        error: status.error,
+                    });
+                }
+            }
+        }
+        // Awaited, though it touches no network: deciding whether to mirror reads
+        // config and asks git for the project id, and both are local. Leaving it
+        // unawaited made `syncStatus()` lie for the first few milliseconds of
+        // every process, which is exactly when a UI asks. The connecting happens
+        // inside the mirror and is not waited for.
+        await harness.startSync();
+        return harness;
+    }
+    /**
+     * Begin mirroring, if this machine is configured and signed in for it.
+     *
+     * Every reason not to is a normal state rather than an error — not signed
+     * in, switched off, this one repository excluded — so nothing here logs a
+     * failure for them. Only an actual attempt that goes wrong is worth a line.
+     */
+    async startSync() {
+        // An ephemeral harness has no session store to mirror; a subagent's would
+        // otherwise open a second connection for transcripts nobody keeps.
+        if (this.ephemeral)
+            return;
+        const decision = resolveSync({
+            config: this.config.sync,
+            accountToken: await this.accountToken(),
+        });
+        this.syncState = decision;
+        if (!decision.on)
+            return;
+        const project = await projectId(this.cwd);
+        if (isExcluded(this.config.sync, { id: project, cwd: this.cwd })) {
+            this.syncState = { on: false, reason: "excluded" };
+            return;
+        }
+        const configured = this.config.sync?.token ?? process.env["OHARNESS_SYNC_TOKEN"];
+        this.mirror = new SessionMirror({
+            store: this.store,
+            client: new SyncClient({
+                url: decision.target.url,
+                // Read per request rather than captured: an account token lasts an
+                // hour and is refreshed underneath, and a mirror holding the string it
+                // started with would stop for good once that hour was up.
+                token: configured ? configured : async () => (await this.accountToken()) ?? "",
+                ...(this.config.sync?.team ? { team: this.config.sync.team } : {}),
+            }),
+            projectId: project,
+            onError: (message) => this.logger.warn(message),
+        });
+        this.mirror.start();
+    }
+    /**
+     * The roots this machine was told to allow, as opposed to the ones it
+     * worked out.
+     *
+     * `workspace.writableRoots` is the sum of a choice and a derivation: what
+     * the config named, plus every skill and agent directory the installed
+     * plugins contributed. Only the first half is editable, and telling them
+     * apart is the difference between a settings row that works and one whose
+     * changes come back on the next launch.
+     */
+    configuredWritableRoots() {
+        return [...(this.config.writableRoots ?? [])];
+    }
+    /**
+     * Replace the roots this machine allows writes to.
+     *
+     * Takes effect on the next launch rather than now: the workspace policy is
+     * built once and handed to every tool, and swapping it under a turn already
+     * in flight would let a command that was checked against one answer run
+     * against another.
+     */
+    async setWritableRoots(roots) {
+        const cleaned = [...new Set(roots.map((root) => root.trim()).filter(Boolean))];
+        await updateUserConfig((current) => ({ ...current, writableRoots: cleaned }));
+        return cleaned;
+    }
+    /**
+     * Whether permission decisions are being recorded, and who decided that.
+     *
+     * Recording is on unless somebody turned it off: the trail is a handful of
+     * short lines per turn, it never leaves the machine, and the state where it
+     * is missing is exactly the state where it turns out to have been wanted.
+     *
+     * The source travels with the answer for the same reason sync carries a
+     * reason: a merged config cannot tell a value the user chose from one the
+     * repository imposed, and only the first can be changed from here. A switch
+     * offered over the second would appear to work and come back on the next
+     * launch, which is worse than no switch at all.
+     */
+    async auditStatus() {
+        // Best effort: a project config that has since become unreadable should
+        // not take the settings page down with it. Treated as "not the project's",
+        // which is the state the user can still act on.
+        const project = await loadProjectConfig(this.cwd).catch(() => undefined);
+        const file = this.config.auditLog;
+        return {
+            on: this.config.audit !== false,
+            ...(file ? { file, path: path.resolve(this.cwd, file) } : {}),
+            source: project?.audit === undefined ? "user" : "project",
+        };
+    }
+    /**
+     * Start or stop recording permission decisions, and remember the choice.
+     *
+     * Only the recording is a choice here. Where an extra copy is written is
+     * `auditLog`, and that stays where somebody typed it: a switch that also
+     * deleted a configured path would turn "stop recording for now" into
+     * "forget where my collector reads from".
+     *
+     * On is written as the *absence* of the key, because on is the default and a
+     * config file should say what somebody decided, not restate what they left
+     * alone. Takes effect on the sessions already open — see `equip`.
+     */
+    async setAudit(enabled) {
+        const status = await this.auditStatus();
+        if (status.source === "project") {
+            throw new ConfigError("this project's config decides the audit trail, so it cannot be changed here");
+        }
+        if (status.on === enabled)
+            return status;
+        this.config.audit = enabled;
+        await updateUserConfig((current) => {
+            const { audit: _previous, ...rest } = current;
+            return enabled ? rest : { ...rest, audit: false };
+        });
+        return this.auditStatus();
+    }
+    /** A session's permission trail, oldest first. Empty for an ephemeral one. */
+    async decisions(sessionId) {
+        if (this.ephemeral)
+            return [];
+        return this.store.decisions(sessionId);
+    }
+    /**
+     * Push whatever is waiting, now.
+     *
+     * The mirror pushes on its own — this is for the person who wants to know it
+     * has happened before closing the laptop, which is not a question a
+     * background timer can answer. False means there was nothing to push it
+     * through: off, excluded, or not signed in.
+     */
+    async syncNow() {
+        if (!this.mirror)
+            return false;
+        await this.mirror.flush();
+        return true;
+    }
+    /**
+     * The OHarness account access token, if signed in.
+     *
+     * Only `official` is asked. Other gateway entries in the catalog hold keys
+     * to *their* vendor, not to an OHarness account, and handing one of those to
+     * the artifact API would authenticate as nobody — the 401 that follows is a
+     * far worse way to find out than not trying.
+     *
+     * Public because publishing an artifact needs it too, and a second copy of
+     * this rule in the server package would be a second place to get it wrong.
+     */
+    async accountToken() {
+        return await this.auth.accessToken("official").catch(() => undefined);
+    }
+    /**
+     * Whether transcripts are leaving this machine, and why not when they are
+     * not.
+     *
+     * The reason is carried rather than collapsed to a boolean because "you
+     * turned this off" and "you are not signed in" look identical from outside
+     * and need opposite advice.
+     */
+    syncStatus() {
+        if (this.syncState.on) {
+            return { on: true, url: this.syncState.target.url };
+        }
+        return { on: false, reason: this.syncState.reason };
+    }
+    /**
+     * Turn sync on or off now, and remember the choice.
+     *
+     * Written to the user's config rather than held in memory, because a switch
+     * that forgets on restart is not a switch — someone who turned sync off did
+     * not mean "until the next launch". Stopping aborts the poll in flight, so
+     * the connection does not outlive the decision.
+     */
+    async setSyncEnabled(enabled) {
+        this.config.sync = { ...this.config.sync, enabled };
+        await updateUserConfig((current) => ({
+            ...current,
+            sync: { ...current.sync, enabled },
+        }));
+        if (enabled) {
+            if (!this.mirror)
+                await this.startSync();
+            else
+                this.mirror.start();
+            return;
+        }
+        this.mirror?.stop();
+        this.mirror = undefined;
+        this.syncState = { on: false, reason: "disabled" };
+    }
+    /** Connect an MCP server at runtime and expose its tools immediately. */
+    async addMcpServer(name, config) {
+        this.tools.unregisterServer(name);
+        const tools = await this.mcp.connect(name, config);
+        this.tools.registerAll(tools);
+        return (this.mcp.status().find((s) => s.name === name) ?? {
+            name,
+            connected: false,
+            transport: config.type,
+            toolCount: 0,
+        });
+    }
+    /**
+     * Begin an OAuth login for a connector that asked for one.
+     *
+     * The connector does not have to be connected — a server that answered 401
+     * is exactly the case this exists for. On success the server is reconnected,
+     * so the tools appear without the user doing anything else.
+     */
+    async mcpLogin(name) {
+        const config = this.mcp.configFor(name);
+        if (!config)
+            throw new ConfigError(`no MCP server named "${name}"`);
+        if (config.type !== "http") {
+            throw new ConfigError(`"${name}" runs locally and has nothing to log in to`);
+        }
+        const expanded = expandSecrets(config);
+        const challenge = this.mcp.authChallenge(name);
+        // The challenge's URL is the one the server actually answered on, which is
+        // what its authorization server will have been told about.
+        const url = challenge?.url ?? (expanded.type === "http" ? expanded.url : "");
+        const result = await beginMcpLogin({
+            serverUrl: url,
+            store: this.auth.store,
+            ...(challenge?.challenge ? { challenge: challenge.challenge } : {}),
+        });
+        if (result.method !== "auto")
+            return result;
+        const finish = result.callback;
+        return {
+            ...result,
+            method: "auto",
+            callback: async () => {
+                const outcome = await finish();
+                if (outcome.type === "success")
+                    await this.addMcpServer(name, config);
+                return outcome;
+            },
+        };
+    }
+    /** Forget a connector's credential. It will ask again on the next connect. */
+    async mcpLogout(name) {
+        const config = this.mcp.configFor(name);
+        if (!config || config.type !== "http")
+            return false;
+        const expanded = expandSecrets(config);
+        if (expanded.type !== "http")
+            return false;
+        return forgetMcpAuth(expanded.url, this.auth.store);
+    }
+    async removeMcpServer(name) {
+        // `remove`, not `disconnect`: an explicitly removed server must not come
+        // back through the reconnect path on the next tool call.
+        await this.mcp.remove(name);
+        this.tools.unregisterServer(name);
+    }
+    mcpStatus() {
+        return this.mcp.status();
+    }
+    authStatus() {
+        return this.auth.status();
+    }
+    /** Providers that can actually authenticate right now. */
+    async configuredProviders() {
+        const out = new Set();
+        for (const provider of this.providers.listProviders()) {
+            if (provider.isConfigured() || (await this.auth.isAuthenticated(provider.id))) {
+                out.add(provider.id);
+            }
+        }
+        return out;
+    }
+    /**
+     * Ask providers which models they actually serve, and persist the result to
+     * the user catalog so the next run starts with a current list.
+     */
+    async refreshModels(providerId) {
+        const discovered = await this.providers.refreshModels(providerId);
+        if (discovered.length > 0) {
+            await this.saveDiscovered(discovered).catch((err) => this.logger.warn("could not persist the discovered catalog", {
+                error: String(err),
+            }));
+        }
+        return discovered;
+    }
+    /** Merge discovered models into the user catalog on disk. */
+    async saveDiscovered(models) {
+        const file = userCatalogPath();
+        let existing = {};
+        try {
+            existing = JSON.parse(await readFile(file, "utf8"));
+        }
+        catch {
+            // No user catalog yet; start one.
+        }
+        const byId = new Map((Array.isArray(existing["models"]) ? existing["models"] : [])
+            .filter((m) => !!m && typeof m === "object")
+            .map((m) => [String(m["id"]), m]));
+        for (const model of models)
+            byId.set(model.id, model);
+        await mkdir(path.dirname(file), { recursive: true });
+        await writeFile(file, JSON.stringify({ ...existing, discoveredAt: new Date().toISOString(), models: [...byId.values()] }, null, 2), "utf8");
+    }
+    /**
+     * Re-scan the skill directories.
+     *
+     * Skills are ordinary markdown on disk and the agent can write them, so
+     * without this an authored skill sits unusable until the next restart —
+     * which breaks the one loop that would let the agent improve itself.
+     */
+    async reloadSkills() {
+        await this.skills.discover(this.cwd, this.config.skillDirs ?? []);
+        return this.skills.size;
+    }
+    /** Providers declared by the catalog, for `/models` and login hints. */
+    listCatalogProviders() {
+        return this.providers.listCatalogProviders();
+    }
+    listModels(configuredOnly = false) {
+        return this.providers.listModels({ configuredOnly });
+    }
+    listSessions(limit) {
+        return this.store.list(limit);
+    }
+    /** Start a fresh session. */
+    createSession(overrides = {}) {
+        return this.equip(new Session({
+            cwd: this.cwd,
+            model: overrides.model ?? this.config.model ?? this.defaultModel(),
+            providers: this.providers,
+            permissionMode: this.config.permissionMode,
+            permissionRules: this.config.permissions,
+            store: this.options.ephemeral ? false : this.store,
+            title: overrides.title,
+        }));
+    }
+    /**
+     * Give a session the machinery that outlives it: where remembered approvals
+     * are written, and where decisions are recorded.
+     */
+    auditQueue = Promise.resolve();
+    /**
+     * The file the queue has already made a directory for.
+     *
+     * A path rather than a flag, because recording can be switched on and off
+     * while sessions are open: a boolean would remember that *some* directory
+     * exists and let the first write to a new one ENOENT into a log line.
+     */
+    auditReadyFor;
+    equip(session) {
+        session.permissions.attachSettings(this.settings);
+        // Attached whatever the setting says, and the setting read when a decision
+        // actually happens. Deciding here instead would make the switch on the
+        // settings page a lie for every session already open — one started with
+        // recording off could never begin, and one started with it on could never
+        // stop.
+        session.permissions.onDecision((entry) => {
+            if (this.config.audit === false)
+                return;
+            this.record(session.id, entry);
+        });
+        return session;
+    }
+    /**
+     * Write one trail entry: to the session's own log, and to the configured
+     * file when there is one.
+     *
+     * Fire-and-forget so recording never delays or fails a tool call, but
+     * chained: concurrent appends of separate lines can interleave and a
+     * half-written record is worse than none. The chain also carries the
+     * one-time mkdir for the file sink — without it every write ENOENTs into a
+     * log line and the trail is silently empty.
+     *
+     * This is the one place this harness parts company with a stricter reading
+     * of the same idea, where a decision that cannot be recorded is a decision
+     * that does not happen. That trade buys an audit you can rely on at the cost
+     * of a tool call that fails because a disk did; here the tool call wins, and
+     * a failed write is a warning in the log rather than a refusal. Anything
+     * that needs the stronger guarantee needs this to be awaited on the call
+     * path, not just louder.
+     */
+    record(sessionId, entry) {
+        const configured = this.config.auditLog;
+        this.auditQueue = this.auditQueue
+            .then(async () => {
+            // An ephemeral harness has no store to write to, and inventing one
+            // for the trail would give a session that deliberately leaves nothing
+            // behind a file that outlives it.
+            if (!this.ephemeral)
+                await this.store.appendDecision(sessionId, entry);
+            if (!configured)
+                return;
+            const file = path.resolve(this.cwd, configured);
+            if (this.auditReadyFor !== file) {
+                await mkdir(path.dirname(file), { recursive: true });
+                this.auditReadyFor = file;
+            }
+            await appendFile(file, `${JSON.stringify({ ...entry, session: sessionId })}\n`, "utf8");
+        })
+            .catch((err) => this.logger.warn("audit write failed", { error: String(err) }));
+    }
+    /**
+     * Branch a session. Omit `keepMessages` to branch from where it stands, or
+     * pass a count to rewind the branch to an earlier point.
+     */
+    async forkSession(id, opts = {}) {
+        const forked = await Session.fork(id, {
+            model: opts.model ?? this.config.model ?? this.defaultModel(),
+            providers: this.providers,
+            permissionMode: this.config.permissionMode,
+            permissionRules: this.config.permissions,
+            store: this.store,
+            ...(opts.keepMessages !== undefined ? { keepMessages: opts.keepMessages } : {}),
+            ...(opts.title !== undefined ? { title: opts.title } : {}),
+        });
+        return forked ? this.equip(forked) : undefined;
+    }
+    deleteSession(id) {
+        return this.store.delete(id);
+    }
+    /**
+     * Delete every session recorded in one tree.
+     *
+     * The directory itself is never touched — this throws away what the harness
+     * wrote about the work, not the work. Returns the ids, because whoever asked
+     * is probably holding some of them open.
+     */
+    deleteSessionsIn(cwd) {
+        return this.store.deleteIn(cwd);
+    }
+    renameSession(id, title) {
+        return this.store.rename(id, title);
+    }
+    /** Reload a persisted session by id; returns undefined if it is unknown. */
+    async resumeSession(id, model) {
+        const resumed = await Session.resume(id, {
+            model: model ?? this.config.model ?? this.defaultModel(),
+            providers: this.providers,
+            permissionMode: this.config.permissionMode,
+            permissionRules: this.config.permissions,
+            store: this.store,
+        });
+        return resumed ? this.equip(resumed) : undefined;
+    }
+    /** Build an agent bound to a session, wired with everything the harness owns. */
+    agent(session, overrides = {}) {
+        return new Agent({
+            session,
+            tools: this.tools,
+            hooks: this.hooks,
+            subagents: this.subagents,
+            skills: this.skills,
+            memory: this.memory,
+            onSkillsChanged: () => this.reloadSkills(),
+            mcp: this.mcp,
+            permissionPrompt: this.options.permissionPrompt,
+            workspace: this.workspace,
+            systemPrompt: this.config.systemPrompt,
+            smallModel: this.config.smallModel,
+            appendSystemPrompt: this.config.appendSystemPrompt,
+            projectInstructions: this.projectInstructions,
+            toolFilter: this.config.tools,
+            thinking: this.config.thinking,
+            maxTurns: this.config.maxTurns,
+            cache: this.config.cache,
+            logger: this.logger,
+            ...overrides,
+        });
+    }
+    /**
+     * One-shot convenience: run a prompt in a new session and stream events.
+     * For multi-turn use, keep a `Session` and reuse the agent.
+     */
+    async *run(prompt, opts = {}) {
+        const session = this.createSession({ model: opts.model });
+        const agent = this.agent(session);
+        yield* agent.run(prompt, { signal: opts.signal });
+    }
+    async close() {
+        // Stopped before MCP, because it is the only thing here holding a socket
+        // open on purpose — a long poll would otherwise keep the process alive for
+        // up to thirty seconds after everything else had shut down.
+        this.mirror?.stop();
+        await this.mcp.closeAll();
+    }
+    /**
+     * First model whose provider has credentials. Only the cheap synchronous
+     * check runs here — a subscription-only provider is picked up once the
+     * caller has awaited `configuredProviders()`.
+     */
+    defaultModel() {
+        const configured = this.providers.listModels({ configuredOnly: true });
+        const first = configured[0] ?? this.providers.listModels()[0];
+        if (!first)
+            throw new Error("no models are registered");
+        return first.id;
+    }
+}
+//# sourceMappingURL=harness.js.map