@ours.network/fleet 0.15.1 → 0.15.4

package/dist/permissions.d.ts

@@ -62,6 +62,11 @@ export interface PermissionConflict {
     /** The role-named line commands print. */
     warning: string;
 }
+/** Resolve the effective portable policy after harness-native overrides win. */
+export declare function effectivePermissionMode(role: ResolvedRole): {
+    fleetMode: import('./config.js').FleetPermissionMode;
+    nativeMode: string;
+};
 /** Resolve one role's permissions through its adapter. Never throws. */
 export declare function analyzeRolePermissions(role: ResolvedRole): RolePermissionAnalysis;
 /** Every line a command should show for a role: translation, conflicts, floor. */

package/dist/permissions.js

@@ -23,6 +23,13 @@ export function checkUnattendedFloor(granted, required = UNATTENDED_FLOOR) {
     const missing = required.filter(c => !granted.includes(c));
     return { meets: missing.length === 0, missing };
 }
+/** Resolve the effective portable policy after harness-native overrides win. */
+export function effectivePermissionMode(role) {
+    const adapter = getAdapter(role.harness);
+    if (!adapter.effectivePermissionMode)
+        throw new Error(`harness '${role.harness}' cannot report an effective ask|auto|allow permission mode`);
+    return adapter.effectivePermissionMode(role);
+}
 /**
  * Find native settings that contradict the neutral block. Only fires when the
  * operator wrote BOTH — a role that states its intent once, neutrally or

package/dist/runner.d.ts

@@ -27,6 +27,8 @@ export interface RunnerDeps {
     /** Lets a test (or a shutdown path) end the supervised restart loop. */
     shouldStop?(): boolean;
 }
+/** Environment injected only into the managed harness process. */
+export declare function managedFleetProxyEnv(role: ResolvedRole, stateDir: string): Record<string, string>;
 /**
  * Record who owns wake delivery for this run. Returning true means a fleet
  * monitor is taking ownership back from a native harness and must start at the

package/dist/runner.js

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync } from 'node:fs';
+import { existsSync, readFileSync, writeFileSync, rmSync, mkdirSync, realpathSync } from 'node:fs';
 import { join } from 'node:path';
 import { randomUUID } from 'node:crypto';
 import { parse } from 'yaml';
@@ -22,6 +22,8 @@ import { OwnerChannel } from './owner-channel/channel.js';
 import { acquireOwnerBinderLease, OwnerBinderHandoffTimeoutError, } from './owner-channel/binder.js';
 import { RoleTurnArbiter } from './session/arbiter.js';
 import { ScheduledLoopManager, } from './loops/manager.js';
+import { FLEET_PROXY_CALLER_ENV, FLEET_PROXY_STATE_DIR_ENV, inheritCallerSpawnDefaults, } from './fleet-proxy.js';
+import { effectivePermissionMode } from './permissions.js';
 const defaultDeps = () => ({
     tmux: new Tmux(),
     exec: realExec,
@@ -54,6 +56,60 @@ const defaultDeps = () => ({
     },
 });
 const MONITOR_OWNER_FILE = '.monitor-owner';
+/** Environment injected only into the managed harness process. */
+export function managedFleetProxyEnv(role, stateDir) {
+    return {
+        ...(role.env ?? {}),
+        [FLEET_PROXY_STATE_DIR_ENV]: stateDir,
+        [FLEET_PROXY_CALLER_ENV]: role.name,
+    };
+}
+/**
+ * Execute a typed proxy request in the caller's supervisor. Dynamic imports
+ * avoid a runner↔spawn initialization cycle (spawn imports runner constants).
+ */
+async function executeManagedSpawn(caller, configPath, requested, log) {
+    const { options, inherited } = inheritCallerSpawnDefaults(caller, requested, configPath);
+    const creationActionId = randomUUID();
+    options.creationActionId = creationActionId;
+    const spawnModule = await import('./spawn.js');
+    const preview = spawnModule.spawnDryRun(options).resolvedRole;
+    const runtimeBinPath = (() => {
+        try {
+            return realpathSync(process.argv[1]);
+        }
+        catch {
+            return process.argv[1];
+        }
+    })();
+    let statePath;
+    if (options.temp) {
+        statePath = await spawnModule.spawnTemp(options, runtimeBinPath);
+    }
+    else {
+        const { pickBackend } = await import('./supervisor/index.js');
+        const { WatchdogServiceManager } = await import('./watchdog/service.js');
+        statePath = await spawnModule.spawnPermanent(options, {
+            backend: pickBackend(), binPath: runtimeBinPath, log,
+            watchdogService: new WatchdogServiceManager(),
+        });
+    }
+    const result = {
+        caller: caller.name,
+        role: options.name,
+        lifetime: options.temp ? 'temporary' : 'permanent',
+        statePath,
+        harness: preview.harness,
+        session: preview.session,
+        ...(preview.model ? { model: preview.model } : {}),
+        monitor: { mode: preview.monitor.mode, interrupt: preview.monitor.interrupt },
+        inherited,
+        creationActionId,
+    };
+    log(`[${caller.name}] managed fleet proxy spawned ${result.lifetime} role ${result.role} `
+        + `harness=${result.harness} session=${result.session}`);
+    return result;
+}
 /**
  * Record who owns wake delivery for this run. Returning true means a fleet
  * monitor is taking ownership back from a native harness and must start at the
@@ -435,6 +491,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     let acpStartupComplete = false;
     let ownerChannel;
     let ownerBinder;
+    const pendingFleetSpawnNotices = [];
     let loopManager;
     let arbiter;
     let reloadLoopConfig;
@@ -453,11 +510,12 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             name,
             argv: wrappedArgv,
             cwd: runCwd,
-            env: { ...launch.env, ...(role.env ?? {}) },
+            env: { ...launch.env, ...managedFleetProxyEnv(role, dir) },
             stateDir: dir,
             mode,
             permissions: perms,
             modeId: adapter.acpPermissionModeId?.(role),
+            permissionMode: effectivePermissionMode(role),
             log: deps.log,
         });
         pid = acpSession.pid;
@@ -501,6 +559,23 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             unsubscribeRecovery?.();
             throw error;
         }
+        control.setFleetSpawner(async (requested) => {
+            const event = await executeManagedSpawn(role, configPath, requested, deps.log);
+            if (!role.owner_channel)
+                return event;
+            if (ownerChannel?.notifyFleetSpawn) {
+                try {
+                    await ownerChannel.notifyFleetSpawn(event);
+                }
+                catch (error) {
+                    deps.log(`[${name}] spawned-agent owner notice failed: `
+                        + `${error?.message ?? String(error)}`);
+                }
+            }
+            else
+                pendingFleetSpawnNotices.push(event);
+            return event;
+        });
         resolvedMonitorDeps.delivery = {
             // A wake is only delivered when its turn TERMINATES successfully. A
             // refusal or a cancellation reached the agent and was not acted on, so
@@ -589,6 +664,15 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 throw new Error(`[${name}] owner channel failed to start: `
                     + `${error?.message ?? String(error)}`);
             }
+            for (const event of pendingFleetSpawnNotices.splice(0)) {
+                try {
+                    await ownerChannel.notifyFleetSpawn?.(event);
+                }
+                catch (error) {
+                    deps.log(`[${name}] deferred spawned-agent owner notice failed: `
+                        + `${error?.message ?? String(error)}`);
+                }
+            }
         }
         if (ownerChannel)
             control.setOwnerChannel(ownerChannel);

package/dist/session/acp.d.ts

@@ -1,5 +1,11 @@
+import * as acp from '@agentclientprotocol/sdk';
 import type { CommonPermissions } from '../config.js';
-import type { ExitRecord, QueuedPrompt, SessionEvent, SessionHandle, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnOutcome, TurnResult } from './types.js';
+import { ConversationEventStore } from './conversation-store.js';
+import type { ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
+import type { ConversationHandlePage, ExitRecord, QueuedPrompt, SessionEvent, RuntimeSelectorMetadata, SessionHandle, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnOutcome, TurnResult } from './types.js';
+/** Server-generated typed provenance followed by the exact human-authored body. */
+export declare function promptContentBlocks(text: string, origin?: PromptOrigin): acp.ContentBlock[];
+export declare function runtimeSelector(options: acp.SessionConfigOption[] | null | undefined, category: string): RuntimeSelectorMetadata | undefined;
 export interface AcpSessionOptions {
     name: string;
     argv: string[];
@@ -10,9 +16,15 @@ export interface AcpSessionOptions {
     permissions: CommonPermissions;
     /** Native permission-mode id to request via session/set_mode; undefined keeps the agent default. */
     modeId?: string;
+    /** Adapter-resolved live permission policy; separate from ACP agent-specific session modes. */
+    permissionMode?: NonNullable<SessionSnapshot['permissionMode']>;
     log(line: string): void;
     /** Test seam for the cancel-escalation grace period; production uses the default. */
     cancelGraceMs?: number;
+    /** How long a pending permission may wait for a human before it expires. */
+    permissionTimeoutMs?: number;
+    /** Grace after the last controller detaches before the unattended policy applies. */
+    controllerGraceMs?: number;
 }
 /**
  * Classify an ACP `stopReason` into a terminal outcome. A refusal and a
@@ -30,6 +42,11 @@ export declare class AcpSession implements SessionHandle {
     readonly pid: number;
     private readonly child;
     private readonly events;
+    private readonly conversation;
+    /** New on every runner start; permission/turn IDs from prior generations are stale. */
+    private readonly sessionGeneration;
+    /** True while `session/load` replays history as ordinary updates. */
+    private replaying;
     private readonly sessionFile;
     private readonly pendingPermissions;
     private connection;
@@ -41,11 +58,22 @@ export declare class AcpSession implements SessionHandle {
     private exit;
     private steeringSupported;
     private capabilities?;
+    private runtimeModel?;
+    private reasoningEffort?;
     private controllerCount;
+    /** Armed when the last controller detaches; unattended policy applies on fire. */
+    private controllerGrace?;
     private cancelEscalation?;
     private activeTurn?;
     private constructor();
     static start(options: AcpSessionOptions): Promise<AcpSession>;
+    /**
+     * Honest restart recovery (spec §5.3): a prompt that was admitted but never
+     * started is safe to dispatch again; a turn that had already started may
+     * have caused side effects, so it is closed as `unknown_after_restart` —
+     * never silently replayed.
+     */
+    private recoverOpenPrompts;
     isAlive(): boolean;
     snapshot(): SessionSnapshot;
     /**
@@ -54,16 +82,40 @@ export declare class AcpSession implements SessionHandle {
      * for it is what turned a busy agent into a timeout and then into "dead".
      */
     queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
+    /**
+     * Durably record a prompt admission BEFORE acceptance is returned. Browser
+     * admissions are transactional — a prompt the ledger cannot hold is refused,
+     * because an acknowledged-then-lost prompt is worse than an error. Every
+     * other source degrades to best-effort so the agent keeps working (§5.3).
+     */
+    private admitToLedger;
+    /** Idempotent browser prompt admission (control v3 `submit_prompt_v2`). */
+    submitPromptBrowser(command: SubmitPromptCommand): Promise<PromptReceipt>;
     submitPrompt(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
     interrupt(source?: TurnCancellationSource): Promise<void>;
     private cancelActive;
     respondPermission(permissionId: string, optionId: string): boolean;
+    /**
+     * A v2 decision binds to the session generation it was shown under. A stale
+     * generation, an already-settled request, or an unknown option are all the
+     * same answer: someone else's decision (or a restart) got there first.
+     */
+    respondPermissionV2(permissionId: string, optionId: string, sessionGeneration: string): 'accepted' | 'stale';
     eventsSince(seq: number): SessionEvent[];
     subscribe(listener: (event: SessionEvent) => void): () => void;
     setControllerAttached(attached: boolean): void;
+    private armControllerGrace;
+    /**
+     * Settle one pending request without a human decision — unattended policy,
+     * expiry, or cancellation — and leave the same durable evidence a manual
+     * decision would. A denial selects the agent's own one-shot reject option;
+     * everything else resolves as cancelled toward the agent.
+     */
+    private settlePendingAutomatically;
     exitResult(): ExitRecord | null;
     close(): Promise<void>;
     private initialize;
+    private captureRuntimeMetadata;
     private runPrompt;
     private steerPrompt;
     private requestPermission;
@@ -75,5 +127,13 @@ export declare class AcpSession implements SessionHandle {
     private settleAutomatically;
     private withinAutomaticBoundary;
     private recordUpdate;
+    /** Normalize every ACP update losslessly into the durable ledger. */
+    private recordConversationUpdate;
+    conversationPage(request?: {
+        after?: string;
+        limit?: number;
+    }): ConversationHandlePage;
+    conversationSnapshot(): ConversationSnapshot;
+    subscribeConversation(listener: Parameters<ConversationEventStore['subscribe']>[0]): () => void;
     private fail;
 }