@ours.network/fleet 1.1.4 → 1.2.0-nightly.1

package/dist/harness/hermes-session.d.ts

@@ -0,0 +1,24 @@
+import type * as acp from '@agentclientprotocol/sdk';
+import type { ResolvedRole } from '../config.js';
+import type { SessionPrep } from './types.js';
+import type { AgentSessionAdapter, AgentSessionStartOptions, BrainSelection } from './agent-session.js';
+import type { AcpSessionTransport } from './acp-session-transport.js';
+/** Native provider resolution and executable compatibility remain harness-owned. */
+export interface HermesStartupChecks {
+    /** Independently resolved native provider identity, never copied from the ACP report. */
+    expectedProvider(role: ResolvedRole, prep: SessionPrep): string | Promise<string>;
+    validateArtifact(initialized: acp.InitializeResponse): void | Promise<void>;
+    /** Inspect the executable using the completed child environment before spawning it. */
+    preflight?(options: AgentSessionStartOptions, env: Record<string, string>): void | Promise<void>;
+}
+/** Fresh-only Hermes implementation of Fleet's existing live-session factory. */
+export declare class HermesAgentSessionAdapter implements AgentSessionAdapter {
+    private readonly transport;
+    private readonly checks?;
+    constructor(transport?: AcpSessionTransport, checks?: HermesStartupChecks | undefined);
+    resolveBrain(brain: BrainSelection): ReturnType<AgentSessionAdapter['resolveBrain']>;
+    modelEnvironmentVariable(): string | undefined;
+    prepareLaunch(role: ResolvedRole, prep: SessionPrep): ReturnType<AgentSessionAdapter['prepareLaunch']>;
+    sessionConfigSelections(role: ResolvedRole): ReturnType<AgentSessionAdapter['sessionConfigSelections']>;
+    start(options: AgentSessionStartOptions): ReturnType<AgentSessionAdapter['start']>;
+}

package/dist/harness/hermes-session.js

@@ -0,0 +1,85 @@
+import { AcpSession } from '../session/acp.js';
+import { hermesChildEnvironment, hermesMcpServers, validateHermesOptions, validateHermesRole } from './hermes-config.js';
+import { hermesPermissionMode } from './hermes-permissions.js';
+function requireValid(errors) {
+    if (errors.length)
+        throw new Error(errors.map(error => `${error.path}: ${error.message}`).join('; '));
+}
+function requireModel(model) {
+    if (typeof model !== 'string' || !model.trim())
+        throw new Error('Hermes requires an explicit non-empty Brain model');
+    return model.trim();
+}
+function preparedHome(prep) {
+    if (!prep.env.HERMES_HOME?.trim())
+        throw new Error('Hermes requires a prepared runtime home');
+    return prep.env.HERMES_HOME;
+}
+/** Fresh-only Hermes implementation of Fleet's existing live-session factory. */
+export class HermesAgentSessionAdapter {
+    transport;
+    checks;
+    constructor(transport = AcpSession.start, checks) {
+        this.transport = transport;
+        this.checks = checks;
+    }
+    resolveBrain(brain) {
+        const model = requireModel(brain.model);
+        if (brain.effort != null)
+            throw new Error('Hermes does not support effort');
+        requireValid(validateHermesOptions(brain.harnessOptions));
+        return { model, ...(brain.harnessOptions ? { harnessOptions: brain.harnessOptions } : {}) };
+    }
+    modelEnvironmentVariable() { return undefined; }
+    prepareLaunch(role, prep) {
+        requireValid(validateHermesRole(role));
+        preparedHome(prep);
+        const command = role.session_options?.acp?.command;
+        const argv = Array.isArray(command) ? [...command]
+            : typeof command === 'string' ? ['sh', '-c', command] : ['hermes-acp'];
+        return { argv, env: { ...prep.env } };
+    }
+    sessionConfigSelections(role) {
+        requireValid(validateHermesRole(role));
+        return [];
+    }
+    async start(options) {
+        const { role, prep, launch } = options;
+        requireValid(validateHermesRole({ ...role, permissions: options.permissions }));
+        const model = requireModel(role.model);
+        if (!this.checks)
+            throw new Error('Hermes startup checks are required before launching a managed session');
+        // Reapply the complete environment boundary after runner routing/isolation
+        // composition; no second ambient merge may reintroduce provider secrets.
+        const env = hermesChildEnvironment(role, preparedHome(prep), launch.env, launch.env);
+        delete env.OURS_AUTOSTART;
+        await this.checks.preflight?.(options, env);
+        const nativeProvider = await this.checks.expectedProvider(role, prep);
+        if (typeof nativeProvider !== 'string' || !nativeProvider.trim())
+            throw new Error('Hermes requires an independently resolved native provider');
+        const provider = nativeProvider.trim().toLowerCase();
+        // model_catalog.encode_model_choice preserves model colons; its catalog
+        // constructor promotes Ollama to the named custom provider identity.
+        const expectedModelId = `${provider === 'ollama' ? 'custom:ollama' : provider}:${model}`;
+        const modeId = hermesPermissionMode(options.permissions);
+        return this.transport({
+            name: role.name, harness: 'hermes', argv: launch.argv, cwd: options.cwd, env,
+            inheritEnvironment: false, stateDir: options.stateDir, mode: 'fresh',
+            permissions: options.permissions, modeId, requireMode: true,
+            permissionMode: { fleetMode: options.permissionMode.fleetMode, nativeMode: modeId },
+            permissionTimeoutMs: 50_000,
+            mcpServers: hermesMcpServers(role, env),
+            scrubObsoleteOursAutostart: true,
+            validateStartupResponse: async (initialized, created) => {
+                await this.checks.validateArtifact(initialized);
+                if (typeof created.models?.currentModelId !== 'string'
+                    || created.models.currentModelId !== expectedModelId)
+                    throw new Error('Hermes fresh-session model/provider report does not match the Brain model and provisioned provider');
+            },
+            ...(role.monitor?.mode === 'fleet' && role.monitor.stall_recovery ? {
+                stallRecovery: { timeoutMs: role.monitor.stall_timeout_ms },
+            } : {}),
+            log: options.log,
+        });
+    }
+}

package/dist/harness/hermes-startup.d.ts

@@ -0,0 +1,3 @@
+export { validateHermesInitialize as validateHermesHandshake } from './hermes-compatibility.js';
+/** Compare a native provisioned identity, never infer it from the child's report. */
+export declare function hermesConfiguredProvider(home: string): string;

package/dist/harness/hermes-startup.js

@@ -0,0 +1,21 @@
+import { readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import YAML from 'yaml';
+export { validateHermesInitialize as validateHermesHandshake } from './hermes-compatibility.js';
+/** Compare a native provisioned identity, never infer it from the child's report. */
+export function hermesConfiguredProvider(home) {
+    let provider;
+    try {
+        provider = YAML.parse(readFileSync(join(home, 'config.yaml'), 'utf8'))?.model?.provider;
+    }
+    catch {
+        throw new Error('Cannot read Hermes native provider; repair config.yaml in the stopped role home');
+    }
+    if (typeof provider !== 'string' || !provider.trim() || provider.trim().toLowerCase() === 'auto' || provider.includes('${'))
+        throw new Error('Hermes requires a literal native model.provider in the stopped role home so startup can detect provider fallback');
+    const canonical = provider.trim().toLowerCase();
+    // The tested runtime collapses named custom endpoints to custom, while its
+    // ACP model catalog reports Ollama under custom:ollama.
+    return canonical === 'ollama' || canonical === 'custom:ollama' ? 'custom:ollama'
+        : canonical.startsWith('custom:') ? 'custom' : canonical;
+}

package/dist/harness/hermes.d.ts

@@ -0,0 +1,5 @@
+import { type Exec } from '../exec.js';
+import type { AcpSessionTransport } from './acp-session-transport.js';
+import type { HarnessAdapter } from './types.js';
+export declare function makeHermesAdapter(exec?: Exec, transport?: AcpSessionTransport): HarnessAdapter;
+export declare const hermesAdapter: HarnessAdapter;

package/dist/harness/hermes.js

@@ -0,0 +1,62 @@
+import { realExec } from '../exec.js';
+import { HermesAgentSessionAdapter } from './hermes-session.js';
+import { inspectHermesCompatibility } from './hermes-compatibility.js';
+import { hermesConfiguredProvider, validateHermesHandshake } from './hermes-startup.js';
+import { prepareHermesConfig, validateHermesOptions, validateHermesRole } from './hermes-config.js';
+import { hermesPermissionMode, translateHermesPermissions } from './hermes-permissions.js';
+import { registerAdapter } from './registry.js';
+const wakeNote = 'Your mail wake-ups are delivered by the fleet supervisor as `[fleet-monitor]` lines. '
+    + 'Call **get_messages**, handle the mail, and reply with send_message. '
+    + 'Do NOT arm arm_monitor, foreground_monitor or a native Hermes monitor.';
+export function makeHermesAdapter(exec = realExec, transport) {
+    return {
+        id: 'hermes',
+        agentSession: new HermesAgentSessionAdapter(transport, {
+            expectedProvider: (_role, prep) => hermesConfiguredProvider(prep.env.HERMES_HOME),
+            validateArtifact: validateHermesHandshake,
+            async preflight(options, env) {
+                const original = new HermesAgentSessionAdapter().prepareLaunch(options.role, options.prep);
+                const report = await inspectHermesCompatibility({ argv: original.argv, env, home: options.prep.env.HERMES_HOME }, exec);
+                options.log(`Hermes ${report.artifact.hermesVersion}, ACP ${report.artifact.acpVersion}; fresh conversation, MCP availability unverified until actual use`);
+            },
+        }),
+        supportsResume: false,
+        async checkPrereqs() {
+            const result = await exec('hermes-acp', ['--help'], { timeout: 10_000 });
+            const ok = result.code === 0;
+            return { ok, checks: [{ name: 'hermes-acp', ok, detail: ok
+                            ? 'Hermes ACP executable found; launch still requires a tested compatible artifact, an explicit Brain model and provider/credentials provisioned in the exact stopped role home. Home/plugin MCP providers must be disabled.'
+                            : 'hermes-acp unavailable; install the tested Hermes artifact and provision provider/credentials in the exact stopped role home.' }] };
+        },
+        validateOptions(options, role) {
+            return role ? validateHermesRole({ ...role, harness_options: options })
+                : validateHermesOptions(options);
+        },
+        prepareSession: prepareHermesConfig,
+        // The selected home is already beneath the role state directory, which
+        // Fleet mounts writable. No operator home or credential path is shared.
+        isolationPaths: () => ({ shared: [] }),
+        nativePermissionOverrides: () => ({}),
+        translatePermissions: translateHermesPermissions,
+        effectivePermissions: role => translateHermesPermissions(role.permissions),
+        effectivePermissionMode(role) {
+            const nativeMode = hermesPermissionMode(role.permissions);
+            return { fleetMode: role.permissions.approval, nativeMode };
+        },
+        vocabulary: {
+            bindTool: 'choose_identity', createTool: 'create_identity',
+            temporaryCreateTool: 'create_temporary_identity', setBioTool: 'set_bio',
+            setPersonaTool: 'set_persona', currentIdentityTool: 'current_identity',
+            sendTool: 'send_message', getMessagesTool: 'get_messages',
+            listHistoryTool: 'list_history', getHistoryItemTool: 'get_history_item',
+            monitorInstruction: () => wakeNote,
+            supervisedWakeNote: () => wakeNote,
+            launchNote: name => `You were launched as Fleet role ${name} in a fresh Hermes ACP conversation. Confirm you are running.`,
+            restartPrompt: (identity, worklog) => `This is a fresh Hermes conversation. Follow the full role briefing, bind identity "${identity}" without force, `
+                + `and continue from ${worklog}. Native memory and skills persist; the previous conversation is not restored. ${wakeNote}`,
+        },
+        exitPolicy: { cleanExitIsFresh: true, fastFailSecs: 20 },
+    };
+}
+export const hermesAdapter = makeHermesAdapter();
+registerAdapter(hermesAdapter);

package/dist/harness/registry.js

@@ -29,7 +29,7 @@ export function knownAdapters() {
  * registry" is not the same question — this is the set doctor falls back to
  * when a broken configuration names no harness at all.
  */
-const PRODUCTION_ADAPTERS = ['claude-code', 'codex'];
+const PRODUCTION_ADAPTERS = ['claude-code', 'codex', 'hermes'];
 /** Production adapters actually registered in this process. */
 export function productionAdapters() {
     return PRODUCTION_ADAPTERS.filter(id => adapters.has(id));

package/dist/index.d.ts

@@ -9,6 +9,7 @@ export { OwnerChannel } from './owner-channel/channel.js';
 export { registerAdapter, getAdapter, knownAdapters } from './harness/registry.js';
 export { claudeCodeAdapter, makeClaudeCodeAdapter } from './harness/claude-code.js';
 export { codexAdapter, makeCodexAdapter } from './harness/codex.js';
+export { hermesAdapter, makeHermesAdapter } from './harness/hermes.js';
 export { generateBriefing } from './briefing.js';
 export { effectivePermissionMode } from './permissions.js';
 export { pickBackend } from './supervisor/index.js';

package/dist/index.js

@@ -6,6 +6,7 @@ export { OwnerChannel } from './owner-channel/channel.js';
 export { registerAdapter, getAdapter, knownAdapters } from './harness/registry.js';
 export { claudeCodeAdapter, makeClaudeCodeAdapter } from './harness/claude-code.js';
 export { codexAdapter, makeCodexAdapter } from './harness/codex.js';
+export { hermesAdapter, makeHermesAdapter } from './harness/hermes.js';
 export { generateBriefing } from './briefing.js';
 export { effectivePermissionMode } from './permissions.js';
 export { pickBackend } from './supervisor/index.js';

package/dist/init-wizard.d.ts

@@ -42,18 +42,23 @@ export interface InitPublishResult {
     manifestExisted: boolean;
     rootExisted: boolean;
 }
+export interface InitExecutionDeps {
+    hostSetup(): Promise<void>;
+    publish(configuration: string, setup: GeneratedSetup): Promise<InitPublishResult>;
+    generate?(answers: InitAnswers): GeneratedSetup;
+    preflight?(configuration: string): InitPathState;
+}
 export declare function validateCatalog(value: BrainCatalog, path?: string): BrainCatalog;
+/** Read and validate the complete public InitAnswers JSON shape without side effects. */
+export declare function readInitSettings(path: string): InitAnswers;
 export declare function askInitQuestions(prompter: InitPrompter, configuration: string): Promise<InitAnswers | undefined>;
 export declare function formatSetupSummary(answers: InitAnswers, configuration: string): string;
 /** Build the exact, deterministic default experience without writing to disk. */
 export declare function generateSetup(answers: InitAnswers): GeneratedSetup;
 /** Run the mutation boundary only after the complete questionnaire is accepted. */
-export declare function executeInitWizard(prompter: InitPrompter, configuration: string, deps: {
-    hostSetup(): Promise<void>;
-    publish(configuration: string, setup: GeneratedSetup): Promise<InitPublishResult>;
-    generate?(answers: InitAnswers): GeneratedSetup;
-    preflight?(configuration: string): InitPathState;
-}): Promise<InitPublishResult | undefined>;
+export declare function executeInitWizard(prompter: InitPrompter, configuration: string, deps: InitExecutionDeps): Promise<InitPublishResult | undefined>;
+/** Execute already-collected answers through the same validation and mutation boundary. */
+export declare function executeInitAnswers(answers: InitAnswers, configuration: string, deps: InitExecutionDeps): Promise<InitPublishResult>;
 export interface InitPathInspectionDeps {
     exists?(path: string): boolean;
     lstat?(path: string): Stats;

package/dist/init-wizard.js

@@ -49,6 +49,35 @@ function catalog() {
     const path = join(packagedPresetRoot(), 'brain-catalog.json');
     return validateCatalog(JSON.parse(readFileSync(path, 'utf8')), path);
 }
+const hasExactKeys = (value, keys) => Object.keys(value).sort().join('\0') === [...keys].sort().join('\0');
+/** Read and validate the complete public InitAnswers JSON shape without side effects. */
+export function readInitSettings(path) {
+    let value;
+    try {
+        value = JSON.parse(readFileSync(resolve(path), 'utf8'));
+    }
+    catch (error) {
+        throw new Error(`cannot read valid Fleet init settings ${path}: ${error.message}`, { cause: error });
+    }
+    if (!value || typeof value !== 'object' || Array.isArray(value)
+        || !hasExactKeys(value, ['subscriptions', 'assignmentStrategy', 'models', 'reasoning']))
+        throw new Error('Fleet init settings must contain exactly subscriptions, assignmentStrategy, models, and reasoning');
+    const candidate = value;
+    const models = candidate.models;
+    if (!models || typeof models !== 'object' || Array.isArray(models)
+        || !hasExactKeys(models, WORK_KINDS))
+        throw new Error('Fleet init settings models must contain exactly development, review, and coordination');
+    for (const work of WORK_KINDS) {
+        const model = models[work];
+        if (!model || typeof model !== 'object' || Array.isArray(model)
+            || !hasExactKeys(model, ['harness', 'session', 'model', 'efforts']))
+            throw new Error(`Fleet init settings ${work} model must contain exactly harness, session, model, and efforts`);
+    }
+    const answers = value;
+    // Generation is the single semantic/catalog validator for wizard and file input.
+    generateSetup(answers);
+    return answers;
+}
 const subscriptionFor = (model) => model.harness === 'codex' ? 'codex' : 'claude';
 export async function askInitQuestions(prompter, configuration) {
     const configPath = resolve(configuration);
@@ -216,6 +245,10 @@ export async function executeInitWizard(prompter, configuration, deps) {
     const answers = await askInitQuestions(prompter, configuration);
     if (!answers)
         return undefined;
+    return executeInitAnswers(answers, configuration, deps);
+}
+/** Execute already-collected answers through the same validation and mutation boundary. */
+export async function executeInitAnswers(answers, configuration, deps) {
     // Resolve every catalog/preset dependency before crossing the first mutation
     // boundary. Production owns this new map; the optional seam forces failures
     // deterministically in tests.

package/dist/monitor.d.ts

@@ -1,3 +1,4 @@
+import { type AttachOursClientOptions } from '@ours.network/sdk/client';
 import type { MonitorConfig, MonitorInterrupt, NotifyEventType } from './config.js';
 import { type FailureEvidence } from './model-recovery.js';
 /** A content-free arrival event as the daemon serves it over the notifications API. */
@@ -26,6 +27,28 @@ export type FetchLike = (url: string, init?: {
     headers?: Record<string, string>;
     signal?: AbortSignal;
 }) => Promise<FetchResponse>;
+export interface MonitorPageClient {
+    readNotificationPage(identity: string, options?: {
+        since?: number | 'tip';
+        signal?: AbortSignal;
+        requestTimeoutMs?: number;
+    }): Promise<{
+        cursor: number;
+        events: Array<Record<string, unknown>>;
+    }>;
+    close(): Promise<void>;
+}
+export interface IdentityProbeClient {
+    identities(): Promise<Array<string | {
+        name?: unknown;
+        temporary?: unknown;
+        stale?: unknown;
+    }>>;
+    close(): Promise<void>;
+}
+export interface IdentityProbeDeps {
+    attachClient?(options: AttachOursClientOptions): IdentityProbeClient | Promise<IdentityProbeClient>;
+}
 export interface MonitorDeps {
     fetch: FetchLike;
     isAlive(pid: number): boolean;
@@ -37,6 +60,8 @@ export interface MonitorDeps {
         set(fn: () => void, ms: number): ReturnType<typeof setTimeout>;
         clear(t: ReturnType<typeof setTimeout>): void;
     };
+    /** Test seam; production attaches through the SDK's verified selection path. */
+    attachClient?(options: AttachOursClientOptions): MonitorPageClient | Promise<MonitorPageClient>;
     /**
      * Structured prompt delivery used by agent sessions.
      * `succeeded` is the turn's TERMINAL result, not merely that the session took
@@ -101,13 +126,13 @@ export type IdentityPresence = {
     detail: string;
 };
 /** Resolve the daemon endpoint + auth header from env → config → defaults. */
-export declare function resolveEndpoint(env: NodeJS.ProcessEnv): DaemonEndpoint;
+export declare function resolveEndpoint(env: NodeJS.ProcessEnv, includeToken?: boolean): DaemonEndpoint;
 /**
  * Ask the daemon's authoritative identity index. The notifications endpoint is
  * intentionally unsuitable for lifecycle: it serves an empty 200 page for a
  * valid but missing identity, which made a closed temp identity look healthy.
  */
-export declare function probeIdentityPresence(name: string, fetch: FetchLike, env: NodeJS.ProcessEnv): Promise<IdentityPresence>;
+export declare function probeIdentityPresence(name: string, fetch: FetchLike, env: NodeJS.ProcessEnv, deps?: IdentityProbeDeps): Promise<IdentityPresence>;
 /** Actionable, secret-free description of every token source for this profile. */
 export declare function authResolutionHint(ep: DaemonEndpoint): string;
 /** Keep only the events whose type the role asked to wake on. */
@@ -171,7 +196,11 @@ export declare class Monitor {
     private readonly identity;
     private readonly cfg;
     private readonly deps;
-    private readonly ep;
+    private readonly ep?;
+    private readonly profile?;
+    private readonly profileKey;
+    private readonly monitorLeaseToken;
+    private profileClientPromise?;
     private readonly statusPath;
     private readonly cursorPath;
     private readonly statePath;
@@ -212,6 +241,8 @@ export declare class Monitor {
      * no-ops (delivery is still verified downstream).
      */
     private doFetch;
+    private profileClient;
+    private disposeProfileClient;
     private advance;
     private persistCursor;
     private readPersistedCursor;