@ours.network/fleet 0.1.0

package/LICENSE

@@ -0,0 +1,98 @@
+# Functional Source License, Version 1.1, Apache 2.0 Future License
+
+## Abbreviation
+
+FSL-1.1-Apache-2.0
+
+## Notice
+
+Copyright 2026 ours.network contributors
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to use,
+copy, modify, create derivative works, publicly perform, publicly display and
+redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or service
+that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software that
+   exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee using
+   the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to the
+infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software, you
+must include a copy of or a link to these Terms and Conditions and not remove any
+copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, INCLUDING
+WITHOUT LIMITATION WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
+PURPOSE, NON-INFRINGEMENT, OR THAT THE SOFTWARE IS FREE OF DEFECTS. IN NO EVENT
+WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE SOFTWARE,
+INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES, EVEN IF WE HAVE
+BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following will
+apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

package/README.md

@@ -0,0 +1,196 @@
+# ours-fleet
+
+**Run a fleet of persistent, identity-bound AI agents — across different agent
+harnesses — from one declarative file.**
+
+## What is this?
+
+An AI coding agent in a terminal dies when you close the laptop. `ours-fleet`
+turns such sessions into **roles**: long-lived agents that
+
+- **live in a detached tmux console** you can attach to, peek at, or type into at
+  any time,
+- are **supervised** — systemd (Linux) or launchd (macOS) restarts them on crash
+  and brings them back after a reboot,
+- **resume their context** across restarts (when the harness supports it),
+- **bind an ours.network identity**, so you — and every other agent — can message
+  them by name over an end-to-end-encrypted channel
+  ([ours.network](https://ours.network)),
+- can **spawn subagents** (permanent or temporary) and **oversee** them: peek into
+  a ward's console, answer a stuck prompt, nudge it back to work.
+
+The whole fleet is described in one hand-written `~/fleet.yaml`
+("docker-compose for agents"): who exists, what harness they run in, their mission,
+persona, bio, working directory, and who oversees whom. `ours-fleet up` makes
+reality match the file.
+
+**Harness-agnostic by design.** The core never assumes a specific agent CLI; each
+harness is a small adapter (how to launch, how to resume, how to wire config).
+Today: **Claude Code**. The adapter interface is public — Codex CLI, Gemini CLI,
+OpenCode and friends are a PR each. A single fleet can mix harnesses per role:
+
+```yaml
+roles:
+  Reviewer:                 # runs in Claude Code
+    harness: claude-code
+  Prototyper:               # (future) runs elsewhere
+    harness: codex
+```
+
+## How it works
+
+```
+~/fleet.yaml + ~/fleet.d/*.yaml           your declaration
+        │  ours-fleet up
+        ▼
+ briefing.md per role  ──►  tmux session  ──►  harness CLI (claude …)
+        ▲                        │
+ systemd --user / launchd ───────┘   restart on crash, start at boot/login
+```
+
+Each role gets a state dir (`~/.ours-fleet/agents/<Name>/`) holding its briefing,
+WORKLOG, and session markers. On boot the agent reads its briefing: bind identity,
+publish bio/persona, arm a mail monitor (`ours-mcp watch`), announce to its
+coordinator, work. On crash the supervisor relaunches it and the harness resumes
+the same session.
+
+## Prerequisites
+
+| What | Why | Install |
+|---|---|---|
+| Node ≥ 20 | runs `ours-fleet` itself | nodejs.org, `apt`, or `brew` |
+| tmux | every role's console | `apt install tmux` / `brew install tmux` |
+| a harness CLI, logged in | the agent itself | e.g. Claude Code (`claude`) |
+| `ours-mcp` daemon | identity + agent-to-agent messaging | `npm i -g @ours.network/mcp && ours-mcp start` |
+
+Linux only: `ours-fleet init` enables *linger* so roles run without a login session
+and survive reboots. macOS: launchd agents start **at login** (no linger
+equivalent); logs land in `~/.ours-fleet/logs/`.
+
+## Install
+
+```sh
+npm i -g @ours.network/fleet
+ours-fleet init      # units/dirs/linger for this user
+ours-fleet doctor    # verifies everything above, with actionable messages
+```
+
+Each OS user manages their own fleet — to host roles under a sandboxed account,
+become that account and repeat.
+
+## Quickstart
+
+```sh
+cp "$(npm root -g)/@ours.network/fleet/examples/fleet.yaml" ~/fleet.yaml
+$EDITOR ~/fleet.yaml          # name your roles, missions, personas
+ours-fleet up                 # boot the fleet (staggered)
+ours-fleet ls                 # running consoles
+ours-fleet attach Alice       # watch one live (Ctrl-b d to leave)
+ours-fleet peek Alice         # or just glance
+```
+
+## Spawning agents
+
+From the shell:
+
+```sh
+ours-fleet spawn Worker --mission "own the worker repo" \
+  --bio-file bio.md --persona-file persona.md --coordinator FleetCoordinator
+ours-fleet spawn --temp Scout --mission "one-off research"   # gone on exit/reboot
+```
+
+Permanent spawns are written to `~/fleet.d/<Name>.yaml` — your hand-written
+`~/fleet.yaml` is **never** machine-edited. `ours-fleet rm <Name>` unspawns.
+
+From inside Claude Code: install the `ours-fleet` plugin (ships in this repo under
+`integrations/claude-code`) and say **"spawn ours agent …"** — the agent asks
+temp-vs-permanent, co-drafts the bio and persona with you, spawns, and arms
+oversight.
+
+## Oversight ("keep an eye")
+
+Spawned agents are subagents; their spawner (or any assigned overseer) checks on
+them and unsticks them:
+
+```sh
+ours-fleet peek Worker          # what is it doing?
+ours-fleet send Worker --key 1  # answer the menu it's stuck on
+ours-fleet send Worker "continue with the tests, then report"
+```
+
+Declare standing assignments in `fleet.yaml` (rendered into the overseer's
+briefing) — or just write "keep an eye on Alice and Bob every 5 minutes" in a
+persona; the bundled `oversee-agents` skill defines what that means operationally:
+
+```yaml
+roles:
+  FleetCoordinator:
+    oversee:
+      - { role: Alice, interval: 5m }
+      - { role: Bob,   interval: 5m }
+```
+
+## Command reference
+
+```
+ours-fleet up|down|restart|force-restart [-c FILE] [Name...]
+ours-fleet config [-c FILE]         validate + print merged plan
+ours-fleet ls | attach | peek | logs [-f] | status <Name>
+ours-fleet send <Name> "text" | --key <K>
+ours-fleet spawn [--temp] <Name> [--mission --bio-file --persona-file ...]
+ours-fleet rm <Name>
+ours-fleet doctor [--harness H]
+ours-fleet init
+```
+
+## fleet.yaml reference
+
+```yaml
+vars: { work_root: /home/me/work }      # ${var} substitution anywhere below
+defaults:
+  harness: claude-code                  # for roles that don't set one
+  max_tokens: 500000                    # session cap (harness-interpreted)
+roles:
+  Name:                                 # [A-Za-z0-9_-]+
+    harness: claude-code
+    identity: "Display Name"            # ours identity to bind (default: Name)
+    cwd: ${work_root}/repo              # where the harness process runs
+    coordinator: FleetCoordinator       # announce target on boot
+    mission: one line
+    persona: |                          # operating contract (published as persona)
+    bio: |                              # public card (published as bio)
+    briefing_file: curated.md           # replaces the generated narrative
+    env: { KEY: value }                 # extra session env
+    oversee: [{ role: X, interval: 5m }]
+    harness_options:                    # adapter-owned, adapter-validated
+      plugins: { "name@marketplace": false }   # claude-code: plugin overrides
+      # mem_palace: false                      # claude-code: disable memory plugin
+```
+
+Merge order: `fleet.yaml` ← `fleet.d/*.yaml`; a duplicate role name is a hard
+error naming both files. Identities and roles are decoupled — removing a role
+never deletes an identity.
+
+## Development
+
+```sh
+npm install && npm test      # vitest; no systemd/tmux needed for the suite
+npm run build
+```
+
+Adding a harness = implementing `HarnessAdapter`
+(`src/harness/types.ts`) and registering it — see `src/harness/claude-code.ts`
+for the reference implementation.
+
+## Support ours.network
+
+ours-fleet is part of [ours.network](https://ours.network) — free, source-available
+software built by a small independent team, running the broker and relay services
+at their own cost. If this is useful to you, please consider chipping in:
+**→ https://ours.network/donate**
+
+## License
+
+[FSL-1.1-Apache-2.0](LICENSE) — Functional Source License, converting to
+Apache-2.0 two years after each release. Free for any use except offering a
+competing product or service. Copyright 2026 ours.network contributors.

package/dist/briefing.d.ts

@@ -0,0 +1,10 @@
+import type { ResolvedRole } from './config.js';
+import type { BriefingVocab } from './harness/types.js';
+export interface BriefingOpts {
+    stateDir: string;
+    worklogPath: string;
+    /** Curated body (from briefing_file) replacing the narrative sections. */
+    briefingBody?: string;
+}
+/** Render a role's briefing.md: narrative (or curated body) + mechanical boot steps. */
+export declare function generateBriefing(role: ResolvedRole, v: BriefingVocab, opts: BriefingOpts): string;

package/dist/briefing.js

@@ -0,0 +1,73 @@
+import { userInfo } from 'node:os';
+/** Render a role's briefing.md: narrative (or curated body) + mechanical boot steps. */
+export function generateBriefing(role, v, opts) {
+    const L = [];
+    const id = role.identity;
+    const hostUser = userInfo().username;
+    L.push(`# ${role.name} — Role Briefing`, '');
+    L.push(`You are **${role.name}** (ours identity: **${id}**), a persistent agent on this`);
+    L.push(`host, running as the \`${hostUser}\` user.`);
+    if (opts.briefingBody) {
+        L.push('', opts.briefingBody.trim());
+    }
+    else {
+        if (role.cwd)
+            L.push('', `Your working directory is \`${role.cwd}\`. Operate on the code there.`);
+        if (role.persona)
+            L.push('', '## Charter (persona — your local operating contract)', role.persona.trim());
+        if (role.bio)
+            L.push('', '## Bio (public card — what peers and a coordinator see)', role.bio.trim());
+        if (role.mission)
+            L.push('', '## Mission', role.mission.trim());
+    }
+    L.push('', '## Do these NOW, in order');
+    L.push(`1. ${v.launchNote(role.name)}`);
+    L.push(`2. BIND your predefined ours identity: call the **${v.bindTool}** tool with`);
+    L.push(`   name "${id}" force=true (search the deferred tool registry first if needed).`);
+    L.push(`   - If no such identity exists yet, call **${v.createTool}** name "${id}" once`);
+    L.push('     to mint it, then you are bound. Re-binding your OWN identity is always allowed.');
+    L.push(`3. RECONCILE your profile (idempotent): call **${v.currentIdentityTool}** and read your`);
+    L.push('   current bio and persona, so you only write below when they actually differ.');
+    L.push(`4. PUBLISH your public **bio** via **${v.setBioTool}**`);
+    L.push(role.bio
+        ? '   with the **Bio** section above, verbatim. Skip the call if it already matches.'
+        : '   with a 1–2 sentence summary of your Charter above. Skip if it already matches.');
+    L.push(`5. SET your **persona** (local operating contract, never shared in invites) via`);
+    L.push(`   **${v.setPersonaTool}** with the **Charter** section above, verbatim. Skip if it matches.`);
+    L.push(`6. ${v.monitorInstruction(id)}`);
+    if (role.coordinator) {
+        L.push(`7. ANNOUNCE yourself: call **${v.sendTool}** to contact "${role.coordinator}" with text:`);
+        L.push(`   "${role.name} online — identity '${id}' bound, monitor armed, ready."`);
+        L.push(`8. Await messages. When the monitor wakes you, call **${v.getMessagesTool}**, act, reply.`);
+    }
+    else {
+        L.push(`7. Await messages. When the monitor wakes you, call **${v.getMessagesTool}**, act on them,`);
+        L.push(`   and reply with ${v.sendTool}. No coordinator is configured — the owner drives you`);
+        L.push(`   via \`tmux attach -t ${role.name}\` or by messaging "${id}".`);
+    }
+    if (role.oversee?.length) {
+        L.push('', '## Oversight assignments');
+        L.push('These agents are your wards — you keep them unstuck:');
+        for (const o of role.oversee)
+            L.push(`- **${o.role}** — check every ${o.interval}`);
+        L.push('');
+        L.push('Procedure (see also the oversee-agents skill if available): on each tick, run');
+        for (const o of role.oversee)
+            L.push(`\`ours-fleet peek ${o.role}\``);
+        L.push('and judge the console: stuck on a prompt/menu/trust dialog → answer it directly with');
+        L.push('`ours-fleet send <Name> "<text>"` (or `--key <K>` for raw keys); crashed to a shell →');
+        L.push('investigate and restart; idle with work assigned → nudge; healthy → do nothing.');
+        L.push('Escalate over ours messaging only when you cannot resolve it yourself.');
+    }
+    L.push('', '## Durable log');
+    L.push(`Append important commands / decisions / results to \`${opts.worklogPath}\` as you go —`);
+    L.push('it survives restarts.');
+    L.push('', '## On restart (you run under a supervised launcher)');
+    L.push(`On restart, WITHOUT asking: re-bind (**${v.bindTool}** name "${id}" force=true),`);
+    L.push(`re-arm the \`${v.watchCommand(id)}\` monitor, then continue from your WORKLOG.`);
+    L.push('Do not blindly re-run whatever may have crashed you.');
+    L.push('', '## House rules');
+    L.push('- Never broad `rm -rf` on home/critical paths; quote globs; use explicit paths.');
+    L.push('- When you stop, be in a declared state (DONE / BLOCKED / resting ≤2h).');
+    return L.join('\n') + '\n';
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import './harness/claude-code.js';

package/dist/cli.js

@@ -0,0 +1,209 @@
+#!/usr/bin/env node
+import { spawn as spawnChild } from 'node:child_process';
+import { mkdirSync } from 'node:fs';
+import { realpathSync } from 'node:fs';
+import { Command } from 'commander';
+import { VERSION } from './version.js';
+import { agentsRoot, tmpRoot, logsRoot } from './paths.js';
+import { loadConfig } from './config.js';
+import { Tmux } from './tmux.js';
+import { pickBackend } from './supervisor/index.js';
+import { up, down, restartRoles, rmRole } from './ops.js';
+import { runOnce, runTemp } from './runner.js';
+import { spawnPermanent, spawnTemp } from './spawn.js';
+import { doctor } from './doctor.js';
+import './harness/claude-code.js'; // registers the claude-code adapter
+const binPath = (() => { try {
+    return realpathSync(process.argv[1]);
+}
+catch {
+    return process.argv[1];
+} })();
+const deps = () => ({
+    backend: pickBackend(),
+    binPath,
+    sleep: ms => new Promise(r => setTimeout(r, ms)),
+    log: l => console.log(l),
+});
+const die = (e) => { console.error(String(e instanceof Error ? e.message : e)); process.exit(1); };
+/** Exec a child with our stdio (logs/attach). */
+const passthrough = (cmd, args) => new Promise(resolve => {
+    const c = spawnChild(cmd, args, { stdio: 'inherit' });
+    c.on('exit', code => resolve(code ?? 1));
+});
+const program = new Command()
+    .name('ours-fleet')
+    .description('Fleet of persistent, identity-bound AI agents — harness-agnostic, tmux + systemd/launchd.')
+    .version(VERSION);
+const cOpt = (cmd) => cmd.option('-c, --configuration <file>', 'config file (default: ~/fleet.yaml + ~/fleet.d/)');
+cOpt(program.command('config').description('validate + print the merged plan (no side effects)'))
+    .action(opts => {
+    try {
+        const cfg = loadConfig(opts.configuration);
+        console.log(`config: ${cfg.files.join(' + ') || '(none)'}`);
+        for (const r of cfg.roles) {
+            console.log(`\n● ${r.name}`);
+            console.log(`    harness:     ${r.harness}`);
+            console.log(`    identity:    ${r.identity}`);
+            console.log(`    source:      ${r.sourceFile}`);
+            if (r.cwd)
+                console.log(`    cwd:         ${r.cwd}`);
+            if (r.coordinator)
+                console.log(`    coordinator: ${r.coordinator}`);
+            if (r.mission)
+                console.log(`    mission:     ${r.mission.split('\n')[0]}`);
+            if (r.oversee?.length)
+                console.log(`    oversees:    ${r.oversee.map(o => `${o.role}@${o.interval}`).join(', ')}`);
+        }
+    }
+    catch (e) {
+        die(e);
+    }
+});
+cOpt(program.command('up [names...]').description('create/start every role (or just the named ones)'))
+    .action(async (names, opts) => {
+    try {
+        await up(loadConfig(opts.configuration), names, deps());
+    }
+    catch (e) {
+        die(e);
+    }
+});
+cOpt(program.command('down [names...]').description('stop roles'))
+    .action(async (names, opts) => {
+    try {
+        await down(loadConfig(opts.configuration), names, deps());
+    }
+    catch (e) {
+        die(e);
+    }
+});
+cOpt(program.command('restart [names...]').description('re-sync config + bounce, RESUMING context'))
+    .action(async (names, opts) => {
+    try {
+        await restartRoles(loadConfig(opts.configuration), names, deps(), 'keep');
+    }
+    catch (e) {
+        die(e);
+    }
+});
+cOpt(program.command('force-restart [names...]').description('re-sync + bounce FRESH (context wiped)'))
+    .action(async (names, opts) => {
+    try {
+        await restartRoles(loadConfig(opts.configuration), names, deps(), 'fresh');
+    }
+    catch (e) {
+        die(e);
+    }
+});
+program.command('ls').description('list running tmux consoles')
+    .action(async () => { console.log(await new Tmux().list() || '(none)'); });
+program.command('attach <name>').description('open the live console (Ctrl-b d to leave)')
+    .action(async (name) => process.exit(await passthrough('tmux', ['attach', '-t', name])));
+program.command('peek <name> [lines]').description('pane snapshot without attaching')
+    .action(async (name, lines) => {
+    try {
+        console.log(await new Tmux().capture(name, lines ? Number(lines) : 40));
+    }
+    catch {
+        die(`'${name}' is not running; try: ours-fleet status ${name}`);
+    }
+});
+program.command('send <name> [text...]').description("type into the agent's console")
+    .option('--key <key>', 'send a raw key instead (Escape, Up, C-c, ...)')
+    .action(async (name, text, opts) => {
+    try {
+        const tmux = new Tmux();
+        if (opts.key)
+            await tmux.sendKey(name, opts.key);
+        else if (text?.length)
+            await tmux.sendText(name, text.join(' '));
+        else
+            die('nothing to send: give text or --key');
+    }
+    catch {
+        die(`'${name}' is not running; try: ours-fleet status ${name}`);
+    }
+});
+program.command('logs <name>').description('show the role log').option('-f, --follow', 'follow')
+    .action(async (name, opts) => {
+    const { cmd, args } = pickBackend().logsArgs(name, opts.follow === true);
+    process.exit(await passthrough(cmd, args));
+});
+program.command('status <name>').description('unit/agent state')
+    .action(async (name) => { console.log(await pickBackend().status(name)); });
+cOpt(program.command('rm <name>').description('stop + delete state dir (+ its fleet.d file if spawned)'))
+    .action(async (name, opts) => {
+    try {
+        await rmRole(loadConfig(opts.configuration), name, deps());
+    }
+    catch (e) {
+        die(e);
+    }
+});
+cOpt(program.command('spawn <name>').description('spawn a new agent (permanent by default)'))
+    .option('--temp', 'temporary: plain tmux, auto-cleaned, gone on reboot')
+    .option('--harness <id>', 'harness adapter (default: defaults.harness)')
+    .option('--mission <text>', 'one-line mission')
+    .option('--identity <name>', 'ours identity to bind (default: role name)')
+    .option('--cwd <dir>', 'working directory')
+    .option('--coordinator <name>', 'announce target')
+    .option('--bio-file <file>', 'public bio (file)')
+    .option('--persona-file <file>', 'persona / operating contract (file)')
+    .action(async (name, opts) => {
+    const o = {
+        name, temp: opts.temp, harness: opts.harness, mission: opts.mission,
+        identity: opts.identity, cwd: opts.cwd, coordinator: opts.coordinator,
+        bioFile: opts.bioFile, personaFile: opts.personaFile, configPath: opts.configuration,
+    };
+    try {
+        if (o.temp) {
+            const dir = await spawnTemp(o, new Tmux(), binPath);
+            console.log(`spawned temp agent '${name}' (state: ${dir}; gone on exit/reboot)`);
+        }
+        else {
+            const file = await spawnPermanent(o, deps());
+            console.log(`spawned '${name}' (config: ${file})`);
+        }
+        console.log(`→ watch it: ours-fleet peek ${name}   |   attach: ours-fleet attach ${name}`);
+    }
+    catch (e) {
+        die(e);
+    }
+});
+cOpt(program.command('doctor').description('prerequisite report'))
+    .option('--harness <id>', 'check one harness explicitly')
+    .action(async (opts) => {
+    const rep = await doctor({ harness: opts.harness, configPath: opts.configuration });
+    for (const c of rep.checks)
+        console.log(`${c.ok ? 'ok  ' : 'MISS'} ${c.name.padEnd(22)} ${c.detail}`);
+    process.exit(rep.ok ? 0 : 1);
+});
+program.command('init').description('one-time host setup (units, dirs, linger)')
+    .action(async () => {
+    for (const d of [agentsRoot(), tmpRoot(), logsRoot()])
+        mkdirSync(d, { recursive: true });
+    for (const m of await pickBackend().init(binPath))
+        console.log(m);
+    console.log('\nNext: copy examples/fleet.yaml to ~/fleet.yaml, edit, then: ours-fleet up');
+});
+program.command('_run <name>', { hidden: true }).description('internal: supervisor entrypoint')
+    .option('-c, --configuration <file>')
+    .action(async (name, opts) => {
+    try {
+        await runOnce(name, { configPath: opts.configuration });
+    }
+    catch (e) {
+        die(e);
+    }
+});
+program.command('_run-temp <name>', { hidden: true }).description('internal: temp-agent entrypoint')
+    .action(async (name) => {
+    try {
+        await runTemp(name);
+    }
+    catch (e) {
+        die(e);
+    }
+});
+program.parseAsync(process.argv);

package/dist/config.d.ts

@@ -0,0 +1,36 @@
+export interface OverseeEntry {
+    role: string;
+    interval: string;
+}
+export interface RoleConfig {
+    harness?: string;
+    identity?: string;
+    cwd?: string;
+    coordinator?: string;
+    mission?: string;
+    persona?: string;
+    bio?: string;
+    briefing_file?: string;
+    max_tokens?: number;
+    autocompact_pct?: number;
+    env?: Record<string, string>;
+    oversee?: OverseeEntry[];
+    harness_options?: Record<string, unknown>;
+}
+export interface ResolvedRole extends RoleConfig {
+    name: string;
+    harness: string;
+    identity: string;
+    sourceFile: string;
+}
+export interface FleetConfig {
+    roles: ResolvedRole[];
+    vars: Record<string, string>;
+    defaults: Record<string, unknown>;
+    files: string[];
+}
+export declare class ConfigError extends Error {
+}
+/** Load ~/fleet.yaml (or an explicit path) merged with ~/fleet.d/*.yaml drop-ins. */
+export declare function loadConfig(configPath?: string): FleetConfig;
+export declare function findRole(cfg: FleetConfig, name: string): ResolvedRole;