@ours.network/fleet 1.0.5 → 1.1.0-nightly.2

package/dist/application/role-removal-service.js

@@ -4,6 +4,7 @@ import { loadConfig, ROLE_NAME_RE } from '../config.js';
 import { agentDir, stateRoot } from '../paths.js';
 import { rmRole } from '../ops.js';
 import { FleetError } from './errors.js';
+import { provesGeneratedAgentSource } from '../generated-agent-source.js';
 export class RoleRemovalService {
     options;
     constructor(options) {
@@ -45,8 +46,9 @@ export class RoleRemovalService {
             `Stop and uninstall the exact backend registration for '${requested}'.`,
             `Archive then remove ${lifetime === 'temporary' ? temporaryState : permanentState}.`,
         ];
-        if (role?.sourceFile.includes('/fleet.d/'))
-            effects.push(`Remove spawned configuration ${role.sourceFile}.`);
+        const generatedSource = role && provesGeneratedAgentSource(agentDir(requested), cfg.files[0], role.sourceFile);
+        if (generatedSource)
+            effects.push(`Remove generated Agent configuration ${role.sourceFile}.`);
         else if (role)
             effects.push(`Keep hand-written configuration ${role.sourceFile}; the role can be recreated from it.`);
         else
@@ -76,7 +78,8 @@ export class RoleRemovalService {
         mkdirSync(recoveryPath, { recursive: true, mode: 0o700 });
         if (existsSync(sourceState))
             cpSync(sourceState, join(recoveryPath, 'state'), { recursive: true });
-        if (role?.sourceFile.includes('/fleet.d/') && existsSync(role.sourceFile))
+        if (role && provesGeneratedAgentSource(agentDir(preview.role), cfg.files[0], role.sourceFile)
+            && existsSync(role.sourceFile))
             cpSync(role.sourceFile, join(recoveryPath, basename(role.sourceFile)));
         if (role || preview.lifetime === 'temporary')
             await rmRole(cfg, preview.role, this.options.ops);

package/dist/application/role-repository.d.ts

@@ -3,9 +3,8 @@ export interface RoleRepositoryOptions {
     configPath?: string;
     permanentRoot?: string;
     temporaryRoot?: string;
-    probeBackend?: (name: string, intended?: 'acp' | 'tmux') => Promise<{
+    probeBackend?: (name: string, intended?: 'acp') => Promise<{
         acp: boolean;
-        tmux: boolean;
     }>;
     concurrency?: number;
     timeoutMs?: number;

package/dist/application/role-repository.js

@@ -42,7 +42,11 @@ function snapshot(path, name) {
         const raw = parse(readFileSync(path, 'utf8'));
         if (!raw || typeof raw !== 'object')
             throw new Error('snapshot must be a mapping');
-        const session = raw.session === 'acp' || raw.session === 'tmux' ? raw.session : 'tmux';
+        if (raw.session === 'tmux')
+            throw new Error('session: tmux is no longer supported; use session: acp with the Codex or Claude Code adapter');
+        if (raw.session !== undefined && raw.session !== 'acp')
+            throw new Error(`unsupported session '${String(raw.session)}'; expected session: acp`);
+        const session = 'acp';
         return {
             role: {
                 ...raw, name, harness: typeof raw.harness === 'string' ? raw.harness : 'claude-code',
@@ -167,14 +171,10 @@ export class RoleRepository {
         const timeoutMs = this.options.timeoutMs ?? 2_000;
         const result = await Promise.race([
             this.options.probeBackend(name, intended),
-            new Promise(resolve => setTimeout(() => resolve({ acp: false, tmux: false }), timeoutMs)),
-        ]).catch(() => ({ acp: false, tmux: false }));
-        if (result.acp && result.tmux)
-            return 'ambiguous';
+            new Promise(resolve => setTimeout(() => resolve({ acp: false }), timeoutMs)),
+        ]).catch(() => ({ acp: false }));
         if (result.acp)
             return 'acp';
-        if (result.tmux)
-            return 'tmux';
         return 'none';
     }
 }

package/dist/application/session-control.d.ts

@@ -1,7 +1,6 @@
 import { controlRequest } from '../session/control.js';
 import type { ConversationEventV1, ConversationSnapshot, PromptReceipt } from '../session/conversation-types.js';
 import type { SessionSnapshot } from '../session/types.js';
-import { Tmux } from '../tmux.js';
 import type { OutputPage, SendReceipt, SessionDescriptor } from './types.js';
 export interface ConversationPageView {
     events: ConversationEventV1[];
@@ -120,14 +119,3 @@ export declare class AcpRoleSessionAdapter implements RoleSessionControl {
     }>;
     private call;
 }
-export declare class TmuxRoleSessionAdapter implements RoleSessionControl {
-    private readonly roleId;
-    private readonly tmux;
-    constructor(roleId: string, tmux?: Tmux);
-    describe(): Promise<SessionDescriptor>;
-    snapshot(): Promise<SessionSnapshot>;
-    recentOutput(request?: {
-        limit?: number;
-    }): Promise<OutputPage>;
-    sendText(text: string): Promise<SendReceipt>;
-}

package/dist/application/session-control.js

@@ -1,6 +1,4 @@
-import { randomUUID } from 'node:crypto';
 import { controlRequest, followConversation } from '../session/control.js';
-import { Tmux } from '../tmux.js';
 import { FleetError, normalizeError } from './errors.js';
 const visibleEvents = (events) => events.filter(event => event.kind !== 'thought');
 export class AcpRoleSessionAdapter {
@@ -149,43 +147,3 @@ export class AcpRoleSessionAdapter {
         }
     }
 }
-export class TmuxRoleSessionAdapter {
-    roleId;
-    tmux;
-    constructor(roleId, tmux = new Tmux()) {
-        this.roleId = roleId;
-        this.tmux = tmux;
-    }
-    async describe() {
-        return { backend: 'tmux', protocolVersion: 1, features: ['text', 'capture'] };
-    }
-    async snapshot() {
-        const alive = await this.tmux.has(this.roleId);
-        return { backend: 'tmux', alive, readiness: alive ? 'idle' : 'failed' };
-    }
-    async recentOutput(request = {}) {
-        try {
-            const text = await this.tmux.capture(this.roleId, Math.min(request.limit ?? 100, 500));
-            return { events: [], text, truncated: false };
-        }
-        catch (error) {
-            throw normalizeError(error);
-        }
-    }
-    async sendText(text) {
-        if (!text.trim())
-            throw new FleetError('invalid_request', 'text is required');
-        if (Buffer.byteLength(text) > 32 * 1024)
-            throw new FleetError('invalid_request', 'text exceeds 32 KiB');
-        try {
-            await this.tmux.sendText(this.roleId, text);
-        }
-        catch (error) {
-            throw normalizeError(error);
-        }
-        return {
-            accepted: true, promptId: randomUUID(), queuedBehind: 0, terminalOutcomeKnown: false,
-            detail: 'literal text and Enter sent; terminal outcome is unknown',
-        };
-    }
-}

package/dist/application/session-mutations.d.ts

@@ -1,7 +1,7 @@
-import type { InterruptOutcome, QueuedPrompt, SessionHandle, SubmitPromptOptions, TurnCancellationSource } from '../session/types.js';
+import type { AgentSession, InterruptOutcome, QueuedPrompt, SubmitPromptOptions, TurnCancellationSource } from '../session/types.js';
 /** Thin in-process session mutation kernel. Callers retain every policy decision. */
-export declare const queueSessionPrompt: (session: SessionHandle, text: string, options?: SubmitPromptOptions) => Promise<QueuedPrompt>;
-export declare const interruptSession: (session: SessionHandle, source: TurnCancellationSource) => Promise<InterruptOutcome>;
-export declare const respondSessionPermission: (session: SessionHandle, permissionId: string, optionId: string) => boolean;
+export declare const queueSessionPrompt: (session: AgentSession, text: string, options?: SubmitPromptOptions) => Promise<QueuedPrompt>;
+export declare const interruptSession: (session: AgentSession, source: TurnCancellationSource) => Promise<InterruptOutcome>;
+export declare const respondSessionPermission: (session: AgentSession, permissionId: string, optionId: string) => boolean;
 export type GenerationPermissionResult = 'accepted' | 'stale' | 'unavailable';
-export declare const respondSessionPermissionV2: (session: SessionHandle, permissionId: string, optionId: string, sessionGeneration: string) => GenerationPermissionResult;
+export declare const respondSessionPermissionV2: (session: AgentSession, permissionId: string, optionId: string, sessionGeneration: string) => GenerationPermissionResult;

package/dist/application/types.d.ts

@@ -18,7 +18,7 @@ export interface ResolvedRoleView {
         sandbox?: string;
     };
     oversee?: Array<{
-        role: string;
+        agent: string;
         interval: string;
     }>;
 }
@@ -117,7 +117,6 @@ export interface RoleCapabilities {
     };
     input: {
         text: boolean;
-        rawKeys: boolean;
         interrupt: boolean;
         steering: boolean;
     };
@@ -125,12 +124,6 @@ export interface RoleCapabilities {
         observe: boolean;
         respond: boolean;
     };
-    terminal: {
-        available: boolean;
-        reason?: 'wrong_backend' | 'pty_unavailable' | 'offline' | 'incompatible_runner';
-        multiViewer: boolean;
-        writerLease: boolean;
-    };
     lifecycle: {
         start: boolean;
         stop: boolean;

package/dist/briefing.js

@@ -190,21 +190,18 @@ export function generateBriefing(role, v, opts) {
         L.push(`7. Await messages. When the monitor wakes you (or the owner requests a manual check),`);
         L.push(`   call **${v.getMessagesTool}**, act on them,`);
         L.push(`   and reply with ${v.sendTool}. No coordinator is configured — the owner drives you`);
-        // NOT `tmux attach -t <name>`: each role's pane lives on its own tmux
-        // socket (#32), so a bare attach finds no server. `ours-fleet attach`
-        // addresses the right one.
         L.push(`   via \`ours-fleet attach ${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(`- **${o.agent}** — check every ${o.interval}`);
         L.push('');
         L.push('Procedure (see also the oversee-agents skill if available). On each tick, for each ward');
         L.push('run BOTH — they answer different questions:');
         for (const o of role.oversee)
-            L.push(`\`ours-fleet status ${o.role}\` then \`ours-fleet peek ${o.role}\``);
+            L.push(`\`ours-fleet status ${o.agent}\` then \`ours-fleet peek ${o.agent}\``);
         L.push('');
         L.push('**One console command is not a liveness verdict.** A `peek` or `send` that fails tells');
         L.push('you what happened to YOUR REQUEST, and only one of its outcomes says the agent is gone.');
@@ -221,7 +218,7 @@ export function generateBriefing(role, v, opts) {
         L.push('idle or stalled from `readiness=idle` alone.');
         L.push('');
         L.push('Then judge the console content: stuck on a prompt/menu/trust dialog → answer it directly');
-        L.push('with `ours-fleet send <Name> "<text>"` (or `--key <K>` for raw keys); idle with work');
+        L.push('with `ours-fleet send <Name> "<text>"`; idle with work');
         L.push('assigned → nudge; actively working → do nothing, and do not mistake a long turn for a');
         L.push('stall. Escalate over ours messaging only when you cannot resolve it yourself.');
     }

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.0.5",
-  "buildId": "233dcfbef2e0",
-  "commit": "5846aa20eb58d5c4ecf8a98bb6a7d3f578afdc2b",
-  "dirty": false,
-  "builtAt": "2026-08-26T08:39:49.505Z",
+  "version": "1.1.0-nightly.2",
+  "buildId": "da774e6be6b1",
+  "commit": "f8890b0449f4142a0c27a195e1351555fe599186",
+  "dirty": true,
+  "builtAt": "2026-08-30T15:08:00.155Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/cli.js

@@ -6,12 +6,12 @@ import { join as joinPath, resolve as resolvePath } from 'node:path';
 import { createInterface } from 'node:readline';
 import { Command } from 'commander';
 import { VERSION } from './version.js';
+import { INIT_COMPLETION_GUIDANCE } from './init-guidance.js';
 import { analyzeInstalls, buildInfo, buildLabel, discoverInstalls, runningLabel, } from './provenance.js';
 import { agentDir, agentsRoot, tmpRoot, logsRoot, deriveXdgRuntimeDir } from './paths.js';
 import { findRole, loadConfig } from './config.js';
 import { formatDuration } from './duration.js';
-import { resolvedPlan } from './resolved-plan.js';
-import { Tmux, tmuxArgs } from './tmux.js';
+import { redactSensitive, resolvedPlan } from './resolved-plan.js';
 import { pickBackend } from './supervisor/index.js';
 import { up, down } from './ops.js';
 import { readRestartLedger, runSupervised, runTemp } from './runner.js';
@@ -74,10 +74,10 @@ const passthrough = (cmd, args) => new Promise(resolve => {
 });
 const program = new Command()
     .name('ours-fleet')
-    .description('Fleet of persistent, identity-bound AI agents — selectable harness and tmux/ACP sessions.')
+    .description('Fleet of persistent, identity-bound AI agents — selectable harnesses over ACP sessions.')
     .enablePositionalOptions()
     .version(VERSION);
-const cOpt = (cmd) => cmd.option('-c, --configuration <file>', 'config file (default: ~/fleet.yaml + ~/fleet.d/)');
+const cOpt = (cmd) => cmd.option('-c, --configuration <file>', 'manifest (default: ~/fleet.yaml; documents under ~/fleet/)');
 const collect = (value, previous) => [...previous, value];
 program.command('docs')
     .alias('man')
@@ -261,14 +261,16 @@ cOpt(program.command('config').description('validate + print the merged plan (no
                 console.log(`    cwd:         ${r.cwd}`);
             if (r.model)
                 console.log(`    model:       ${r.model}`);
+            if (r.effort)
+                console.log(`    effort:      ${r.effort}`);
             if (r.harness_options && Object.keys(r.harness_options).length)
-                console.log(`    options:     ${JSON.stringify(r.harness_options)}`);
+                console.log(`    options:     ${JSON.stringify(redactSensitive(r.harness_options))}`);
             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(', ')}`);
+                console.log(`    oversees:    ${r.oversee.map(o => `${o.agent}@${o.interval}`).join(', ')}`);
             if (r.isolation) {
                 const iso = r.isolation;
                 const caps = [
@@ -369,15 +371,11 @@ cOpt(program.command('force-restart [names...]').description('re-sync + bounce F
 });
 program.command('ls').description('list running fleet sessions')
     .action(async () => {
-    // Each session has its own tmux server (#32), so there is no single server
-    // to ask: the known role names ARE the list of servers to poll.
-    const names = [];
     const acp = [];
     for (const root of [agentsRoot(), tmpRoot()]) {
         if (!existsSync(root))
             continue;
         for (const name of readdirSync(root)) {
-            names.push(name);
             const stateDir = joinPath(root, name);
             if (!existsSync(controlSocketPath(stateDir)))
                 continue;
@@ -395,14 +393,13 @@ program.command('ls').description('list running fleet sessions')
             catch { /* ignore stale sockets */ }
         }
     }
-    const tmux = await new Tmux().list(names);
-    console.log([tmux, ...acp].filter(Boolean).join('\n') || '(none)');
+    console.log(acp.join('\n') || '(none)');
 });
 program.command('attach <name>').description('open the live console (Ctrl-b d to leave)')
     .action(async (name) => {
     const stateDir = acpStateDir(name);
     if (!stateDir)
-        process.exit(await passthrough('tmux', tmuxArgs(name, ['attach', '-t', name])));
+        throw new SessionControlError('offline', 'agent session is offline');
     try {
         const { socket, send } = await followControl(stateDir, message => {
             if ('event' in message)
@@ -439,7 +436,7 @@ program.command('attach <name>').description('open the live console (Ctrl-b d to
         die(e);
     }
 });
-/** Classify a raw tmux failure: only "no such session" proves the pane is gone. */
+/** Preserve typed control failures and classify only definite missing-session errors as offline. */
 const asControlError = (e) => {
     if (e instanceof SessionControlError)
         return e;
@@ -467,23 +464,17 @@ program.command('peek <name> [lines]').description('pane snapshot without attach
             for (const event of events.slice(-(lines ? Number(lines) : 40)))
                 renderSessionEvent(event);
         }
-        else {
-            console.log(await new Tmux().capture(name, lines ? Number(lines) : 40));
-        }
+        else
+            throw new SessionControlError('offline', 'agent session is offline');
     }
     catch (e) {
         die(controlFailure(name, 'peek', e));
     }
 });
 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) => {
     const stateDir = acpStateDir(name);
-    if (stateDir && opts.key)
-        die('--key is available only for tmux sessions');
-    if (!stateDir && !opts.key && !text?.length)
-        die('nothing to send: give text or --key');
-    if (stateDir && !text?.length)
+    if (!text?.length)
         die('nothing to send: give text');
     try {
         if (stateDir) {
@@ -496,10 +487,8 @@ program.command('send <name> [text...]').description("type into the agent's cons
                 ? `queued for ${name} behind ${queued.queuedBehind} running turn(s)`
                 : `queued for ${name}`);
         }
-        else if (opts.key)
-            await new Tmux().sendKey(name, opts.key);
         else
-            await new Tmux().sendText(name, text.join(' '));
+            throw new SessionControlError('offline', 'agent session is offline');
     }
     catch (e) {
         die(controlFailure(name, 'send', e, asControlError(e).kind === 'timeout'
@@ -1126,7 +1115,7 @@ cOpt(program.command('spawn [name]').description('spawn a new agent (permanent b
     .option('--role <name>', 'role name (alternative to the positional name)')
     .option('--temp', 'temporary: independent transient supervisor, archived on retirement, gone on reboot')
     .option('--harness <id>', 'harness adapter (default: defaults.harness)')
-    .option('--session <backend>', 'session backend: tmux|acp (default: defaults.session or tmux)')
+    .option('--session <backend>', 'session backend: acp (default: acp)')
     .option('--mission <text>', 'one-line mission')
     .option('--mission-file <path>', 'UTF-8 mission text (mutually exclusive with --mission)')
     .option('--identity <name>', 'ours identity to bind (default: role name)')
@@ -1267,7 +1256,7 @@ program.command('init').description('one-time host setup (units, dirs, linger)')
         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');
+    console.log(INIT_COMPLETION_GUIDANCE);
 });
 const webCommand = cOpt(program.command('web').description('start or open the secure localhost fleet web console'))
     .enablePositionalOptions()

package/dist/config.d.ts

@@ -3,7 +3,7 @@ import type { IsolationConfig, WrapContext } from './isolation/types.js';
 import type { ResolvedWatchdog } from './watchdog/config.js';
 import type { ResolvedLoop, ResolvedRoleLoop } from './loops/config.js';
 export interface OverseeEntry {
-    role: string;
+    agent: string;
     interval: string;
 }
 export interface WorklogPolicy {
@@ -25,7 +25,7 @@ export declare const NOTIFY_EVENT_TYPES: readonly ["message_received", "file_rec
 export type NotifyEventType = (typeof NOTIFY_EVENT_TYPES)[number];
 export type InjectMode = 'notification' | 'full';
 export type MonitorMode = 'fleet' | 'native';
-export type SessionBackendId = 'tmux' | 'acp';
+export type SessionBackendId = 'acp';
 /** Public, harness-neutral permission policy. */
 export type FleetPermissionMode = 'ask' | 'auto' | 'allow';
 /** `deny` is a deprecated, fail-closed compatibility alias retained for old fleet files. */
@@ -44,9 +44,6 @@ export interface SessionOptions {
         /** ACP agent command and arguments. Defaults are supplied by the harness adapter. */
         command?: string | string[];
     };
-    tmux?: {
-        boot_grace_ms?: number;
-    };
 }
 /** Resolved per-role supervisor-monitor config. */
 export interface MonitorConfig {
@@ -126,6 +123,8 @@ export interface RoleConfig {
     briefing_file?: string;
     /** Explicit null means use the selected harness's own default, bypassing fleet defaults. */
     model?: string | null;
+    /** Neutral Brain reasoning effort, retained for inspection after adapter translation. */
+    effort?: string;
     model_chain?: string[];
     max_tokens?: number;
     autocompact_pct?: number;
@@ -169,14 +168,37 @@ export interface ResolvedRole extends Omit<RoleConfig, 'model' | 'owner_channel'
     worklog?: WorklogPolicy;
     auth_proxy?: AuthProxyConfig;
     loops?: ResolvedRoleLoop[];
+    provenance?: Record<string, FieldProvenance>;
     /** Internal/transient: never accepted as a user-authored RoleConfig key. */
     roomMemberStartup?: RoomMemberStartup;
 }
+export interface FieldProvenance {
+    sourceFile: string;
+    sourcePointer: string;
+    sourceKind: 'Agent' | 'Role' | 'Brain' | 'Manifest' | 'built-in';
+    sourceId?: string;
+    origin: 'explicit' | 'typed-default' | 'built-in';
+    viaReference?: {
+        sourcePointer: string;
+        kind: 'Role' | 'Brain';
+        id: string;
+    };
+    transforms: Array<{
+        kind: 'substitution' | 'adapter-normalization' | 'validation-default';
+        detail: string;
+    }>;
+}
 export interface FleetConfig {
     roles: ResolvedRole[];
     vars: Record<string, string>;
     defaults: Record<string, unknown>;
     files: string[];
+    configMode?: 'split-v2';
+    sourceDocuments?: Array<{
+        kind: 'Manifest' | 'Agent' | 'Role' | 'Brain';
+        id?: string;
+        path: string;
+    }>;
     /** Fleet-wide delay (ms) enforced between agent launches to avoid boot bursts (0 = none). */
     startStaggerMs: number;
     /** Warning-first non-plain YAML migration diagnostics, in source order. */
@@ -207,7 +229,8 @@ export declare function resolveRoleModel(model: string | null | undefined, harne
  */
 export declare function isolationContextFor(role: ResolvedRole): WrapContext;
 export declare const ROLE_NAME_RE: RegExp;
-/** Load ~/fleet.yaml (or an explicit path) merged with ~/fleet.d/*.yaml drop-ins. */
+export declare function splitRootFor(base: string): string;
+/** Load a v2 manifest and bare Agent/Role/Brain documents from its stem directory. */
 export declare function loadConfig(configPath?: string, options?: {
     yamlMode?: YamlMode;
 }): FleetConfig;