@ours.network/fleet 1.1.0-nightly.9 → 1.1.0

package/dist/doctor.js

@@ -14,6 +14,7 @@ import { readScheduledLoops, storedLoopHealth } from './loops/state.js';
 import { controlSocketPath } from './session/control.js';
 import { analyzeInstalls, buildInfo, buildLabel, discoverInstalls, BIN_NAME, } from './provenance.js';
 import { readDaemonRecoveryStatus } from './daemon-recovery.js';
+import { codexModelCatalog } from './application/model-catalog.js';
 /** Which cgroup-v2 controllers are delegated to this user manager (advisory). */
 function cgroupDelegationDetail() {
     try {
@@ -107,6 +108,22 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
                 ok: true,
                 detail: `warning: ${diagnostic.message}`,
             });
+    if (loaded.ok) {
+        const packaged = Object.entries(loaded.brainPresets ?? {}).flatMap(([id, brain]) => brain.harness === 'codex' && typeof brain.model === 'string' && typeof brain.effort === 'string'
+            ? [{ id, model: brain.model, effort: brain.effort }] : [])
+            .sort((a, b) => a.id.localeCompare(b.id));
+        if (packaged.length) {
+            const runtime = codexModelCatalog(opts.codexCatalogPath);
+            const available = new Set(runtime.models.flatMap(model => model.reasoningEfforts.map(effort => `${model.id}\0${effort}`)));
+            const missing = packaged.filter(({ model, effort }) => !available.has(`${model}\0${effort}`));
+            checks.push({ name: 'brain catalog: Codex runtime drift', ok: true,
+                detail: runtime.models.length
+                    ? missing.length ? `warning: packaged Brain preset(s) absent from local Codex catalog: ${missing
+                        .map(({ id, model, effort }) => `${id} (${model}/${effort})`).join(', ')}`
+                        : `all ${packaged.length} packaged Codex model/effort pairs are present locally`
+                    : runtime.warnings.join('; ') });
+        }
+    }
     for (const role of roles) {
         const recovery = readDaemonRecoveryStatus(agentDir(role.name));
         if (!recovery)
@@ -160,16 +177,16 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
         const { listTemplates, resolveTemplate } = await import('./rooms-tasks/templates.js');
         const customs = loaded.roomTemplates ?? {};
         const templates = listTemplates(customs);
-        const roleNames = new Set(roles.map(r => r.name));
+        const agentTemplateNames = new Set(Object.keys(loaded.agentTemplates ?? {}));
         for (const t of templates) {
             const badRefs = t.members
-                .filter(m => 'ref' in m.agent && !roleNames.has(m.agent.ref))
-                .map(m => 'ref' in m.agent ? m.agent.ref : '');
+                .filter(m => !agentTemplateNames.has(m.agent_template))
+                .map(m => m.agent_template);
             if (badRefs.length) {
                 checks.push({
                     name: `template: ${t.name}@${t.version}`,
                     ok: true,
-                    detail: `warning: Agent ref(s) ${badRefs.join(', ')} not found in configured Agents`,
+                    detail: `warning: Agent Template(s) ${badRefs.join(', ')} not found`,
                 });
             }
         }
@@ -527,6 +544,23 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
                 : `${command} not found or failed — install the ACP adapter or set session_options.acp.command`,
         });
     }
+    for (const role of roles.filter(role => role.session === 'codex-app-server')) {
+        const configured = role.session_options?.codex_app_server?.command;
+        const launcher = role.harness_options?.launcher;
+        const command = Array.isArray(configured)
+            ? configured[0]
+            : typeof configured === 'string'
+                ? configured.trim().split(/\s+/)[0]
+                : launcher === 'ours-codex' ? 'ours-codex' : 'codex';
+        const result = await exec('sh', ['-c', 'command -v "$1" >/dev/null 2>&1', 'sh', command]);
+        checks.push({
+            name: `codex-app-server: ${role.name}`,
+            ok: result.code === 0,
+            detail: result.code === 0
+                ? `${command} available`
+                : `${command} not found — install Codex CLI or set session_options.codex_app_server.command`,
+        });
+    }
     return { ok: checks.every(c => c.ok), checks };
 }
 function loadConfigResult(configPath, yamlMode) {
@@ -535,6 +569,8 @@ function loadConfigResult(configPath, yamlMode) {
         return {
             ok: true, roles: cfg.roles, files: cfg.files, diagnostics: cfg.diagnostics,
             rooms: cfg.rooms, roomTemplates: cfg.roomTemplates, tasks: cfg.tasks,
+            agentTemplates: cfg.agentTemplates,
+            brainPresets: cfg.brainPresets,
             ownerInviteFingerprint: cfg.ownerInviteFingerprint,
         };
     }

package/dist/fleet-command-audit.d.ts

@@ -1,3 +1,5 @@
+import { type AgentLaunchConfiguration } from './lifecycle-summary.js';
+import type { SessionBackendId } from './config.js';
 export type FleetCommandDecision = 'allow' | 'deny' | 'unsupported';
 export type FleetCommandOutcomeClass = 'success' | 'validation' | 'denied' | 'runtime' | 'timeout' | 'proxy' | 'delivery';
 export declare class FleetCliExit extends Error {
@@ -15,12 +17,13 @@ export type FleetAuditPresentation = {
     brain: string;
     role: string;
     harness: string;
-    session: 'acp';
+    session: SessionBackendId;
     model?: string;
     permissions?: string;
     parent: string;
     actionId: string;
     inherited: string[];
+    configuration?: AgentLaunchConfiguration;
 } | {
     kind: 'task';
     operation: 'create' | 'start' | 'work' | 'block' | 'unblock' | 'review' | 'done' | 'cancel' | 'finish' | 'delete' | 'settling';
@@ -31,6 +34,8 @@ export type FleetAuditPresentation = {
     newState: string;
     template?: string;
     roomId?: string;
+    roomName?: string;
+    reason?: string;
     revision?: string;
     list?: string;
     agents: Array<{
@@ -38,6 +43,7 @@ export type FleetAuditPresentation = {
         brain?: string;
         role: string;
         permissions?: string;
+        configuration?: AgentLaunchConfiguration;
     }>;
 } | {
     kind: 'room';
@@ -50,18 +56,23 @@ export type FleetAuditPresentation = {
     name?: string;
     template?: string;
     taskId?: string;
+    anonymous?: boolean;
+    memberCount?: number;
+    ownerAttached?: boolean;
     participants: Array<{
         name: string;
         id?: string;
         brain?: string;
         role: string;
         permissions?: string;
+        configuration?: AgentLaunchConfiguration;
     }>;
 } | {
     kind: 'lifecycle_failure';
     eventId: string;
     resource: 'Agent' | 'Task' | 'Room';
     id: string;
+    label?: string;
     state: string;
     category: 'provision_failed' | 'provision_pending' | 'readiness_failed' | 'settlement_failed' | 'settlement_pending' | 'cleanup_failed' | 'cleanup_pending';
 };
@@ -70,10 +81,19 @@ export declare const FLEET_LIFECYCLE_EVENT_KINDS: readonly ["agent_started", "ta
 /** Stable semantic dedupe basis: resource kind + stable resource ID + transition/action ID. */
 export declare function lifecycleEventDigestBasis(value: FleetAuditPresentation): string;
 export declare function beginFleetAuditCollection(): void;
+export declare function setFleetAuditLifecycleCheckpoint(checkpoint: ((presentations: FleetAuditPresentation[]) => Promise<void>) | undefined): void;
+/**
+ * Deliver already-recorded lifecycle events while a managed command is still
+ * running. On a failed checkpoint the events remain in the final audit batch,
+ * so a temporary Owner-channel outage loses timing, never the notice itself.
+ */
+export declare function checkpointFleetAuditPresentations(): Promise<void>;
 export declare function recordFleetAuditResource(kind: 'agent' | 'task' | 'room', id: string | undefined): void;
 type FleetAuditPresentationInput = FleetAuditPresentation extends infer T ? T extends FleetAuditPresentation ? Omit<T, 'eventId'> & {
     eventId?: string;
 } : never : never;
+/** Immutable, single-line human label captured before mutable Task/Room state can disappear. */
+export declare function fleetPresentationLabel(value: unknown): string | undefined;
 export declare function recordFleetAuditPresentation(value: FleetAuditPresentationInput): void;
 export declare function recordFleetAuditFailure(failure: {
     class: FleetCommandOutcomeClass;
@@ -155,6 +175,7 @@ export declare function validateFleetAuditFinish(value: unknown): asserts value
     resourceIds?: Record<string, string>;
     presentations?: FleetAuditPresentation[];
 };
+export declare function validateFleetAuditPresentations(value: unknown): asserts value is FleetAuditPresentation[];
 /** Compact Owner presentation. It intentionally has no command, argv, environment, or correlation data. */
 export declare function renderFleetLifecycleEvent(value: FleetAuditPresentation): string;
 export {};