@ours.network/fleet 1.2.0-nightly.7 → 1.2.0-nightly.70

package/dist/application/preset-provenance.d.ts

@@ -0,0 +1,19 @@
+export declare const PROVENANCE_KINDS: {
+    readonly role: "roles";
+    readonly brain: "brains";
+    readonly template: "agent_templates";
+    readonly layout: "room_layouts";
+};
+export type ProvenanceKind = keyof typeof PROVENANCE_KINDS;
+export type ProvenanceStatus = 'predefined' | 'changed' | 'custom';
+export interface ProvenanceEntry {
+    status: ProvenanceStatus;
+    preset?: string;
+}
+export type Provenance = Record<ProvenanceKind, Record<string, ProvenanceEntry>>;
+export declare class PresetProvenance {
+    private configPath?;
+    private presetRoot;
+    constructor(configPath?: string | undefined, presetRoot?: string);
+    read(): Provenance;
+}

package/dist/application/preset-provenance.js

@@ -0,0 +1,59 @@
+/** Where each configured definition came from, compared with the packaged presets.
+ * A definition is `predefined` when it has the same value as the shipped preset of
+ * the same name, `changed` when a preset of that name exists but the value differs,
+ * and `custom` otherwise. Values are compared after parsing, so the formatting the
+ * configuration editor writes does not count as a change. Preset text is returned
+ * so users can see exactly what ships; it contains no host data.
+ */
+import { isDeepStrictEqual } from 'node:util';
+import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+import { parse } from 'yaml';
+import { defaultConfigPath } from '../paths.js';
+import { splitRootFor } from '../config.js';
+import { packagedPresetRoot } from '../preset-bootstrap.js';
+export const PROVENANCE_KINDS = { role: 'roles', brain: 'brains', template: 'agent_templates', layout: 'room_layouts' };
+const MAX_BYTES = 256 * 1024;
+/** Regular, bounded YAML files of one directory, by definition name. Anything else is skipped. */
+function yamlFiles(dir) {
+    const files = new Map();
+    if (!existsSync(dir) || !lstatSync(dir).isDirectory())
+        return files;
+    for (const file of readdirSync(dir).sort()) {
+        if (!/\.ya?ml$/.test(file))
+            continue;
+        const path = join(dir, file), stat = lstatSync(path);
+        if (!stat.isFile() || stat.size > MAX_BYTES)
+            continue;
+        files.set(basename(file, extname(file)), readFileSync(path, 'utf8'));
+    }
+    return files;
+}
+const parsed = (text) => { try {
+    return parse(text);
+}
+catch {
+    return Symbol('unparseable');
+} };
+export class PresetProvenance {
+    configPath;
+    presetRoot;
+    constructor(configPath, presetRoot = join(packagedPresetRoot(), 'fleet')) {
+        this.configPath = configPath;
+        this.presetRoot = presetRoot;
+    }
+    read() {
+        const split = splitRootFor(this.configPath ?? defaultConfigPath());
+        const result = {};
+        for (const [kind, dir] of Object.entries(PROVENANCE_KINDS)) {
+            const presets = yamlFiles(join(this.presetRoot, dir)), installed = yamlFiles(join(split, dir));
+            result[kind] = Object.fromEntries([...installed].map(([name, text]) => {
+                const preset = presets.get(name);
+                if (preset === undefined)
+                    return [name, { status: 'custom' }];
+                return [name, { status: isDeepStrictEqual(parsed(text), parsed(preset)) ? 'predefined' : 'changed', preset }];
+            }));
+        }
+        return result;
+    }
+}

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

@@ -59,7 +59,8 @@ export class RoleCreationService {
     }
     async createManaged(caller, requested) {
         const plan = this.previewSpawn({ origin: 'managed', caller, options: requested });
-        const creationActionId = randomUUID();
+        const creationActionId = requested.roomMemberStartup?.task_id
+            ? requested.creationActionId ?? randomUUID() : randomUUID();
         plan.options.creationActionId = creationActionId;
         const statePath = await this.launchSync(plan.options);
         const selectionSummary = (kind) => {
@@ -138,7 +139,7 @@ export class RoleCreationService {
             reasoningEffort: resolved.effort,
             cwd, lifetime: request.lifetime,
             permissions: resolvePermissions(defaults.permissions, request.permissions),
-            monitor: resolveMonitorConfig(defaults.monitor, request.monitor),
+            monitor: resolveMonitorConfig(defaults.monitor, request.monitor, { harness: resolved.harness }),
         };
         const warnings = [];
         if (request.permissions.approval === 'allow')

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

@@ -1,9 +1,11 @@
+import { retireNotificationTarget } from '../notifications/target-cleanup.js';
 import { cpSync, existsSync, mkdirSync, readdirSync, renameSync } from 'node:fs';
 import { basename, dirname, join } from 'node:path';
 import { loadConfig, ROLE_NAME_RE } from '../config.js';
 import { agentDir, stateRoot } from '../paths.js';
-import { rmRole } from '../ops.js';
+import { assertStandaloneRoleRemoval, rmRole } from '../ops.js';
 import { FleetError } from './errors.js';
+import { removeReminderState } from '../reminders/store.js';
 import { provesGeneratedAgentSource } from '../generated-agent-source.js';
 export class RoleRemovalService {
     options;
@@ -18,6 +20,12 @@ export class RoleRemovalService {
         if (!ROLE_NAME_RE.test(requested))
             throw new FleetError('invalid_request', 'invalid role name');
         const cfg = loadConfig(this.options.configPath);
+        try {
+            assertStandaloneRoleRemoval(cfg, requested);
+        }
+        catch (error) {
+            throw new FleetError('conflict', error instanceof Error ? error.message : String(error));
+        }
         const names = new Set(cfg.roles.map(role => role.name));
         for (const root of [dirname(agentDir('_')), dirname(agentDir('_', true))]) {
             try {
@@ -76,8 +84,11 @@ export class RoleRemovalService {
         const stamp = new Date().toISOString().replaceAll(/[:.]/g, '-');
         const recoveryPath = join(stateRoot(), 'recovery', 'removed', `${stamp}-${preview.role}`);
         mkdirSync(recoveryPath, { recursive: true, mode: 0o700 });
-        if (existsSync(sourceState))
+        if (existsSync(sourceState)) {
             cpSync(sourceState, join(recoveryPath, 'state'), { recursive: true });
+            // Recovery evidence is not a schedule: a removed agent's reminders end here.
+            removeReminderState(join(recoveryPath, 'state'));
+        }
         if (role && provesGeneratedAgentSource(agentDir(preview.role), cfg.files[0], role.sourceFile)
             && existsSync(role.sourceFile))
             cpSync(role.sourceFile, join(recoveryPath, basename(role.sourceFile)));
@@ -85,8 +96,11 @@ export class RoleRemovalService {
             await rmRole(cfg, preview.role, this.options.ops);
         else {
             await this.options.ops.backend.uninstall(preview.role);
-            if (existsSync(sourceState))
+            if (existsSync(sourceState)) {
                 renameSync(sourceState, join(recoveryPath, 'orphan-state'));
+                removeReminderState(join(recoveryPath, 'orphan-state'));
+            }
+            await retireNotificationTarget(`/fleet/chats/agents/${encodeURIComponent(preview.role)}`).catch(() => { });
             this.options.ops.log(`removed orphaned backend/state '${preview.role}'`);
         }
         return { ...preview, removed: true, recoveryPath };

package/dist/application/role-repository.js

@@ -1,10 +1,25 @@
 import { lstatSync, readFileSync, readdirSync, realpathSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { parse } from 'yaml';
-import { loadConfig, resolveMonitorConfig, resolvePermissions, ROLE_NAME_RE, } from '../config.js';
+import { loadConfig, resolveSnapshotMonitor, resolvePermissions, ROLE_NAME_RE, } from '../config.js';
 import { agentsRoot, tmpRoot } from '../paths.js';
 import { readSpawnLineage } from '../web/topology.js';
 const MAX_SNAPSHOT_BYTES = 256 * 1024;
+function retainedTaskId(dir, name) {
+    try {
+        const path = join(dir, '.temp-supervisor.json');
+        const stat = lstatSync(path);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 16 * 1024)
+            return undefined;
+        const record = JSON.parse(readFileSync(path, 'utf8'));
+        const id = record?.taskOwner?.taskId;
+        return record?.version === 1 && record?.role === name && typeof id === 'string'
+            && /^[0-9a-z]{9}[0-9a-f]{8}$/.test(id) ? id : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function safeDirs(root) {
     try {
         return readdirSync(root, { withFileTypes: true })
@@ -54,7 +69,7 @@ function snapshot(path, name) {
                 session, identity: typeof raw.identity === 'string' ? raw.identity : name,
                 permissions: resolvePermissions(undefined, raw.permissions),
                 permissionsDeclared: raw.permissions !== undefined,
-                monitor: resolveMonitorConfig(undefined, raw.monitor),
+                monitor: resolveSnapshotMonitor(raw.monitor),
                 sourceFile: '(temp)',
             },
         };
@@ -128,10 +143,12 @@ export class RoleRepository {
             const stateRef = inTemporary ? { lifetime: 'temporary' }
                 : inPermanent ? { lifetime: 'permanent' } : undefined;
             const tempStateDir = inTemporary ? join(temporaryRoot, name) : undefined;
+            const taskId = !config && tempStateDir ? retainedTaskId(tempStateDir, name) : undefined;
             return {
                 id: name,
                 lifetime: config ? 'permanent' : inTemporary ? 'temporary' : 'orphan',
                 configured: Boolean(config),
+                ...(taskId ? { taskId } : {}),
                 config: config ? view(config) : tempRole ? view(tempRole) : undefined,
                 stateRef,
                 stateHealth,

package/dist/application/room-layout-definitions.d.ts

@@ -0,0 +1,45 @@
+import { loadConfig } from '../config.js';
+import { type RoomLayoutDefinition } from '../rooms-tasks/layout-config.js';
+export declare const ABSENT_REVISION = "absent";
+export type LayoutDefinitionBody = Omit<RoomLayoutDefinition, 'sourceFile'>;
+export type LayoutListEntry = {
+    name: string;
+    revision: string;
+    file: string;
+    definition: LayoutDefinitionBody;
+    issues: string[];
+    definition_hash: string;
+} | {
+    name: string;
+    revision: string;
+    file: string;
+    error: string;
+};
+export declare class RoomLayoutDefinitions {
+    private configPath?;
+    private deps;
+    constructor(configPath?: string | undefined, deps?: {
+        loadConfiguration?: typeof loadConfig;
+    });
+    private root;
+    private pathFor;
+    private currentRevision;
+    /** Agent-template references that do not resolve in the current Fleet configuration. */
+    private templateIssues;
+    /** The configured default (`rooms.defaults.template`, else `tasks.default_room_template`) when it names a usable layout. */
+    defaultLayout(entries?: LayoutListEntry[]): string | undefined;
+    list(): LayoutListEntry[];
+    validate(raw: unknown): {
+        definition?: LayoutDefinitionBody;
+        issues: string[];
+    };
+    save(name: string, expectedRevision: string, raw: unknown): Promise<{
+        name: string;
+        revision: string;
+        definition: LayoutDefinitionBody;
+    }>;
+    remove(name: string, expectedRevision: string): Promise<{
+        name: string;
+        deleted: boolean;
+    }>;
+}

package/dist/application/room-layout-definitions.js

@@ -0,0 +1,130 @@
+/** Web authoring of `fleet/room_layouts/<name>.yaml`.
+ * Writes are revision-guarded (sha256 of the file bytes) and validated with the
+ * same parser the CLI uses. Retained layout runs keep their own snapshots, so
+ * editing or deleting a definition never changes an existing run.
+ */
+import { createHash } from 'node:crypto';
+import { existsSync, mkdirSync, readFileSync, readdirSync, unlinkSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+import { stringify } from 'yaml';
+import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
+import { parseFleetDocument } from '../config-yaml.js';
+import { defaultConfigPath } from '../paths.js';
+import { loadConfig, splitRootFor } from '../config.js';
+import { assertLayoutFile, validLayoutKey, validateRoomLayout } from '../rooms-tasks/layout-config.js';
+import { FleetError } from './errors.js';
+import { layoutDefinitionHash } from './task-layouts.js';
+export const ABSENT_REVISION = 'absent';
+const revisionOf = (bytes) => createHash('sha256').update(bytes).digest('hex');
+export class RoomLayoutDefinitions {
+    configPath;
+    deps;
+    constructor(configPath, deps = {}) {
+        this.configPath = configPath;
+        this.deps = deps;
+    }
+    root() { return join(splitRootFor(this.configPath ?? defaultConfigPath()), 'room_layouts'); }
+    pathFor(name) {
+        if (!validLayoutKey(name))
+            throw new FleetError('invalid_request', 'layout name must start with a letter and use letters, digits, - or _');
+        return join(this.root(), `${name}.yaml`);
+    }
+    currentRevision(path) {
+        if (!existsSync(path))
+            return ABSENT_REVISION;
+        assertLayoutFile(path);
+        return revisionOf(readFileSync(path));
+    }
+    /** Agent-template references that do not resolve in the current Fleet configuration. */
+    templateIssues(definition) {
+        let templates = {};
+        try {
+            templates = (this.deps.loadConfiguration ?? loadConfig)(this.configPath).agentTemplates ?? {};
+        }
+        catch (error) {
+            return [`fleet configuration unavailable: ${error.message}`];
+        }
+        return Object.entries(definition.participants).flatMap(([key, participant]) => participant.agent_template && !Object.hasOwn(templates, participant.agent_template)
+            ? [`participant ${key}: agent template not found: ${participant.agent_template}`] : []);
+    }
+    /** The configured default (`rooms.defaults.template`, else `tasks.default_room_template`) when it names a usable layout. */
+    defaultLayout(entries = this.list()) {
+        let name;
+        try {
+            const config = (this.deps.loadConfiguration ?? loadConfig)(this.configPath);
+            name = config.rooms?.defaults?.template ?? config.tasks?.default_room_template;
+        }
+        catch {
+            return undefined;
+        }
+        const entry = entries.find(e => e.name === name);
+        return entry && !('error' in entry) && !entry.issues.length ? entry.name : undefined;
+    }
+    list() {
+        const root = this.root();
+        if (!existsSync(root))
+            return [];
+        assertLayoutFile(root, true);
+        return readdirSync(root).filter(file => /\.ya?ml$/.test(file)).sort().map(file => {
+            const name = basename(file, extname(file)), path = join(root, file);
+            try {
+                if (!validLayoutKey(name))
+                    throw Error(`invalid room layout id: ${name}`);
+                assertLayoutFile(path);
+                const bytes = readFileSync(path);
+                const definition = validateRoomLayout(parseFleetDocument(path, bytes.toString('utf8'), 'strict').value, file);
+                return { name, file, revision: revisionOf(bytes), definition, issues: this.templateIssues(definition), definition_hash: layoutDefinitionHash(definition) };
+            }
+            catch (error) {
+                // Only a trusted regular file may be read to offer an overwrite revision.
+                let revision = ABSENT_REVISION;
+                try {
+                    assertLayoutFile(path);
+                    revision = revisionOf(readFileSync(path));
+                }
+                catch { /* not trusted: never read */ }
+                return { name, file, revision, error: error.message };
+            }
+        });
+    }
+    validate(raw) {
+        let definition;
+        try {
+            definition = validateRoomLayout(raw, 'room layout');
+        }
+        catch (error) {
+            return { issues: [error.message] };
+        }
+        return { definition, issues: this.templateIssues(definition) };
+    }
+    async save(name, expectedRevision, raw) {
+        const path = this.pathFor(name);
+        const { definition, issues } = this.validate(raw);
+        if (!definition || issues.length)
+            throw new FleetError('invalid_request', issues.join('; '));
+        const root = this.root();
+        mkdirSync(root, { recursive: true, mode: 0o700 });
+        assertLayoutFile(root, true);
+        return withFileLock(`${path}.lock`, async () => {
+            const current = this.currentRevision(path);
+            if (current !== expectedRevision)
+                throw new FleetError('stale_state', 'room layout changed since it was loaded; reload before saving');
+            const { description, participants, rooms } = definition;
+            const text = stringify({ version: 1, ...(description ? { description } : {}), participants, rooms });
+            replaceFileAtomically(path, text, 0o600);
+            return { name, revision: revisionOf(text), definition };
+        });
+    }
+    async remove(name, expectedRevision) {
+        const path = this.pathFor(name);
+        return withFileLock(`${path}.lock`, async () => {
+            const current = this.currentRevision(path);
+            if (current === ABSENT_REVISION)
+                return { name, deleted: false };
+            if (current !== expectedRevision)
+                throw new FleetError('stale_state', 'room layout changed since it was loaded; reload before deleting');
+            unlinkSync(path);
+            return { name, deleted: true };
+        });
+    }
+}

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

@@ -1,6 +1,10 @@
-import { controlRequest } from '../session/control.js';
-import type { ConversationEventV1, ConversationSnapshot, PromptReceipt } from '../session/conversation-types.js';
+import type { ConversationRoleObservation, ConversationRoleState, ObserveConversationRole } from './conversation-role-observer.js';
+import { type ConversationTailPage } from './conversation-history.js';
+import type { AgentHistoryQuery } from '../agent-ours/correspondence.js';
+import { controlRequest, followConversation } from '../session/control.js';
+import type { ConversationEventV1, ConversationSnapshot, ConversationObservationState, PromptReceipt } from '../session/conversation-types.js';
 import type { SessionSnapshot } from '../session/types.js';
+import type { PassiveConversationFollowRequest, ConversationReplayPage, ConversationReplayReady } from '../session/conversation-replay.js';
 import type { OutputPage, SendReceipt, SessionDescriptor } from './types.js';
 export interface ConversationPageView {
     events: ConversationEventV1[];
@@ -12,6 +16,23 @@ export interface ConversationPageView {
 export interface ConversationFollowHandle {
     close(): void;
 }
+export interface LegacyConversationFollowRequest {
+    after?: string;
+    onPage(page: ConversationPageView): void;
+    onEvent(event: ConversationEventV1): void;
+    onClose(reason?: string): void;
+}
+export interface PassiveConversationFollow extends PassiveConversationFollowRequest {
+    /** Reports role updates from the owned or borrowed observer; never attaches a controller. */
+    onRole?(state: ConversationRoleState): void;
+    /** Application-only borrowed owner; never sent over the private wire. */
+    roleObservation?: ConversationRoleObservation;
+    onReplay(page: ConversationReplayPage): void;
+    onReady(ready: ConversationReplayReady): void;
+    onEvent(event: ConversationEventV1): void;
+    onState(state: ConversationObservationState): void;
+    onClose(reason?: string): void;
+}
 /**
  * An interrupt that reached the session. `state` says whether the turn stopped
  * cooperatively or through bounded forced recovery — both are accepted, so no
@@ -23,7 +44,11 @@ export interface InterruptReceipt {
     reasonCode?: string;
 }
 export interface RoleSessionControl {
-    describe(): Promise<SessionDescriptor>;
+    /** Standalone owner for role-only observation; dispose with that connection. */
+    observeRole?: ObserveConversationRole;
+    agentContacts?(): Promise<unknown>;
+    agentHistory?(request: AgentHistoryQuery): Promise<unknown>;
+    describe(roleObservation?: ConversationRoleObservation): Promise<SessionDescriptor>;
     snapshot(): Promise<SessionSnapshot>;
     recentOutput(request?: {
         since?: number;
@@ -41,12 +66,24 @@ export interface RoleSessionControl {
         after?: string;
         limit?: number;
     }): Promise<ConversationPageView>;
+    /** The newest visible events (or those before `before`), read backwards from the ledger. */
+    conversationTail?(request: {
+        before?: string;
+        limit?: number;
+    }): Promise<ConversationTailPage>;
     submitPromptV2?(request: {
         commandId: string;
         text: string;
         actorBrowserSession: string;
+        expectedSessionGeneration?: string;
+        requireIdle?: boolean;
         source: 'owner_admin_console';
     }): Promise<PromptReceipt>;
+    interruptPromptV2?(request: {
+        commandId: string;
+        expectedSessionGeneration: string;
+        promptId: string;
+    }): Promise<InterruptReceipt>;
     interruptV2?(commandId: string): Promise<InterruptReceipt & {
         commandId: string;
     }>;
@@ -64,18 +101,19 @@ export interface RoleSessionControl {
      * replay page; `onEvent` every subsequent durable event; `onClose` fires
      * exactly once when the underlying control stream ends.
      */
-    followConversation?(request: {
-        after?: string;
-        onPage(page: ConversationPageView): void;
-        onEvent(event: ConversationEventV1): void;
-        onClose(reason?: string): void;
-    }): Promise<ConversationFollowHandle>;
+    followConversation?(request: LegacyConversationFollowRequest | PassiveConversationFollow): Promise<ConversationFollowHandle>;
 }
 export declare class RoleSessionControlAdapter implements RoleSessionControl {
     private readonly stateDir;
     private readonly request;
-    constructor(stateDir: string, request?: typeof controlRequest);
-    describe(): Promise<SessionDescriptor>;
+    private readonly openFollow;
+    readonly observeRole?: ObserveConversationRole | undefined;
+    private controlHealthy;
+    constructor(stateDir: string, request?: typeof controlRequest, openFollow?: typeof followConversation, observeRole?: ObserveConversationRole | undefined);
+    agentContacts(): Promise<unknown>;
+    agentHistory(request: AgentHistoryQuery): Promise<unknown>;
+    private requireCorrespondence;
+    describe(roleObservation?: ConversationRoleObservation): Promise<SessionDescriptor>;
     snapshot(): Promise<SessionSnapshot>;
     recentOutput(request?: {
         since?: number;
@@ -87,12 +125,23 @@ export declare class RoleSessionControlAdapter implements RoleSessionControl {
         after?: string;
         limit?: number;
     }): Promise<ConversationPageView>;
+    conversationTail(request?: {
+        before?: string;
+        limit?: number;
+    }): Promise<ConversationTailPage>;
     submitPromptV2(request: {
         commandId: string;
         text: string;
         actorBrowserSession: string;
+        expectedSessionGeneration?: string;
+        requireIdle?: boolean;
         source: 'owner_admin_console';
     }): Promise<PromptReceipt>;
+    interruptPromptV2(request: {
+        commandId: string;
+        expectedSessionGeneration: string;
+        promptId: string;
+    }): Promise<InterruptReceipt>;
     interruptV2(commandId: string): Promise<InterruptReceipt & {
         commandId: string;
     }>;
@@ -105,12 +154,7 @@ export declare class RoleSessionControlAdapter implements RoleSessionControl {
         accepted: true;
         commandId: string;
     }>;
-    followConversation(request: {
-        after?: string;
-        onPage(page: ConversationPageView): void;
-        onEvent(event: ConversationEventV1): void;
-        onClose(reason?: string): void;
-    }): Promise<ConversationFollowHandle>;
+    followConversation(request: LegacyConversationFollowRequest | PassiveConversationFollow): Promise<ConversationFollowHandle>;
     respondPermission(request: {
         permissionId: string;
         optionId: string;