@oharness/engine 0.9.3 → 0.11.0

package/dist/harness.js

@@ -6,6 +6,7 @@ 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 { claudeAgent } from "./acp/claude.js";
 import { SkillRegistry } from "./agent/skills.js";
 import { SettingsStore } from "./agent/settings.js";
 import { createPolicy } from "./agent/workspace.js";
@@ -60,10 +61,40 @@ export class Harness {
     extensions = new PluginExtensions();
     /** Undefined when browser tools are turned off. Lazy: holds no process until used. */
     browser;
+    /**
+     * Who hosts a session started in a new worktree. Set by the frontend that
+     * holds sessions (the web server); while unset, `worktree_start` is not
+     * offered to the model.
+     */
+    worktreeLauncher;
+    /**
+     * Starts a turn in a conversation that is idle, to read in background task
+     * results that ended after its last run. Set by a frontend that keeps
+     * conversations alive between turns; while unset, background tasks are not
+     * offered and `task` runs everything in the foreground.
+     */
+    taskWaker;
+    /**
+     * Where pictures of the browser tabs a turn left go, and whether to take
+     * them at all. Set by a frontend that shows them; while unset, none are.
+     * `at` is the conversation's message count when the turn ended.
+     */
+    turnShotSink;
     /** Browser state belongs to a conversation, not to its project harness. */
     sessionBrowsers = new Map();
+    /** Computer Use state belongs to a conversation too. */
+    sessionComputers = new Map();
     /** Each live conversation's title, read when its browser needs a name. */
     sessionTitles = new Map();
+    /** Each live conversation's model, read when it creates a routine. */
+    sessionModels = new Map();
+    /**
+     * The model a routine runs on when it names none of its own, or names one
+     * that is gone. Set by whoever knows what the user picked — the app's
+     * composer — because the first-configured model is a guess: a local server
+     * that is not running, or a gated one the account never unlocked.
+     */
+    routineModel;
     memoryService;
     /** User-level notes, shared by every project. Absent when the user directory is not writable. */
     memoryUserService;
@@ -183,6 +214,8 @@ export class Harness {
             list: () => this.scheduler.status(),
             add: (input) => this.addSchedule(input),
             remove: (name) => this.removeSchedule(name),
+            sessionModel: (sessionId) => this.sessionModels.get(sessionId)?.(),
+            appStatus: (app, signal) => this.appStatus(app, signal),
         }));
         this.ephemeral = opts.ephemeral === true;
         this.runtimeAudit = new RuntimeAuditBus(this.logger);
@@ -237,6 +270,11 @@ export class Harness {
                     .catch((err) => harness.logger.warn("session pruning failed", { error: String(err) }));
             }
             await harness.skills.discover(cwd, config.skillDirs ?? []);
+            // Claude Agent, when the user turned it on and this machine has their
+            // own Claude Code to hand work to. Before the markdown ones, so a
+            // project can redefine it.
+            if (config.claudeAgent === true)
+                await harness.registerClaudeAgent();
             // 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 ?? [])) {
@@ -283,19 +321,7 @@ export class Harness {
                     }
                 }, token: () => harness.accountToken(), syncUrl: () => resolveSyncUrl(harness.config.sync),
                 // Merge proposals use the small model, like extraction and titles.
-                generate: async (system, prompt, signal) => {
-                    const model = harness.providers.resolve(harness.config.smallModel ?? harness.config.model ?? harness.defaultModel());
-                    const provider = harness.providers.getProvider(model.provider);
-                    const parts = [];
-                    for await (const event of provider.stream({
-                        model, system, messages: [userMessage(prompt)],
-                        maxOutputTokens: Math.min(8_000, model.maxOutputTokens), thinking: { enabled: false, effort: "low" },
-                        ...(signal ? { signal } : {}),
-                    }))
-                        if (event.type === "text_delta")
-                            parts.push(event.text);
-                    return parts.join("");
-                },
+                generate: (system, prompt, signal) => harness.generateText(system, prompt, signal),
             }, (service, user) => { harness.memoryService = service; harness.memoryUserService = user; });
             /**
              * Media generation, billed to the OHarness account and nothing else.
@@ -408,6 +434,50 @@ export class Harness {
      * started with the browser off has no tools to switch, so that one stays as
      * it is until a restart.
      */
+    /** The Claude Agent definition this harness registered, while it is on. */
+    claudeRegistered;
+    /**
+     * Whether Claude Agent is switched on, and whether it could be.
+     *
+     * `available` is whether this machine has the user's `claude` (and `npx`
+     * for the adapter); `unavailable` is the reason it would not run even so,
+     * such as an old Node. Detected afresh each time, since installing Claude
+     * Code is something done in another window while this page is open.
+     */
+    async claudeAgentStatus() {
+        const found = await claudeAgent().catch(() => undefined);
+        return {
+            on: this.config.claudeAgent === true,
+            available: Boolean(found),
+            ...(found?.runtime?.unavailable ? { unavailable: found.runtime.unavailable } : {}),
+        };
+    }
+    /**
+     * Turn Claude Agent on or off, now and for later launches.
+     *
+     * Written to the user's own config, the same place `claudeAgent` is read
+     * from at startup, so the terminal frontends and the page agree. Takes
+     * effect at once: open conversations share this harness's subagent list.
+     */
+    async setClaudeAgent(on) {
+        await updateUserConfig((current) => ({ ...current, claudeAgent: on }));
+        this.config.claudeAgent = on;
+        if (on)
+            await this.registerClaudeAgent();
+        else if (this.claudeRegistered) {
+            this.subagents.unregister(this.claudeRegistered);
+            this.claudeRegistered = undefined;
+        }
+    }
+    async registerClaudeAgent() {
+        if (this.claudeRegistered || process.env["OHARNESS_NO_CLAUDE_AGENT"] === "1")
+            return;
+        const claude = await claudeAgent().catch(() => undefined);
+        if (!claude)
+            return;
+        this.subagents.register(claude);
+        this.claudeRegistered = claude;
+    }
     async setBrowserMode(mode) {
         await updateUserConfig((current) => ({ ...current, browser: { ...current.browser, mode } }));
         this.config.browser = { ...this.config.browser, mode };
@@ -543,11 +613,41 @@ export class Harness {
         const where = await stat(cwd).catch(() => undefined);
         if (!where?.isDirectory())
             throw new ConfigError(`"${cwd}" is not a directory`);
-        const def = { name, cron, prompt, cwd, createdAt: Date.now() };
+        const apps = [...new Set((input.apps ?? []).map((app) => app.trim().toLowerCase()).filter(Boolean))];
+        const def = {
+            name, cron, prompt, cwd, createdAt: Date.now(),
+            ...(input.model ? { model: input.model } : {}),
+            ...(apps.length ? { apps } : {}),
+        };
         await updateUserConfig((current) => ({ ...current, schedules: [...(current.schedules ?? []), def] }));
         this.scheduler.add(def);
         return def;
     }
+    /**
+     * The model a routine should run on: its own if that still resolves, else
+     * the one `routineModel` names, else nothing — and the session default.
+     */
+    routineModelFor(own) {
+        for (const ref of [own, this.routineModel?.()]) {
+            if (!ref)
+                continue;
+            try {
+                return this.providers.resolve(ref).id;
+            }
+            catch {
+                this.logger.warn("routine model is not available; trying the next", { ref });
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Whether a Cloud app is connected for this account, asked without opening
+     * a card. `label` is the app's display name when the Cloud gave one.
+     */
+    async appStatus(app, signal) {
+        const data = await this.cloudConnectors.call("catalog", { app }, signal);
+        return { connected: data.connected !== false, label: typeof data.label === "string" ? data.label : app };
+    }
     /**
      * Bring the scheduler in line with the config files as they are now.
      *
@@ -727,9 +827,9 @@ export class Harness {
      * 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", {
+        const { changed: discovered, cleared } = await this.providers.refreshListings(providerId);
+        if (discovered.length > 0 || cleared.length > 0) {
+            await this.saveDiscovered(discovered, cleared).catch((err) => this.logger.warn("could not persist the discovered catalog", {
                 error: String(err),
             }));
         }
@@ -744,12 +844,22 @@ export class Harness {
      * happen to — and answers 404 when picked. Nothing to refresh from (no
      * listing ever made) counts as stale. Resolves to undefined when the list
      * was fresh enough to leave alone.
+     *
+     * The age is the oldest provider's, from `discovered`, not `discoveredAt`:
+     * that one moves whenever any single provider is listed — a sign-in, a
+     * key saved for one vendor — and read alone it kept every other provider's
+     * week-old list looking fresh. `discoveredAt` is the fallback for a file
+     * written before `discovered` existed.
      */
     async refreshStaleModels(maxAgeMs = MODEL_LIST_MAX_AGE_MS) {
         let at = NaN;
         try {
             const raw = JSON.parse(await readFile(userCatalogPath(), "utf8"));
-            at = Date.parse(String(raw["discoveredAt"] ?? ""));
+            const each = raw["discovered"];
+            const times = each && typeof each === "object" && !Array.isArray(each)
+                ? Object.values(each).map((value) => Date.parse(String(value))).filter(Number.isFinite)
+                : [];
+            at = times.length > 0 ? Math.min(...times) : Date.parse(String(raw["discoveredAt"] ?? ""));
         }
         catch {
             // No file or an unreadable one: never listed, so due.
@@ -784,8 +894,9 @@ export class Harness {
      * it: merging only ever grew the file, so a model the vendor withdrew stayed
      * in the picker for good. `discovered` records which providers have a live
      * listing, so the pi-ai snapshot stops filling in models for them.
+     * `cleared` names local servers that listed nothing, whose entries go.
      */
-    async saveDiscovered(models) {
+    async saveDiscovered(models, cleared = []) {
         const file = userCatalogPath();
         let existing = {};
         try {
@@ -797,7 +908,7 @@ export class Harness {
         const byId = new Map((Array.isArray(existing["models"]) ? existing["models"] : [])
             .filter((m) => !!m && typeof m === "object")
             .map((m) => [String(m["id"]), m]));
-        const listed = new Set(models.map((model) => model.provider));
+        const listed = new Set([...models.map((model) => model.provider), ...cleared]);
         const fresh = new Set(models.map((model) => model.id));
         for (const [id, model] of byId) {
             const { provider, model: wire } = model;
@@ -872,6 +983,7 @@ export class Harness {
     auditReadyFor;
     equip(session) {
         this.sessionTitles.set(session.id, () => session.title);
+        this.sessionModels.set(session.id, () => session.model.id);
         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
@@ -930,7 +1042,8 @@ export class Harness {
      */
     async forkSession(id, opts = {}) {
         const forked = await Session.fork(id, {
-            model: opts.model ?? this.config.model ?? this.defaultModel(),
+            model: opts.model ?? "",
+            fallbackModel: this.config.model ?? this.defaultModel(),
             providers: this.providers,
             permissionMode: this.config.permissionMode,
             permissionRules: this.config.permissions,
@@ -959,7 +1072,10 @@ export class Harness {
     /** 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(),
+            // Empty means "the session's own": a conversation reopens on the model
+            // it was using, and the default is only for one whose model is gone.
+            model: model ?? "",
+            fallbackModel: this.config.model ?? this.defaultModel(),
             providers: this.providers,
             permissionMode: this.config.permissionMode,
             permissionRules: this.config.permissions,
@@ -972,9 +1088,15 @@ export class Harness {
         if (this.lifecycle.signal.aborted)
             throw new ConfigError("Harness is closed");
         const browser = this.browserFor(session.id);
-        const tools = browser && browser !== this.browser
+        let tools = browser && browser !== this.browser
             ? this.tools.clone().registerAll(this.browserUse.tools(browser))
             : this.tools;
+        // Registered for every conversation and shown only to those that switched
+        // it on; see Agent.visibleTools.
+        const computer = this.computerFor(session.id);
+        if (computer && this.computerUse) {
+            tools = (tools === this.tools ? tools.clone() : tools).registerAll(this.computerUse.tools(computer));
+        }
         return new Agent({
             session,
             tools,
@@ -998,17 +1120,96 @@ export class Harness {
             cache: this.config.cache,
             logger: this.logger,
             lifecycleSignal: this.lifecycle.signal,
-            onRunStart: () => {
-                let finish;
-                const done = new Promise((resolve) => { finish = resolve; });
-                this.activeRuns.add(done);
-                return () => { this.activeRuns.delete(done); finish(); };
-            },
+            worktreeLauncher: () => this.worktreeLauncher,
+            taskWaker: () => this.taskWaker,
+            equipSubagent: (sessionId, label, tools) => this.equipSubagent(sessionId, label, tools),
+            onRunStart: () => this.trackRun(computer, browser, session),
             onAudit: (event) => { if (this.config.audit !== false)
                 this.runtimeAudit.publish(event); },
             ...overrides,
         });
     }
+    /**
+     * Count a run toward shutdown's drain. Its end lets go of the windows and
+     * control its conversation held, so another need not wait out the lease.
+     */
+    trackRun(computer, browser, session) {
+        let finish;
+        const done = new Promise((resolve) => { finish = resolve; });
+        this.activeRuns.add(done);
+        return () => {
+            this.activeRuns.delete(done);
+            computer?.endTurn();
+            // A subagent's tabs are not pictured: it has no transcript of its own.
+            if (session)
+                this.pictureBrowserTurn(browser, session);
+            finish();
+        };
+    }
+    /**
+     * The tabs a turn left, beside the conversation (see BrowserUseSession.endTurn).
+     * Where the turn ended is read now, before a queued message starts the next.
+     */
+    pictureBrowserTurn(browser, session) {
+        if (!browser?.endTurn)
+            return;
+        const sink = this.turnShotSink;
+        const at = session.messages.length;
+        void browser
+            .endTurn(Boolean(sink?.enabled()))
+            .then((shots) => { if (shots.length)
+            sink?.save(session.id, at, shots); })
+            .catch(() => { });
+    }
+    /**
+     * A subagent's own browser and computer.
+     *
+     * Without them it would drive its parent's tabs and act under its parent's
+     * window leases, where the arbiter cannot tell the two apart — and several
+     * subagents at once would take each other's pages away. Only the tools the
+     * subagent was already given are rebound; a filter that left the browser
+     * out leaves it out. Both are closed again when the subagent ends.
+     */
+    equipSubagent(sessionId, label, tools) {
+        const browser = this.browser
+            ? this.browserUse.createSession({
+                sessionId,
+                mode: this.browserMode(),
+                logger: this.logger,
+                label: () => label,
+                cwd: this.cwd,
+            })
+            : undefined;
+        if (browser)
+            for (const tool of this.browserUse.tools(browser))
+                if (tools.has(tool.name))
+                    tools.register(tool);
+        const computer = this.options.computerUsePlugin?.createSession({ sessionId, label: () => label });
+        if (computer && this.computerUse) {
+            for (const tool of this.computerUse.tools(computer))
+                if (tools.has(tool.name))
+                    tools.register(tool);
+        }
+        return {
+            onRunStart: () => this.trackRun(computer),
+            // A later run's registry gets the same browser and computer again.
+            bind: (next) => {
+                if (browser)
+                    for (const tool of this.browserUse.tools(browser))
+                        if (next.has(tool.name))
+                            next.register(tool);
+                if (computer && this.computerUse) {
+                    for (const tool of this.computerUse.tools(computer))
+                        if (next.has(tool.name))
+                            next.register(tool);
+                }
+            },
+            release: async () => {
+                await computer?.close();
+                await browser?.close();
+            },
+        };
+    }
     /**
      * The lazy browser owned by one session.
      *
@@ -1040,11 +1241,35 @@ export class Harness {
         this.sessionBrowsers.set(sessionId, browser);
         return browser;
     }
+    /** Whether this harness can offer Computer Use at all. */
+    get computerUse() {
+        return this.options.computerUsePlugin;
+    }
+    /** One conversation's view of the computer; undefined without the feature. */
+    computerFor(sessionId) {
+        const plugin = this.options.computerUsePlugin;
+        if (!plugin)
+            return undefined;
+        let found = this.sessionComputers.get(sessionId);
+        if (!found) {
+            found = plugin.createSession({ sessionId, label: () => this.sessionTitles.get(sessionId)?.() });
+            this.sessionComputers.set(sessionId, found);
+        }
+        return found;
+    }
+    /** Release a closed conversation's leases and its place in the control queue. */
+    async closeComputerFor(sessionId) {
+        const computer = this.sessionComputers.get(sessionId);
+        this.sessionComputers.delete(sessionId);
+        await computer?.close();
+    }
     /** Release the process and transient page state when a session tab closes. */
     async closeBrowserFor(sessionId) {
+        await this.closeComputerFor(sessionId);
         const browser = this.sessionBrowsers.get(sessionId);
         this.sessionBrowsers.delete(sessionId);
         this.sessionTitles.delete(sessionId);
+        this.sessionModels.delete(sessionId);
         await browser?.close();
     }
     /**
@@ -1053,7 +1278,8 @@ export class Harness {
      */
     async *run(prompt, opts = {}) {
         const session = this.createSession({ model: opts.model });
-        const agent = this.agent(session);
+        // One prompt and done: nothing would be left to read a late result into.
+        const agent = this.agent(session, { taskWaker: () => undefined });
         yield* agent.run(prompt, { signal: opts.signal });
     }
     close() {
@@ -1086,11 +1312,42 @@ export class Harness {
         await this.mcp.closeAll();
         // Last, and never awaited for long: a browser that will not close should
         // not be what keeps the process alive.
+        for (const computer of this.sessionComputers.values())
+            await computer.close();
+        this.sessionComputers.clear();
         const browsers = new Set(this.sessionBrowsers.values());
         if (this.browser)
             browsers.add(this.browser);
         await Promise.all([...browsers].map((browser) => browser.close()));
     }
+    /**
+     * One reply from the small model, as text: no tools, no thinking, no
+     * session. For the chores around the work — merge proposals, suggestions —
+     * where the configured default model would be paying for depth nobody reads.
+     * `fallback` is a model the caller knows the user can reach, such as the one
+     * picked in the composer; it wins over the first-configured guess.
+     */
+    async generateText(system, prompt, signal, maxOutputTokens = 8_000, fallback) {
+        return this.generateWith(this.config.smallModel ?? fallback ?? this.config.model ?? this.defaultModel(), system, prompt, signal, maxOutputTokens);
+    }
+    /**
+     * The same one reply, from a model the caller names rather than the small
+     * one: for a chore that should cost and sound like the conversation it is
+     * about, such as the composer's next-message suggestion.
+     */
+    async generateWith(ref, system, prompt, signal, maxOutputTokens = 8_000) {
+        const model = this.providers.resolve(ref);
+        const provider = this.providers.getProvider(model.provider);
+        const parts = [];
+        for await (const event of provider.stream({
+            model, system, messages: [userMessage(prompt)],
+            maxOutputTokens: Math.min(maxOutputTokens, model.maxOutputTokens), thinking: { enabled: false, effort: "low" },
+            ...(signal ? { signal } : {}),
+        }))
+            if (event.type === "text_delta")
+                parts.push(event.text);
+        return parts.join("");
+    }
     /**
      * First model whose provider has credentials. Only the cheap synchronous
      * check runs here — a subscription-only provider is picked up once the