@ours.network/fleet 1.2.0-nightly.8 → 1.2.0-nightly.80

package/dist/application/codex-models.js

@@ -0,0 +1,56 @@
+import { statSync } from 'node:fs';
+import { join } from 'node:path';
+import { resolveBundledAcpAgent } from '../harness/acp-agent.js';
+import { probeCodexRuntime } from '../harness/codex-runtime.js';
+import { codexOfferedModels, profileEnv } from '../subscriptions/cli.js';
+import { profileHome, readSubscriptionState } from '../subscriptions/store.js';
+const KNOWN_FOR_MS = 5 * 60_000;
+const UNKNOWN_FOR_MS = 10_000;
+/** When the profile's sign-in last changed; a new sign-in must not reuse another account's answer. */
+function signInStamp(home) {
+    try {
+        return statSync(join(home, 'auth.json')).mtimeMs;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * The models offered to the active Codex account by the runtime that sessions will actually use.
+ * An answer is reused only for the same executable, version, profile and sign-in.
+ */
+export function createCodexModelDiscovery(overrides = {}) {
+    const deps = {
+        runtime: () => probeCodexRuntime(resolveBundledAcpAgent('@agentclientprotocol/codex-acp', 'codex-acp', 'codex-acp'), process.env),
+        ask: codexOfferedModels,
+        now: Date.now,
+        ...overrides,
+    };
+    let cached;
+    let pending;
+    return async () => {
+        let key, executable, env;
+        try {
+            const profileId = readSubscriptionState().providers.codex.activeProfileId;
+            const profile = profileHome('codex', profileId);
+            const runtime = await deps.runtime();
+            executable = runtime.executable;
+            env = profileEnv('CODEX_HOME', profileId, profile);
+            key = [runtime.executable, runtime.version, profileId, signInStamp(profile)].join('\n');
+        }
+        catch (error) {
+            return { state: 'unknown', reason: error instanceof Error ? error.message : String(error) };
+        }
+        if (cached && cached.key === key && cached.until > deps.now())
+            return cached.value;
+        if (pending?.key === key)
+            return pending.answer;
+        const answer = deps.ask(executable, env).then(value => {
+            cached = { key, until: deps.now() + (value.state === 'known' ? KNOWN_FOR_MS : UNKNOWN_FOR_MS), value };
+            return value;
+        }).finally(() => { if (pending?.key === key)
+            pending = undefined; });
+        pending = { key, answer };
+        return answer;
+    };
+}

package/dist/application/conversation-history.d.ts

@@ -0,0 +1,34 @@
+import type { ConversationEventV1 } from '../session/conversation-types.js';
+import type { ConversationPageView } from './session-control.js';
+/** Whether a ledger event belongs in the conversation: the live generation, or history of the resumed ACP session. */
+export declare function conversationEventVisible(event: ConversationEventV1, sessionGeneration: string, resumedSessionId?: string): boolean;
+export interface ConversationTailPage extends ConversationPageView {
+    /** Pass as `before` to read the next older page. */
+    olderCursor?: string;
+    hasOlder: boolean;
+    /** Latest page only: older events the view still needs, the current session's latest capabilities and still-pending permission requests. */
+    context: ConversationEventV1[];
+}
+/**
+ * The newest `limit` visible events before `before` (or the newest overall),
+ * read backwards from the ledger so opening a long session costs one page.
+ * `nextCursor` is the newest ledger position seen, for forward `after` paging.
+ */
+export declare function conversationTailPage(stateDir: string, request: {
+    before?: string;
+    limit?: number;
+}, snapshot: ConversationPageView['snapshot'], resumedSessionId?: string, signal?: AbortSignal): Promise<ConversationTailPage>;
+/** Read the existing ACP session ledger without opening its writer/recovery store. */
+export declare function resumedConversationPage(stateDir: string, request: {
+    after?: string;
+    limit?: number;
+}, live: ConversationPageView, expectedSessionId: string): Promise<ConversationPageView>;
+/** Download authorization requires an actual published attachment, never an orphan copy. */
+export declare function conversationHasAttachment(stateDir: string, attachment: import('../file-delivery/types.js').DeliveredFile): Promise<boolean>;
+/** Passive, bounded last assistant text for directory previews. Never opens the
+ * ledger writer/recovery path or acquires a session/controller. An incomplete
+ * newest append is not committed yet; completed malformed records still fail. */
+export declare function conversationPreview(stateDir: string, signal: AbortSignal): Promise<{
+    text: string;
+    at: string;
+}>;

package/dist/application/conversation-history.js

@@ -0,0 +1,294 @@
+import { createReadStream } from 'node:fs';
+import { open, readFile, readdir } from 'node:fs/promises';
+import { join } from 'node:path';
+import { createInterface } from 'node:readline';
+const HISTORICAL_KINDS = ['file.attached', 'fleet.task_created', 'prompt.admitted', 'message.chunk', 'message.replace', 'tool.upsert', 'tool.content_chunk', 'turn.completed'];
+/** Whether a ledger event belongs in the conversation: the live generation, or history of the resumed ACP session. */
+export function conversationEventVisible(event, sessionGeneration, resumedSessionId) {
+    return event.source !== 'agent_replay' && (event.sessionGeneration === sessionGeneration || (!!resumedSessionId && HISTORICAL_KINDS.includes(event.kind) && event.acpSessionId === resumedSessionId));
+}
+/** Newest-first lines of a file, read in chunks from its end; `visit` returns false to stop. */
+async function readLinesBackward(path, visit, signal) {
+    signal?.throwIfAborted();
+    const file = await open(path, 'r');
+    try {
+        let position = (await file.stat()).size;
+        let carry = Buffer.alloc(0);
+        while (position > 0) {
+            signal?.throwIfAborted();
+            const size = Math.min(256 * 1024, position);
+            position -= size;
+            const chunk = Buffer.alloc(size);
+            await file.read(chunk, 0, size, position);
+            signal?.throwIfAborted();
+            let buffer = Buffer.concat([chunk, carry]);
+            let end = buffer.length;
+            for (let i = buffer.length - 1; i >= 0; i--) {
+                if (buffer[i] !== 10)
+                    continue;
+                if (end > i + 1 && !visit(buffer.toString('utf8', i + 1, end)))
+                    return false;
+                end = i;
+            }
+            carry = buffer.subarray(0, end);
+        }
+        if (carry.length && !visit(carry.toString('utf8')))
+            return false;
+        return true;
+    }
+    finally {
+        await file.close();
+    }
+}
+/** The last event cursor in a segment, read from its tail; undefined when none is readable. */
+async function lastSeq(path) {
+    let seq;
+    await readLinesBackward(path, line => { try {
+        const value = Number(JSON.parse(line).seq);
+        if (Number.isSafeInteger(value)) {
+            seq = value;
+            return false;
+        }
+    }
+    catch { } return true; });
+    return seq;
+}
+/**
+ * The newest `limit` visible events before `before` (or the newest overall),
+ * read backwards from the ledger so opening a long session costs one page.
+ * `nextCursor` is the newest ledger position seen, for forward `after` paging.
+ */
+export async function conversationTailPage(stateDir, request, snapshot, resumedSessionId, signal) {
+    signal?.throwIfAborted();
+    const before = request.before === undefined ? Infinity : Number(request.before);
+    if (before !== Infinity && (!Number.isSafeInteger(before) || before < 0))
+        throw new Error('before must be a ledger cursor');
+    const limit = Math.min(1000, Math.max(1, Number.isFinite(request.limit) ? Math.floor(request.limit) : 200));
+    let files = [];
+    try {
+        files = (await readdir(join(stateDir, '.conversation'))).filter(n => /^events-\d{6}\.jsonl$/.test(n)).sort().reverse();
+    }
+    catch { }
+    const events = [];
+    let newest;
+    let hasOlder = false;
+    const observation = snapshot;
+    const barrier = observation.ledgerBarrier;
+    // Current supervisors capture these sanitized inventories together with the
+    // ledger barrier. The browser uses them directly, including authoritative
+    // empty arrays. Looking for their old ledger events would scan the entire
+    // generation on every open. Legacy/incomplete snapshots still need context.
+    const complete = !snapshot.observationFailure && Number.isSafeInteger(barrier) && barrier >= 0
+        && Number.isSafeInteger(observation.stateRevision) && observation.stateRevision >= 0;
+    const needsCapabilities = !complete || !Array.isArray(observation.commands);
+    const pending = new Set(complete && Array.isArray(observation.pendingPermissions)
+        && snapshot.pendingPermissionIds.every(id => observation.pendingPermissions.some(permission => permission.permissionId === id))
+        ? [] : snapshot.pendingPermissionIds);
+    let capabilities;
+    const context = [];
+    // Context only accompanies the newest page; older pages stop as soon as they are full.
+    const wantsContext = () => before === Infinity && ((needsCapabilities && !capabilities) || pending.size > 0);
+    const generation = `"sessionGeneration":${JSON.stringify(snapshot.sessionGeneration)}`;
+    for (const file of files) {
+        const more = await readLinesBackward(join(stateDir, '.conversation', file), line => {
+            if (hasOlder) {
+                // The page is full; only the current generation's context kinds matter. Generations are
+                // appended in order, so the first line of an older one ends the search.
+                if (!line.includes(generation))
+                    return !line.includes('"sessionGeneration":') && wantsContext();
+                if (!line.includes('"capabilities.updated"') && !line.includes('"permission.requested"'))
+                    return wantsContext();
+            }
+            let event;
+            try {
+                event = JSON.parse(line);
+            }
+            catch {
+                return true;
+            }
+            const seq = Number(event.seq);
+            if (!Number.isSafeInteger(seq))
+                return true;
+            if (barrier !== undefined && seq > barrier)
+                return true;
+            newest ??= seq;
+            if (seq < before && conversationEventVisible(event, snapshot.sessionGeneration, resumedSessionId)) {
+                const inPage = !hasOlder && events.length < limit;
+                if (event.sessionGeneration === snapshot.sessionGeneration) {
+                    if (event.kind === 'capabilities.updated' && !capabilities) {
+                        capabilities = event;
+                        if (!inPage)
+                            context.push(event);
+                    }
+                    if (event.kind === 'permission.requested' && event.permissionId && pending.delete(event.permissionId) && !inPage)
+                        context.push(event);
+                }
+                if (inPage)
+                    events.push(event);
+                else
+                    hasOlder = true;
+            }
+            return !hasOlder || wantsContext();
+        }, signal);
+        if (!more)
+            break;
+    }
+    events.reverse();
+    context.reverse();
+    return { events, snapshot, hasOlder, context, hasMore: false,
+        ...(events.length ? { olderCursor: String(events[0].seq) } : {}),
+        ...(before === Infinity && (barrier !== undefined || newest !== undefined) ? { nextCursor: String(barrier ?? newest) } : {}) };
+}
+/** Read the existing ACP session ledger without opening its writer/recovery store. */
+export async function resumedConversationPage(stateDir, request, live, expectedSessionId) {
+    let sessionId;
+    let files;
+    try {
+        sessionId = (await readFile(join(stateDir, '.acp-session-id'), 'utf8')).trim();
+        files = (await readdir(join(stateDir, '.conversation'))).filter(n => /^events-\d{6}\.jsonl$/.test(n)).sort();
+    }
+    catch {
+        return live;
+    }
+    if (!sessionId || sessionId !== expectedSessionId || !files.length)
+        return live;
+    const after = Number(request.after ?? 0);
+    if (!Number.isSafeInteger(after) || after < 0)
+        return live;
+    const limit = Math.min(1000, Math.max(1, Number.isFinite(request.limit) ? Math.floor(request.limit) : 200));
+    const events = [];
+    let next = String(after);
+    let first;
+    let hasMore = false;
+    scan: for (const file of files) {
+        // Forward polling asks for the newest few events: skip whole segments that end at or before the cursor.
+        const end = await lastSeq(join(stateDir, '.conversation', file));
+        if (end !== undefined && end <= after)
+            continue;
+        const input = createReadStream(join(stateDir, '.conversation', file), { encoding: 'utf8' });
+        const lines = createInterface({ input, crlfDelay: Infinity });
+        try {
+            for await (const line of lines) {
+                let event;
+                try {
+                    event = JSON.parse(line);
+                }
+                catch {
+                    continue;
+                }
+                const cursor = Number(event.seq);
+                if (!Number.isSafeInteger(cursor) || cursor <= after)
+                    continue;
+                const historical = ['file.attached', 'fleet.task_created', 'prompt.admitted', 'message.chunk', 'message.replace', 'tool.upsert', 'tool.content_chunk', 'turn.completed'].includes(event.kind);
+                const visible = event.source !== 'agent_replay' && (event.sessionGeneration === live.snapshot.sessionGeneration || (historical && event.acpSessionId === sessionId));
+                if (!visible) {
+                    next = String(cursor);
+                    continue;
+                }
+                if (events.length === limit) {
+                    hasMore = true;
+                    break scan;
+                }
+                first ??= String(cursor);
+                events.push(event);
+                next = String(cursor);
+            }
+        }
+        finally {
+            lines.close();
+            input.destroy();
+        }
+    }
+    // If a fresh/resumed session changed during the read, use the live page only.
+    if ((await readFile(join(stateDir, '.acp-session-id'), 'utf8')).trim() !== sessionId)
+        return live;
+    return { ...live, events, firstAvailableCursor: first, nextCursor: next, hasMore };
+}
+/** Download authorization requires an actual published attachment, never an orphan copy. */
+export async function conversationHasAttachment(stateDir, attachment) {
+    const dir = join(stateDir, '.conversation');
+    const names = (await readdir(dir)).filter(n => /^events-\d+\.jsonl$/.test(n)).sort().reverse();
+    let found = false;
+    for (const name of names) {
+        await readLinesBackward(join(dir, name), line => {
+            try {
+                const e = JSON.parse(line);
+                const a = e.payload.attachment;
+                if (e.kind === 'file.attached' && e.source === 'agent' && a?.id === attachment.id
+                    && e.sessionGeneration === attachment.sessionGeneration && e.acpSessionId === attachment.acpSessionId
+                    && e.turnId === attachment.turnId && JSON.stringify(a) === JSON.stringify(attachment))
+                    found = true;
+            }
+            catch { /* unreadable lines cannot authorize a download */ }
+            return !found;
+        });
+        if (found)
+            break;
+    }
+    return found;
+}
+/** Passive, bounded last assistant text for directory previews. Never opens the
+ * ledger writer/recovery path or acquires a session/controller. An incomplete
+ * newest append is not committed yet; completed malformed records still fail. */
+export async function conversationPreview(stateDir, signal) {
+    signal.throwIfAborted();
+    const dir = join(stateDir, '.conversation');
+    let files;
+    try {
+        files = (await readdir(dir)).filter(name => /^events-\d{6}\.jsonl$/.test(name)).sort().reverse();
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return { text: 'No recent agent output', at: '' };
+        throw error;
+    }
+    const events = [];
+    for (const name of files) {
+        signal.throwIfAborted();
+        const file = await open(join(dir, name), 'r');
+        try {
+            const size = (await file.stat()).size, length = Math.min(size, 2 * 1024 * 1024), buffer = Buffer.alloc(length);
+            await file.read(buffer, 0, length, size - length);
+            const completeEnd = buffer.lastIndexOf(10) + 1;
+            // Only the newest segment can have an in-flight append. If its tail
+            // fills the bounded window, we cannot establish the previous preview.
+            if (completeEnd < length && (name !== files[0] || (size > length && completeEnd === 0)))
+                throw Error('preview ledger has partial record');
+            const lines = buffer.toString('utf8', 0, completeEnd).split('\n');
+            lines.pop();
+            if (size > length)
+                lines.shift();
+            for (let i = lines.length - 1; i >= 0 && events.length < 200; i--) {
+                const event = JSON.parse(lines[i]);
+                if (event.schemaVersion !== 1 || !Number.isSafeInteger(event.seq))
+                    throw Error('preview ledger invalid');
+                events.push(event);
+            }
+        }
+        finally {
+            await file.close();
+        }
+        if (events.length >= 200)
+            break;
+    }
+    signal.throwIfAborted();
+    const assistant = (event) => ['message.chunk', 'message.replace'].includes(event.kind) && event.payload?.role === 'assistant' && typeof event.payload?.content?.type === 'string';
+    const end = events.findIndex(assistant);
+    if (end < 0)
+        return { text: 'No recent agent output', at: '' };
+    const last = events[end], parts = [];
+    for (let i = end; i < events.length; i++) {
+        const event = events[i];
+        if (last.messageId !== undefined) {
+            if (!assistant(event) || event.messageId !== last.messageId)
+                continue;
+        }
+        else if (!assistant(event) || event.messageId !== undefined)
+            break;
+        const content = event.payload.content;
+        parts.unshift(content.type === 'text' ? content.text : `[${content.type}]`);
+        if (event.kind === 'message.replace')
+            break;
+    }
+    return { text: parts.join('').replace(/\s+/g, ' ').trim().slice(0, 300) || 'No recent agent output', at: last.at ?? '' };
+}

package/dist/application/conversation-role-observer.d.ts

@@ -0,0 +1,62 @@
+import { type FSWatcher } from 'node:fs';
+import { type SessionBackendId } from '../config.js';
+export interface ConversationRoleState {
+    roleId: string;
+    /** Connection-owned ordering; never a session stateRevision. */
+    roleRevision: number;
+    roleLifetime: string;
+    availability: 'available' | 'unavailable' | 'missing';
+    fallbackHarness?: string;
+    backend?: SessionBackendId;
+    stateDir?: string;
+    health: 'healthy' | 'unsupported' | 'failed';
+    failure?: 'watch-unsupported' | 'watch-error' | 'watch-closed' | 'role-read-failed' | 'observer-disposed';
+}
+export interface ConversationRoleObservation {
+    snapshot(): ConversationRoleState;
+    subscribe(listener: (state: ConversationRoleState) => void): {
+        snapshot: ConversationRoleState;
+        unsubscribe(): void;
+    };
+    dispose(): void;
+}
+export type ObserveConversationRole = (listener: (state: ConversationRoleState) => void) => ConversationRoleObservation;
+export interface ConversationRoleObserverOptions {
+    roleId: string;
+    configPath?: string;
+    permanentRoot?: string;
+    temporaryRoot?: string;
+    watch?: (path: string, listener: (event: string, filename: string | null) => void) => Pick<FSWatcher, 'on' | 'close'>;
+    subscribeMutations?: (listener: () => void) => () => void;
+}
+/** Native directory notifications are assumed reliable on qualified host/mount setups.
+ * No periodic reads or claim of detecting every silently dropped filesystem event.
+ */
+export declare class ConversationRoleObserver implements ConversationRoleObservation {
+    private readonly options;
+    private readonly listener;
+    private state;
+    private watchers;
+    private detach?;
+    private disposed;
+    private readonly listeners;
+    private queued;
+    private fingerprint?;
+    private readonly configPath;
+    private readonly permanent;
+    private readonly temporary;
+    constructor(options: ConversationRoleObserverOptions, listener: (state: ConversationRoleState) => void);
+    snapshot(): ConversationRoleState;
+    subscribe(listener: (state: ConversationRoleState) => void): {
+        snapshot: ConversationRoleState;
+        unsubscribe: () => void;
+    };
+    private publish;
+    dispose(): void;
+    private release;
+    private fail;
+    private schedule;
+    private refresh;
+    private install;
+    private watchFailure;
+}

package/dist/application/conversation-role-observer.js

@@ -0,0 +1,206 @@
+import { createHash, randomUUID } from 'node:crypto';
+import { lstatSync, readFileSync, realpathSync, watch } from 'node:fs';
+import { basename, dirname, join, resolve } from 'node:path';
+import { parse } from 'yaml';
+import { loadConfig, ROLE_NAME_RE, splitRootFor } from '../config.js';
+import { agentsRoot, defaultConfigPath, tmpRoot } from '../paths.js';
+import { controlSocketPath } from '../session/control.js';
+function identity(path) {
+    try {
+        const s = lstatSync(path);
+        return `${s.dev}:${s.ino}:${s.birthtimeMs}`;
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+}
+/** Native directory notifications are assumed reliable on qualified host/mount setups.
+ * No periodic reads or claim of detecting every silently dropped filesystem event.
+ */
+export class ConversationRoleObserver {
+    options;
+    listener;
+    state;
+    watchers = new Map();
+    detach;
+    disposed = false;
+    listeners = new Set();
+    queued = false;
+    fingerprint;
+    configPath;
+    permanent;
+    temporary;
+    constructor(options, listener) {
+        this.options = options;
+        this.listener = listener;
+        if (!ROLE_NAME_RE.test(options.roleId))
+            throw new Error('invalid role id');
+        this.configPath = resolve(options.configPath ?? defaultConfigPath());
+        this.permanent = resolve(options.permanentRoot ?? agentsRoot(), options.roleId);
+        this.temporary = resolve(options.temporaryRoot ?? tmpRoot(), options.roleId);
+        this.state = { roleId: options.roleId, roleRevision: 0, roleLifetime: randomUUID(), availability: 'missing', health: 'healthy' };
+        this.refresh();
+        if (this.state.health === 'healthy')
+            this.detach = options.subscribeMutations?.(() => this.schedule());
+    }
+    snapshot() {
+        return this.disposed ? { ...this.state, health: 'failed', failure: 'observer-disposed' } : { ...this.state };
+    }
+    subscribe(listener) {
+        if (!this.disposed)
+            this.listeners.add(listener);
+        return { snapshot: this.snapshot(), unsubscribe: () => { this.listeners.delete(listener); } };
+    }
+    publish() {
+        this.listener(this.snapshot());
+        for (const listener of this.listeners)
+            listener(this.snapshot());
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        this.disposed = true;
+        this.release();
+        this.listeners.clear();
+    }
+    release() {
+        const retired = [...this.watchers.values()];
+        // Retire before close: native close events may arrive synchronously or later.
+        this.watchers.clear();
+        for (const watcher of retired)
+            watcher.handle.close();
+        this.detach?.();
+        this.detach = undefined;
+    }
+    fail(failure) {
+        if (this.disposed || this.state.health !== 'healthy')
+            return;
+        this.state = { ...this.state, roleRevision: this.state.roleRevision + 1, health: failure === 'watch-unsupported' ? 'unsupported' : 'failed', failure };
+        this.release();
+        this.publish();
+    }
+    schedule() {
+        if (this.queued || this.disposed || this.state.health !== 'healthy')
+            return;
+        this.queued = true;
+        queueMicrotask(() => { this.queued = false; if (!this.disposed && this.state.health === 'healthy')
+            this.refresh(); });
+    }
+    refresh() {
+        try {
+            // Install parents before reading, including absent children, so atomic rename
+            // and recreation cannot strand us watching an unlinked inode.
+            this.install();
+            if (this.state.health !== 'healthy')
+                return;
+            let configured;
+            const split = splitRootFor(this.configPath);
+            if (identity(this.configPath) && identity(split) && identity(join(split, 'agents')))
+                configured = loadConfig(this.configPath).roles.find(role => role.name === this.options.roleId);
+            const permanentId = identity(this.permanent), temporaryId = identity(this.temporary);
+            const stateDir = temporaryId ? realpathSync(this.temporary) : permanentId ? realpathSync(this.permanent) : undefined;
+            let temporary;
+            if (!configured && temporaryId && identity(join(this.temporary, 'role.yaml'))) {
+                const raw = parse(readFileSync(join(this.temporary, 'role.yaml'), 'utf8'));
+                if (!raw || typeof raw !== 'object' || Array.isArray(raw)
+                    || (raw.session !== undefined && raw.session !== 'acp' && raw.session !== 'codex-app-server'))
+                    throw new Error('invalid temporary role snapshot');
+                temporary = { session: raw.session ?? 'acp', harness: typeof raw.harness === 'string' ? raw.harness : 'claude-code' };
+            }
+            const backend = configured?.session ?? temporary?.session;
+            const fallbackHarness = configured?.harness ?? temporary?.harness;
+            const socket = stateDir ? identity(controlSocketPath(stateDir)) : undefined;
+            const tokenPath = stateDir && join(stateDir, '.control-token');
+            const token = tokenPath && identity(tokenPath) ? createHash('sha256').update(readFileSync(tokenPath)).digest('hex') : undefined;
+            const exists = Boolean(configured || permanentId || temporaryId);
+            const availability = !exists ? 'missing' : stateDir && socket && token && backend ? 'available' : 'unavailable';
+            const fingerprint = JSON.stringify([Boolean(configured), permanentId, temporaryId, backend, socket, token]);
+            const lifetime = this.fingerprint === fingerprint ? this.state.roleLifetime : randomUUID();
+            this.fingerprint = fingerprint;
+            const next = { roleId: this.options.roleId, roleRevision: this.state.roleRevision, roleLifetime: lifetime,
+                availability, fallbackHarness, backend, stateDir, health: 'healthy' };
+            if (JSON.stringify(next) !== JSON.stringify(this.state)) {
+                this.state = { ...next, roleRevision: this.state.roleRevision + 1 };
+                this.publish();
+            }
+        }
+        catch {
+            this.fail('role-read-failed');
+        }
+    }
+    install() {
+        const wanted = new Map();
+        const add = (dir, child) => {
+            if (child === undefined)
+                wanted.set(dir, null);
+            else if (wanted.get(dir) !== null) {
+                const names = wanted.get(dir) ?? new Set();
+                names.add(child);
+                wanted.set(dir, names);
+            }
+        };
+        const parents = (path, boundary) => {
+            while (path !== boundary && dirname(path) !== path) {
+                add(dirname(path), basename(path));
+                path = dirname(path);
+            }
+        };
+        const configRoot = splitRootFor(this.configPath);
+        const configBoundary = dirname(dirname(this.configPath));
+        parents(this.configPath, configBoundary);
+        for (const dir of [configRoot, ...['agents', 'brains', 'roles', 'agent_templates'].map(kind => join(configRoot, kind))]) {
+            parents(dir, configBoundary);
+            add(dir);
+        }
+        for (const dir of [this.permanent, this.temporary]) {
+            parents(dir, dirname(dirname(dirname(dir))));
+            for (const name of ['role.yaml', '.control-token', '.control.sock'])
+                add(dir, name);
+            const socket = controlSocketPath(dir);
+            parents(socket, dirname(dirname(socket)));
+        }
+        for (const [dir, current] of this.watchers) {
+            if (!wanted.has(dir) || identity(dir) !== current.identity) {
+                this.watchers.delete(dir);
+                current.handle.close();
+            }
+        }
+        for (const [dir, names] of wanted) {
+            const id = identity(dir);
+            if (!id)
+                continue;
+            const existing = this.watchers.get(dir);
+            if (existing) {
+                existing.names = names;
+                continue;
+            }
+            try {
+                const handle = (this.options.watch ?? ((path, listener) => watch(path, { persistent: false }, listener)))(dir, (_event, filename) => {
+                    const entry = this.watchers.get(dir);
+                    if (filename === null || !entry?.names || entry.names.has(String(filename)) || String(filename) === basename(dir))
+                        this.schedule();
+                });
+                this.watchers.set(dir, { identity: id, names, handle });
+                handle.on('error', (error) => {
+                    if (this.watchers.get(dir)?.handle === handle)
+                        this.watchFailure(error);
+                });
+                handle.on('close', () => {
+                    if (this.watchers.get(dir)?.handle !== handle)
+                        return;
+                    this.watchers.delete(dir);
+                    this.fail('watch-closed');
+                });
+            }
+            catch (error) {
+                this.watchFailure(error);
+                return;
+            }
+        }
+    }
+    watchFailure(error) {
+        this.fail(['ENOSYS', 'ENOTSUP', 'ERR_FEATURE_UNAVAILABLE_ON_PLATFORM'].includes(error.code ?? '') ? 'watch-unsupported' : 'watch-error');
+    }
+}

package/dist/application/fleet-query-service.d.ts

@@ -24,7 +24,7 @@ export declare class FleetQueryService {
     private readonly options;
     private readonly control;
     constructor(options: FleetQueryOptions);
-    list(): Promise<Array<{
+    list(includeTemporary?: boolean, strict?: boolean): Promise<Array<{
         role: RoleRecord;
         status: RoleStatus;
         capabilities: RoleCapabilities;

package/dist/application/fleet-query-service.js

@@ -75,9 +75,9 @@ export class FleetQueryService {
         this.options = options;
         this.control = options.control ?? controlRequest;
     }
-    async list() {
-        const roles = (await this.options.repository.list())
-            .filter(role => role.configured && role.lifetime === 'permanent');
+    async list(includeTemporary = false, strict = false) {
+        const roles = (await this.options.repository.list(strict))
+            .filter(role => (role.configured && role.lifetime === 'permanent') || (includeTemporary && role.lifetime === 'temporary'));
         return Promise.all(roles.map(async (role) => {
             const status = await this.status(role);
             return { role, status, capabilities: roleCapabilities(role, status, this.options.capabilityContext) };