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

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,27 @@
+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): 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>;

package/dist/application/conversation-history.js

@@ -0,0 +1,215 @@
+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) {
+    const file = await open(path, 'r');
+    try {
+        let position = (await file.stat()).size;
+        let carry = Buffer.alloc(0);
+        while (position > 0) {
+            const size = Math.min(256 * 1024, position);
+            position -= size;
+            const chunk = Buffer.alloc(size);
+            await file.read(chunk, 0, size, position);
+            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) {
+    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 barrier = snapshot.ledgerBarrier;
+    const pending = new Set(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 && (!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();
+        });
+        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;
+}

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): 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() {
+    async list(includeTemporary = false) {
         const roles = (await this.options.repository.list())
-            .filter(role => role.configured && role.lifetime === 'permanent');
+            .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) };

package/dist/application/log-service.js

@@ -3,7 +3,6 @@ import { createHmac, randomBytes } from 'node:crypto';
 import { join } from 'node:path';
 import { realExec } from '../exec.js';
 import { logsRoot } from '../paths.js';
-import { unitFor } from '../supervisor/systemd.js';
 import { ROLE_NAME_RE } from '../config.js';
 import { FleetError } from './errors.js';
 const STANDARD_REDACTIONS = [
@@ -78,12 +77,13 @@ export class StructuredLogService {
     }
     async tail(roleId, requested, cursor) {
         const limit = Math.min(Math.max(requested, 1), 1_000);
-        const args = this.backend.id === 'systemd'
-            ? {
-                cmd: 'journalctl',
-                args: ['--user', '-u', unitFor(roleId), '-o', 'json', '--no-pager', '-n', String(limit)],
-            }
-            : this.backend.logsArgs(roleId, false);
+        const source = this.backend.logsArgs(roleId, false);
+        const args = { cmd: source.cmd, args: [...source.args] };
+        const count = args.args.indexOf('-n');
+        if (count >= 0)
+            args.args[count + 1] = String(limit);
+        if (args.cmd === 'journalctl')
+            args.args.push('-o', 'json', '--no-pager', '-n', String(limit));
         if (!['journalctl', 'tail', 'tmux'].includes(args.cmd))
             throw new FleetError('capability_unavailable', 'log backend is unsupported');
         const result = await this.exec(args.cmd, args.args);
@@ -93,7 +93,7 @@ export class StructuredLogService {
         const parsed = lines.map((line, index) => {
             let text = line;
             let at;
-            if (this.backend.id === 'systemd') {
+            if (args.cmd === 'journalctl') {
                 try {
                     const json = JSON.parse(line);
                     text = typeof json.MESSAGE === 'string' ? json.MESSAGE : line;

package/dist/application/model-catalog.d.ts

@@ -14,7 +14,7 @@ export interface HarnessModelCatalog {
 export declare function codexModelCatalog(path?: string): HarnessModelCatalog;
 /**
  * Claude Code 2.1 has no typed model-list endpoint. These exact IDs are the
- * versioned adapter contract shipped by the installed 2.1 CLI, not aliases and
+ * versioned adapter contract verified with CLI 2.1.281, not aliases and
  * not a claim about account entitlement (which Claude validates at launch).
  */
 export declare function claudeModelCatalog(): HarnessModelCatalog;

package/dist/application/model-catalog.js

@@ -41,17 +41,20 @@ export function codexModelCatalog(path = join(homedir(), '.codex', 'models_cache
 }
 /**
  * Claude Code 2.1 has no typed model-list endpoint. These exact IDs are the
- * versioned adapter contract shipped by the installed 2.1 CLI, not aliases and
+ * versioned adapter contract verified with CLI 2.1.281, not aliases and
  * not a claim about account entitlement (which Claude validates at launch).
  */
 export function claudeModelCatalog() {
     const reasoningEfforts = ['low', 'medium', 'high', 'xhigh', 'max'];
     return {
         models: [
+            { id: 'claude-fable-5-1', label: 'Claude Fable 5.1', reasoningEfforts, source: 'claude-adapter-2.1' },
+            { id: 'claude-opus-5-5', label: 'Claude Opus 5.5', reasoningEfforts, source: 'claude-adapter-2.1' },
+            { id: 'claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5', reasoningEfforts: [], source: 'claude-adapter-2.1' },
             { id: 'claude-fable-5', label: 'Claude Fable 5', reasoningEfforts, source: 'claude-adapter-2.1' },
             { id: 'claude-opus-5', label: 'Claude Opus 5', reasoningEfforts, source: 'claude-adapter-2.1' },
             { id: 'claude-sonnet-5', label: 'Claude Sonnet 5', reasoningEfforts, source: 'claude-adapter-2.1' },
         ],
-        warnings: ['Claude Code exposes no typed model-list endpoint; choices are exact 2.1 adapter IDs and entitlement is validated at launch.'],
+        warnings: ['Claude Code exposes no typed model-list endpoint; choices require a current Claude runtime (verified with 2.1.281); older bundled SDKs need CLAUDE_CODE_EXECUTABLE. Entitlement is validated at launch.'],
     };
 }