@ours.network/fleet 0.1.0

package/dist/config.js

@@ -0,0 +1,79 @@
+import { existsSync, readFileSync, readdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { parse } from 'yaml';
+import { defaultConfigPath, fleetDDir } from './paths.js';
+export class ConfigError extends Error {
+}
+const NAME_RE = /^[A-Za-z0-9_-]+$/;
+const ROLE_KEYS = [
+    'harness', 'identity', 'cwd', 'coordinator', 'mission', 'persona', 'bio',
+    'briefing_file', 'max_tokens', 'autocompact_pct', 'env', 'oversee', 'harness_options',
+];
+function deepSub(v, vars) {
+    if (typeof v === 'string')
+        return v.replace(/\$\{(\w+)\}/g, (m, k) => (k in vars ? String(vars[k]) : m));
+    if (Array.isArray(v))
+        return v.map(x => deepSub(x, vars));
+    if (v && typeof v === 'object')
+        return Object.fromEntries(Object.entries(v).map(([k, x]) => [k, deepSub(x, vars)]));
+    return v;
+}
+/** Load ~/fleet.yaml (or an explicit path) merged with ~/fleet.d/*.yaml drop-ins. */
+export function loadConfig(configPath) {
+    const base = configPath ?? defaultConfigPath();
+    const files = [];
+    const docs = [];
+    if (existsSync(base)) {
+        docs.push({ file: base, doc: (parse(readFileSync(base, 'utf8')) ?? {}) });
+        files.push(base);
+    }
+    else if (configPath) {
+        throw new ConfigError(`config not found: ${base}`);
+    }
+    const dd = fleetDDir();
+    if (existsSync(dd)) {
+        for (const f of readdirSync(dd).filter(f => f.endsWith('.yaml') || f.endsWith('.yml')).sort()) {
+            const p = join(dd, f);
+            const doc = (parse(readFileSync(p, 'utf8')) ?? {});
+            const extra = Object.keys(doc).filter(k => k !== 'roles');
+            if (extra.length)
+                throw new ConfigError(`${p}: fleet.d files may only define roles: (found: ${extra.join(', ')})`);
+            docs.push({ file: p, doc });
+            files.push(p);
+        }
+    }
+    const baseDoc = docs.length && docs[0].file === base ? docs[0].doc : {};
+    const vars = (baseDoc.vars ?? {});
+    const defaults = (baseDoc.defaults ?? {});
+    const seen = new Map();
+    const roles = [];
+    for (const { file, doc } of docs) {
+        for (const [name, raw] of Object.entries((doc.roles ?? {}))) {
+            if (!NAME_RE.test(name))
+                throw new ConfigError(`${file}: invalid role name '${name}' (allowed: [A-Za-z0-9_-])`);
+            const prev = seen.get(name);
+            if (prev)
+                throw new ConfigError(`role '${name}' defined in both ${prev} and ${file}`);
+            seen.set(name, file);
+            const r = deepSub(raw ?? {}, vars);
+            const bad = Object.keys(r).filter(k => !ROLE_KEYS.includes(k));
+            if (bad.length)
+                throw new ConfigError(`${file}: role '${name}' has unknown key(s) ${bad.join(', ')}; allowed: ${ROLE_KEYS.join(', ')}`);
+            roles.push({
+                ...r,
+                name,
+                sourceFile: file,
+                harness: r.harness ?? defaults.harness ?? 'claude-code',
+                identity: r.identity ?? name,
+                max_tokens: r.max_tokens ?? defaults.max_tokens,
+            });
+        }
+    }
+    return { roles, vars, defaults, files };
+}
+export function findRole(cfg, name) {
+    const r = cfg.roles.find(r => r.name === name);
+    if (!r)
+        throw new ConfigError(`no such role '${name}' in ${cfg.files.join(', ') || 'config'}`);
+    return r;
+}

package/dist/doctor.d.ts

@@ -0,0 +1,7 @@
+import { type Exec } from './exec.js';
+import type { PrereqReport } from './harness/types.js';
+/** Host-level + per-harness prerequisite report with actionable messages. */
+export declare function doctor(opts?: {
+    harness?: string;
+    configPath?: string;
+}, exec?: Exec, platform?: NodeJS.Platform): Promise<PrereqReport>;

package/dist/doctor.js

@@ -0,0 +1,61 @@
+import { userInfo } from 'node:os';
+import { realExec } from './exec.js';
+import { loadConfig } from './config.js';
+import { getAdapter } from './harness/registry.js';
+/** Host-level + per-harness prerequisite report with actionable messages. */
+export async function doctor(opts = {}, exec = realExec, platform = process.platform) {
+    const checks = [];
+    const major = Number(process.versions.node.split('.')[0]);
+    checks.push({
+        name: 'node', ok: major >= 20,
+        detail: major >= 20 ? `v${process.versions.node}` : `v${process.versions.node} — need >= 20`,
+    });
+    const tmux = await exec('tmux', ['-V']);
+    checks.push({
+        name: 'tmux', ok: tmux.code === 0,
+        detail: tmux.code === 0 ? tmux.stdout.trim() : 'not found — apt install tmux / brew install tmux',
+    });
+    const mcp = await exec('ours-mcp', ['--version']);
+    checks.push({
+        name: 'ours-mcp', ok: mcp.code === 0,
+        detail: mcp.code === 0 ? mcp.stdout.trim() : 'not found — npm i -g @ours.network/mcp',
+    });
+    if (mcp.code === 0) {
+        const st = await exec('ours-mcp', ['status']);
+        checks.push({
+            name: 'ours-mcp daemon', ok: st.code === 0,
+            detail: st.code === 0 ? 'running' : 'not running — start it with: ours-mcp start',
+        });
+    }
+    if (platform === 'linux') {
+        const user = userInfo().username;
+        const linger = await exec('loginctl', ['show-user', user, '--property=Linger']);
+        const ok = linger.code === 0 && linger.stdout.includes('Linger=yes');
+        checks.push({
+            name: 'linger', ok,
+            detail: ok ? 'enabled (roles survive logout/reboot)'
+                : `not enabled — run: ours-fleet init (or: sudo loginctl enable-linger ${user})`,
+        });
+    }
+    const harnesses = opts.harness
+        ? [opts.harness]
+        : [...new Set(loadConfigSafe(opts.configPath).map(r => r.harness))];
+    for (const h of harnesses) {
+        try {
+            const rep = await getAdapter(h).checkPrereqs();
+            checks.push(...rep.checks.map(c => ({ ...c, name: `${h}: ${c.name}` })));
+        }
+        catch (e) {
+            checks.push({ name: h, ok: false, detail: e.message });
+        }
+    }
+    return { ok: checks.every(c => c.ok), checks };
+}
+function loadConfigSafe(configPath) {
+    try {
+        return loadConfig(configPath).roles;
+    }
+    catch {
+        return [];
+    }
+}

package/dist/exec.d.ts

@@ -0,0 +1,12 @@
+export interface ExecResult {
+    stdout: string;
+    stderr: string;
+    code: number;
+}
+export type Exec = (cmd: string, args: string[], opts?: {
+    env?: NodeJS.ProcessEnv;
+}) => Promise<ExecResult>;
+/** execFile wrapper that never rejects; missing binary → code 127. */
+export declare const realExec: Exec;
+/** POSIX single-quote shell escaping. */
+export declare const shq: (s: string) => string;

package/dist/exec.js

@@ -0,0 +1,14 @@
+import { execFile } from 'node:child_process';
+/** execFile wrapper that never rejects; missing binary → code 127. */
+export const realExec = (cmd, args, opts) => new Promise(resolve => {
+    execFile(cmd, args, { env: opts?.env ?? process.env, maxBuffer: 10 * 1024 * 1024 }, (err, stdout, stderr) => {
+        let code = 0;
+        if (err) {
+            const c = err.code;
+            code = typeof c === 'number' ? c : c === 'ENOENT' ? 127 : 1;
+        }
+        resolve({ stdout: String(stdout), stderr: String(stderr), code });
+    });
+});
+/** POSIX single-quote shell escaping. */
+export const shq = (s) => `'${s.replace(/'/g, `'\\''`)}'`;

package/dist/harness/claude-code.d.ts

@@ -0,0 +1,8 @@
+import { type Exec } from '../exec.js';
+import type { ResolvedRole } from '../config.js';
+import type { HarnessAdapter } from './types.js';
+export declare function autocompactPct(role: ResolvedRole): number;
+/** Pre-trust a dir in ~/.claude.json so the first launch never blocks on the trust dialog. */
+export declare function pretrust(dir: string): void;
+export declare function makeClaudeCodeAdapter(exec?: Exec): HarnessAdapter;
+export declare const claudeCodeAdapter: HarnessAdapter;

package/dist/harness/claude-code.js

@@ -0,0 +1,116 @@
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { home } from '../paths.js';
+import { realExec } from '../exec.js';
+import { registerAdapter } from './registry.js';
+const OPTION_KEYS = ['plugins', 'mem_palace', 'mem_palace_midsession_autosave'];
+/** Context window of the fleet model (1M); max_tokens → % of this. */
+const WINDOW = 1_000_000;
+export function autocompactPct(role) {
+    let pct;
+    if (role.autocompact_pct != null)
+        pct = Math.round(role.autocompact_pct);
+    else if (role.max_tokens != null)
+        pct = Math.round((role.max_tokens / WINDOW) * 100);
+    else
+        return 50;
+    return Math.max(1, Math.min(100, pct));
+}
+/** Pre-trust a dir in ~/.claude.json so the first launch never blocks on the trust dialog. */
+export function pretrust(dir) {
+    const p = join(home(), '.claude.json');
+    const d = existsSync(p) ? JSON.parse(readFileSync(p, 'utf8')) : {};
+    const projects = (d.projects ??= {});
+    const e = (projects[dir] ??= {});
+    e.hasTrustDialogAccepted = true;
+    e.hasCompletedProjectOnboarding = true;
+    e.projectOnboardingSeenCount = Math.max(e.projectOnboardingSeenCount ?? 0, 1);
+    writeFileSync(p, JSON.stringify(d, null, 2));
+}
+export function makeClaudeCodeAdapter(exec = realExec) {
+    return {
+        id: 'claude-code',
+        supportsResume: true,
+        async checkPrereqs() {
+            const r = await exec('claude', ['--version']);
+            const ok = r.code === 0;
+            return {
+                ok,
+                checks: [{
+                        name: 'claude',
+                        ok,
+                        detail: ok ? r.stdout.trim() : 'claude CLI not found on PATH — install Claude Code and log in',
+                    }],
+            };
+        },
+        validateOptions(opts) {
+            if (opts == null)
+                return [];
+            if (typeof opts !== 'object' || Array.isArray(opts))
+                return [{ path: 'harness_options', message: 'must be a map' }];
+            return Object.keys(opts)
+                .filter(k => !OPTION_KEYS.includes(k))
+                .map(k => ({ path: `harness_options.${k}`, message: `unknown option; allowed: ${OPTION_KEYS.join(', ')}` }));
+        },
+        async prepareSession(role, dirs) {
+            pretrust(dirs.stateDir);
+            if (dirs.runCwd && dirs.runCwd !== dirs.stateDir)
+                pretrust(dirs.runCwd);
+            const o = (role.harness_options ?? {});
+            const memPalace = o.mem_palace !== false;
+            const enabledPlugins = { ...(o.plugins ?? {}) };
+            if (!memPalace)
+                enabledPlugins['mempalace@mempalace'] = false;
+            const env = {
+                CLAUDE_AUTOCOMPACT_PCT_OVERRIDE: String(autocompactPct(role)),
+                MEMPALACE_HOOKS_AUTO_SAVE: 'false',
+                MEMPALACE_MIDSESSION_AUTOSAVE: o.mem_palace_midsession_autosave ? 'true' : 'false',
+            };
+            if (!memPalace)
+                env.MEMPALACE_DISABLED = 'true';
+            const argv = [];
+            if (Object.keys(enabledPlugins).length) {
+                const overlay = join(dirs.stateDir, '.settings-overlay.json');
+                writeFileSync(overlay, JSON.stringify({ enabledPlugins }, null, 2));
+                argv.push('--settings', overlay);
+            }
+            return { argv, env };
+        },
+        buildLaunch(role, mode, s, prep) {
+            const stateDir = roleStateDir(role);
+            const base = ['claude', ...prep.argv, '--remote-control', role.name];
+            const argv = mode === 'fresh'
+                ? [...base, '--session-id', s.sessionId, `Read and follow ${join(stateDir, 'briefing.md')} now.`]
+                : [...base, '--resume', s.sessionId,
+                    this.vocabulary.restartPrompt(role.identity, join(stateDir, 'WORKLOG.md'))];
+            return { argv, env: prep.env };
+        },
+        vocabulary: {
+            bindTool: 'choose_identity',
+            createTool: 'create_identity',
+            setBioTool: 'set_bio',
+            setPersonaTool: 'set_persona',
+            currentIdentityTool: 'current_identity',
+            sendTool: 'send_message',
+            getMessagesTool: 'get_messages',
+            watchCommand: id => `ours-mcp watch "${id}"`,
+            monitorInstruction: id => `Arm a **persistent Monitor** running the shell command \`ours-mcp watch "${id}"\` so inbound ours mail wakes you.`,
+            launchNote: name => `You were launched with \`--remote-control ${name}\`. Confirm you are running.`,
+            restartPrompt: (id, worklog) => `Session restarted. Re-bind your ours identity now (choose_identity name "${id}" force=true), ` +
+                `re-arm your monitor (ours-mcp watch "${id}"), then continue from ${worklog}. ` +
+                'Do not re-run whatever crashed you.',
+        },
+        exitPolicy: { cleanExitIsFresh: true, fastFailSecs: 20 },
+    };
+}
+// The adapter needs the state dir for briefing/worklog paths in launch prompts.
+// Roles' state dirs are canonical: agentDir(name) — temp roles carry their dir in cwd handling
+// by the runner, which passes dirs to prepareSession; buildLaunch derives from the same rule.
+import { agentDir } from '../paths.js';
+function roleStateDir(role) {
+    // Temp roles are marked by the runner via a private field to keep the interface small.
+    const temp = role.__temp === true;
+    return agentDir(role.name, temp);
+}
+export const claudeCodeAdapter = makeClaudeCodeAdapter();
+registerAdapter(claudeCodeAdapter);

package/dist/harness/registry.d.ts

@@ -0,0 +1,4 @@
+import type { HarnessAdapter } from './types.js';
+export declare function registerAdapter(a: HarnessAdapter): void;
+export declare function getAdapter(id: string): HarnessAdapter;
+export declare function knownAdapters(): string[];

package/dist/harness/registry.js

@@ -0,0 +1,13 @@
+const adapters = new Map();
+export function registerAdapter(a) {
+    adapters.set(a.id, a);
+}
+export function getAdapter(id) {
+    const a = adapters.get(id);
+    if (!a)
+        throw new Error(`unknown harness '${id}'; registered: ${[...adapters.keys()].join(', ') || '(none)'}`);
+    return a;
+}
+export function knownAdapters() {
+    return [...adapters.keys()];
+}

package/dist/harness/types.d.ts

@@ -0,0 +1,58 @@
+import type { ResolvedRole } from '../config.js';
+export interface PrereqCheck {
+    name: string;
+    ok: boolean;
+    detail: string;
+}
+export interface PrereqReport {
+    ok: boolean;
+    checks: PrereqCheck[];
+}
+export interface RoleDirs {
+    stateDir: string;
+    runCwd: string;
+}
+export interface SessionState {
+    sessionId: string;
+}
+/** Extra argv/env contributed by prepareSession (overlays, trust, limits). */
+export interface SessionPrep {
+    argv: string[];
+    env: Record<string, string>;
+}
+export interface Launch {
+    argv: string[];
+    env: Record<string, string>;
+}
+/** Harness-correct wording/tool names used to generate briefing.md. */
+export interface BriefingVocab {
+    bindTool: string;
+    createTool: string;
+    setBioTool: string;
+    setPersonaTool: string;
+    currentIdentityTool: string;
+    sendTool: string;
+    getMessagesTool: string;
+    watchCommand(identity: string): string;
+    monitorInstruction(identity: string): string;
+    launchNote(name: string): string;
+    restartPrompt(identity: string, worklogPath: string): string;
+}
+export interface ExitPolicy {
+    cleanExitIsFresh: boolean;
+    fastFailSecs: number;
+}
+export interface ValidationError {
+    path: string;
+    message: string;
+}
+export interface HarnessAdapter {
+    id: string;
+    supportsResume: boolean;
+    checkPrereqs(): Promise<PrereqReport>;
+    validateOptions(opts: unknown): ValidationError[];
+    prepareSession(role: ResolvedRole, dirs: RoleDirs): Promise<SessionPrep>;
+    buildLaunch(role: ResolvedRole, mode: 'fresh' | 'resume', s: SessionState, prep: SessionPrep): Launch;
+    vocabulary: BriefingVocab;
+    exitPolicy: ExitPolicy;
+}

package/dist/harness/types.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+export { loadConfig, findRole, ConfigError } from './config.js';
+export type { FleetConfig, ResolvedRole, RoleConfig, OverseeEntry } from './config.js';
+export type { HarnessAdapter, BriefingVocab, ExitPolicy, PrereqReport, PrereqCheck, SessionPrep, SessionState, Launch, RoleDirs, ValidationError, } from './harness/types.js';
+export { registerAdapter, getAdapter, knownAdapters } from './harness/registry.js';
+export { claudeCodeAdapter, makeClaudeCodeAdapter } from './harness/claude-code.js';
+export { generateBriefing } from './briefing.js';
+export { pickBackend } from './supervisor/index.js';
+export type { SupervisorBackend } from './supervisor/types.js';
+export { up, down, restartRoles, rmRole, applyRole } from './ops.js';
+export { spawnPermanent, spawnTemp } from './spawn.js';
+export { doctor } from './doctor.js';
+export { runOnce, runTemp } from './runner.js';
+export { Tmux } from './tmux.js';
+export { VERSION } from './version.js';

package/dist/index.js

@@ -0,0 +1,11 @@
+export { loadConfig, findRole, ConfigError } from './config.js';
+export { registerAdapter, getAdapter, knownAdapters } from './harness/registry.js';
+export { claudeCodeAdapter, makeClaudeCodeAdapter } from './harness/claude-code.js';
+export { generateBriefing } from './briefing.js';
+export { pickBackend } from './supervisor/index.js';
+export { up, down, restartRoles, rmRole, applyRole } from './ops.js';
+export { spawnPermanent, spawnTemp } from './spawn.js';
+export { doctor } from './doctor.js';
+export { runOnce, runTemp } from './runner.js';
+export { Tmux } from './tmux.js';
+export { VERSION } from './version.js';

package/dist/ops.d.ts

@@ -0,0 +1,20 @@
+import type { FleetConfig, ResolvedRole } from './config.js';
+import type { SupervisorBackend } from './supervisor/types.js';
+export interface OpsDeps {
+    backend: SupervisorBackend;
+    binPath: string;
+    sleep(ms: number): Promise<void>;
+    log(line: string): void;
+}
+/** Materialize a role's state dir from config: briefing + markers. Returns the dir. */
+export declare function applyRole(role: ResolvedRole, opts?: {
+    fresh?: boolean;
+    temp?: boolean;
+}): string;
+/** Create/start roles declaratively. Idempotent; active roles keep their context. */
+export declare function up(cfg: FleetConfig, names: string[], deps: OpsDeps): Promise<void>;
+export declare function down(cfg: FleetConfig, names: string[], deps: OpsDeps): Promise<void>;
+/** Re-sync from config + bounce. mode 'keep' resumes context; 'fresh' wipes it. */
+export declare function restartRoles(cfg: FleetConfig, names: string[], deps: OpsDeps, mode: 'keep' | 'fresh'): Promise<void>;
+/** Stop + forget a role: unit, state dir, and its fleet.d file when spawned. */
+export declare function rmRole(cfg: FleetConfig, name: string, deps: OpsDeps): Promise<void>;

package/dist/ops.js

@@ -0,0 +1,87 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync, rmSync, unlinkSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { agentDir, fleetDDir } from './paths.js';
+import { findRole } from './config.js';
+import { getAdapter } from './harness/registry.js';
+import { generateBriefing } from './briefing.js';
+const STAGGER_MS = () => 1000 * Number(process.env.FLEET_START_STAGGER ?? 5);
+/** Materialize a role's state dir from config: briefing + markers. Returns the dir. */
+export function applyRole(role, opts = {}) {
+    const adapter = getAdapter(role.harness);
+    const errs = adapter.validateOptions(role.harness_options);
+    if (errs.length)
+        throw new Error(`role '${role.name}': ` + errs.map(e => `${e.path}: ${e.message}`).join('; '));
+    const dir = agentDir(role.name, opts.temp === true);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(join(dir, '.identity'), role.identity + '\n');
+    if (role.cwd)
+        writeFileSync(join(dir, '.cwd'), role.cwd + '\n');
+    if (!existsSync(join(dir, '.session-id')))
+        writeFileSync(join(dir, '.session-id'), randomUUID() + '\n');
+    if (!existsSync(join(dir, 'WORKLOG.md')))
+        writeFileSync(join(dir, 'WORKLOG.md'), '');
+    const briefingBody = role.briefing_file ? readFileSync(role.briefing_file, 'utf8') : undefined;
+    writeFileSync(join(dir, 'briefing.md'), generateBriefing(role, adapter.vocabulary, {
+        stateDir: dir, worklogPath: join(dir, 'WORKLOG.md'), briefingBody,
+    }));
+    if (opts.fresh)
+        for (const f of ['.booted', '.session-id', '.exit-status'])
+            rmSync(join(dir, f), { force: true });
+    return dir;
+}
+function selectRoles(cfg, names) {
+    return names.length ? names.map(n => findRole(cfg, n)) : cfg.roles;
+}
+/** Create/start roles declaratively. Idempotent; active roles keep their context. */
+export async function up(cfg, names, deps) {
+    let first = true;
+    for (const role of selectRoles(cfg, names)) {
+        if (!first)
+            await deps.sleep(STAGGER_MS());
+        first = false;
+        const dir = applyRole(role);
+        // If the role isn't running, boot fresh so it reads the briefing we just wrote.
+        const status = await deps.backend.status(role.name).catch(() => '');
+        if (!/running|active \(/.test(status))
+            rmSync(join(dir, '.booted'), { force: true });
+        await deps.backend.install(role.name, deps.binPath);
+        deps.log(`↑ up: ${role.name} (harness: ${role.harness}, identity: ${role.identity}${role.cwd ? `, cwd: ${role.cwd}` : ''})`);
+    }
+}
+export async function down(cfg, names, deps) {
+    for (const role of selectRoles(cfg, names)) {
+        try {
+            await deps.backend.stop(role.name);
+            deps.log(`■ stopped ${role.name}`);
+        }
+        catch {
+            deps.log(`  (could not stop ${role.name} — maybe not running)`);
+        }
+    }
+}
+/** Re-sync from config + bounce. mode 'keep' resumes context; 'fresh' wipes it. */
+export async function restartRoles(cfg, names, deps, mode) {
+    let first = true;
+    for (const role of selectRoles(cfg, names)) {
+        if (!first)
+            await deps.sleep(STAGGER_MS());
+        first = false;
+        applyRole(role, { fresh: mode === 'fresh' });
+        await deps.backend.restart(role.name);
+        deps.log(mode === 'fresh'
+            ? `↻ ${role.name} — force-restarted (FRESH — context cleared, briefing reloaded)`
+            : `↻ ${role.name} — restarted (resumes; briefing re-synced)`);
+    }
+}
+/** Stop + forget a role: unit, state dir, and its fleet.d file when spawned. */
+export async function rmRole(cfg, name, deps) {
+    const role = findRole(cfg, name);
+    await deps.backend.uninstall(name);
+    rmSync(agentDir(name), { recursive: true, force: true });
+    if (role.sourceFile.startsWith(fleetDDir() + '/')) {
+        unlinkSync(role.sourceFile);
+        deps.log(`removed ${role.sourceFile}`);
+    }
+    deps.log(`removed '${name}' (its ours identity is left intact)`);
+}

package/dist/paths.d.ts

@@ -0,0 +1,9 @@
+/** Home root for config + state. OURS_FLEET_HOME overrides (tests, exotic setups). */
+export declare const home: () => string;
+export declare const stateRoot: () => string;
+export declare const agentsRoot: () => string;
+export declare const tmpRoot: () => string;
+export declare const logsRoot: () => string;
+export declare const agentDir: (name: string, temp?: boolean) => string;
+export declare const defaultConfigPath: () => string;
+export declare const fleetDDir: () => string;

package/dist/paths.js

@@ -0,0 +1,11 @@
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+/** Home root for config + state. OURS_FLEET_HOME overrides (tests, exotic setups). */
+export const home = () => process.env.OURS_FLEET_HOME ?? homedir();
+export const stateRoot = () => join(home(), '.ours-fleet');
+export const agentsRoot = () => join(stateRoot(), 'agents');
+export const tmpRoot = () => join(stateRoot(), 'tmp');
+export const logsRoot = () => join(stateRoot(), 'logs');
+export const agentDir = (name, temp = false) => join(temp ? tmpRoot() : agentsRoot(), name);
+export const defaultConfigPath = () => join(home(), 'fleet.yaml');
+export const fleetDDir = () => join(home(), 'fleet.d');

package/dist/runner.d.ts

@@ -0,0 +1,21 @@
+import { type ResolvedRole } from './config.js';
+import type { Launch } from './harness/types.js';
+import { Tmux } from './tmux.js';
+export interface RunnerDeps {
+    tmux: Tmux;
+    isAlive(pid: number): boolean;
+    sleep(ms: number): Promise<void>;
+    now(): number;
+    log(line: string): void;
+}
+/** Compose the tmux pane shell command: env prefix + argv + exit-status capture. */
+export declare function buildPaneCommand(launch: Launch, roleEnv: Record<string, string> | undefined, exitStatusPath: string): string;
+/** Read a temp role's config snapshot written by spawnTemp. */
+export declare function loadTempRole(name: string): ResolvedRole;
+/** One supervised session lifecycle. The supervisor re-invokes us after we return. */
+export declare function runOnce(name: string, opts?: {
+    temp?: boolean;
+    configPath?: string;
+}, partialDeps?: Partial<RunnerDeps>): Promise<void>;
+/** Temp-agent entrypoint: run one session, then remove the temp dir. */
+export declare function runTemp(name: string, deps?: Partial<RunnerDeps>): Promise<void>;