@ours.network/fleet 0.9.0 → 0.9.1

package/dist/doctor.js

@@ -6,6 +6,7 @@ import { getAdapter } from './harness/registry.js';
 import { agentDir, home, deriveXdgRuntimeDir } from './paths.js';
 import { resolveIsolation } from './isolation/policy.js';
 import { makeBubblewrapBackend } from './isolation/bubblewrap.js';
+import { authResolutionHint, resolveEndpoint, } from './monitor.js';
 /** Which cgroup-v2 controllers are delegated to this user manager (advisory). */
 function cgroupDelegationDetail() {
     try {
@@ -19,6 +20,21 @@ function cgroupDelegationDetail() {
         return 'unknown (not cgroup-v2 or no delegation info)';
     }
 }
+/** Resolve and deduplicate the effective daemon profiles used by monitored roles. */
+function resolveMonitorProfiles(roles) {
+    const profiles = [];
+    for (const role of roles.filter(r => r.monitor?.enabled)) {
+        const endpoint = resolveEndpoint({ ...process.env, ...(role.env ?? {}) });
+        const token = endpoint.headers['x-ours-api-token'];
+        const existing = profiles.find(p => p.endpoint.origin === endpoint.origin
+            && p.endpoint.headers['x-ours-api-token'] === token);
+        if (existing)
+            existing.roles.push(role.name);
+        else
+            profiles.push({ endpoint, roles: [role.name] });
+    }
+    return profiles;
+}
 /** Host-level + per-harness prerequisite report with actionable messages. */
 export async function doctor(opts = {}, exec = realExec, platform = process.platform, fetchImpl = (u, i) => globalThis.fetch(u, i)) {
     const checks = [];
@@ -110,34 +126,36 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
     // Monitor daemon-API reachability (design §5): only when a role is supervised.
     // /state-dir is unauthenticated (liveness); /identities exercises the token so a
     // shared-mode misconfig (401) surfaces here rather than as a silent deaf monitor.
-    if (roles.some(r => r.monitor?.enabled)) {
-        const port = Number(process.env.OURS_PORT) || 3050;
-        const token = process.env.OURS_API_TOKEN;
-        const headers = token ? { 'x-ours-api-token': token } : {};
+    const monitorProfiles = resolveMonitorProfiles(roles);
+    for (const profile of monitorProfiles) {
+        const { endpoint } = profile;
+        const checkName = monitorProfiles.length === 1
+            ? 'monitor: daemon API'
+            : `monitor: daemon API (${profile.roles.join(', ')})`;
         let ok = false, detail;
         try {
-            const live = await fetchImpl(`http://127.0.0.1:${port}/state-dir`, {});
+            const live = await fetchImpl(`${endpoint.origin}/state-dir`, {});
             if (!live.ok) {
-                detail = `daemon on :${port} answered /state-dir with HTTP ${live.status} — not the ours daemon?`;
+                detail = `daemon on :${endpoint.port} answered /state-dir with HTTP ${live.status} — not the ours daemon?`;
             }
             else {
-                const auth = await fetchImpl(`http://127.0.0.1:${port}/identities`, { headers });
+                const auth = await fetchImpl(`${endpoint.origin}/identities`, { headers: endpoint.headers });
                 if (auth.status === 401)
-                    detail = `reachable on :${port} but the API token was rejected (401) — set OURS_API_TOKEN to the ` +
-                        `daemon's token (shared mode) or run the fleet as the daemon owner`;
+                    detail = `reachable on :${endpoint.port} but the API token was rejected (401) — ` +
+                        authResolutionHint(endpoint);
                 else if (!auth.ok)
-                    detail = `reachable on :${port} but /identities returned HTTP ${auth.status}`;
+                    detail = `reachable on :${endpoint.port} but /identities returned HTTP ${auth.status}`;
                 else {
                     ok = true;
-                    detail = `reachable on :${port}, authorized — supervisor wake stream available`;
+                    detail = `reachable on :${endpoint.port}, authorized — supervisor wake stream available`;
                 }
             }
         }
         catch (e) {
-            detail = `unreachable on :${port} — monitored roles run degraded until it is up ` +
+            detail = `unreachable on :${endpoint.port} — monitored roles run degraded until it is up ` +
                 `(start it: ours-mcp start) [${e?.message ?? e}]`;
         }
-        checks.push({ name: 'monitor: daemon API', ok, detail });
+        checks.push({ name: checkName, ok, detail });
     }
     const harnesses = opts.harness
         ? [opts.harness]

package/dist/harness/claude-code.js

@@ -38,6 +38,15 @@ export function pretrust(dir) {
     e.projectOnboardingSeenCount = Math.max(e.projectOnboardingSeenCount ?? 0, 1);
     writeFileSync(p, JSON.stringify(d, null, 2));
 }
+/**
+ * Shared Monitor-arming mandate (issue #16). Single-sourced so the briefing and
+ * the restart prompt can never diverge on how the agent must arm its monitor —
+ * it must be the Monitor TOOL, not a background Bash task (which never wakes the
+ * agent on output → an armed-looking but deaf monitor).
+ */
+const armMonitor = (id) => 'arm a **persistent Monitor** (the Monitor TOOL — NOT a background Bash command; a ' +
+    `background Bash task never wakes you on output) running \`ours-mcp watch "${id}"\` ` +
+    'so inbound ours mail wakes you';
 export function makeClaudeCodeAdapter(exec = realExec) {
     return {
         id: 'claude-code',
@@ -108,7 +117,10 @@ export function makeClaudeCodeAdapter(exec = realExec) {
             sendTool: 'send_message',
             getMessagesTool: 'get_messages',
             watchCommand: id => `ours-mcp watch "${id}"`,
-            monitorInstruction: id => `Arm a **persistent Monitor** running the shell command \`ours-mcp watch "${id}"\` so inbound ours mail wakes you.`,
+            monitorInstruction: id => {
+                const m = armMonitor(id);
+                return `${m.charAt(0).toUpperCase()}${m.slice(1)}.`;
+            },
             supervisedWakeNote: () => 'Your mail wake-ups are delivered by the fleet supervisor directly into this console as ' +
                 '`[fleet-monitor]` lines — do NOT arm an in-session Monitor. When such a line appears, run ' +
                 '**get_messages** to drain the mail.',
@@ -116,8 +128,12 @@ export function makeClaudeCodeAdapter(exec = realExec) {
             restartPrompt: (id, worklog, role) => `Session restarted. Re-bind your ours identity now (choose_identity name "${id}" force=true), ` +
                 (role?.monitor?.enabled
                     ? 'then continue from '
-                    : `re-arm your monitor (ours-mcp watch "${id}"), then continue from `) +
-                `${worklog}. Do not re-run whatever crashed you.`,
+                    : `then ${armMonitor(id)}, then continue from `) +
+                `${worklog}. Do not re-run whatever crashed you.` +
+                (role?.monitor?.enabled
+                    ? ' Your mail wakes arrive as `[fleet-monitor]` console lines from the supervisor — ' +
+                        'do NOT arm an in-session Monitor.'
+                    : ''),
         },
         exitPolicy: { cleanExitIsFresh: true, fastFailSecs: 20 },
     };

package/dist/monitor.d.ts

@@ -39,11 +39,37 @@ export interface MonitorDeps {
         clear(t: ReturnType<typeof setTimeout>): void;
     };
 }
-/** Resolve the daemon endpoint + auth header from the environment (design §6c). */
-export declare function resolveEndpoint(env: NodeJS.ProcessEnv): {
+/** Best-effort daemon config (issue #17): the fields the MCP client reads. */
+interface DaemonConfig {
+    apiToken?: string;
+    port?: number;
+    stateDir?: string;
+}
+/**
+ * Read the daemon config the way the MCP client does — best-effort. Any missing,
+ * malformed, or unreadable config yields `{}` so token resolution falls through
+ * (issue #17). Only the well-typed fields we consume are surfaced.
+ */
+export declare function readDaemonConfig(env: NodeJS.ProcessEnv): DaemonConfig;
+/**
+ * Resolve the daemon API token exactly like the MCP client (issue #17), a 3-step
+ * chain: `OURS_API_TOKEN` (trimmed) → config `apiToken` (trimmed) → the 0600 owner
+ * token at `<stateDir>/daemon-token`. Never generates a token; a failed read of
+ * any source (missing/unreadable) silently falls through to the next.
+ */
+export declare function resolveApiToken(env: NodeJS.ProcessEnv, file?: DaemonConfig): string | undefined;
+export interface DaemonEndpoint {
+    origin: string;
+    port: number;
+    configPath: string;
+    stateDir: string;
     url(name: string): string;
     headers: Record<string, string>;
-};
+}
+/** Resolve the daemon endpoint + auth header from env → config → defaults. */
+export declare function resolveEndpoint(env: NodeJS.ProcessEnv): DaemonEndpoint;
+/** 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. */
 export declare function filterEvents(events: NotifyEvent[], wakeSources: string[]): NotifyEvent[];
 /**
@@ -101,3 +127,4 @@ export declare class Monitor {
     private setStatus;
 }
 export declare function createMonitor(o: MonitorOpts): Monitor;
+export {};

package/dist/monitor.js

@@ -1,4 +1,5 @@
 import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import { homedir } from 'node:os';
 import { join } from 'node:path';
 // Code constants (not config — YAGNI, design §2).
 const DEFAULT_PORT = 3050;
@@ -14,15 +15,81 @@ const PREFIX = '[fleet-monitor]';
 const MAX_LINE = 260;
 class AuthError extends Error {
 }
-/** Resolve the daemon endpoint + auth header from the environment (design §6c). */
+/** Path to the daemon config the MCP client uses: OURS_CONFIG ?? real ~/.ours/config.json. */
+const daemonConfigPath = (env) => env.OURS_CONFIG ?? join(homedir(), '.ours', 'config.json');
+/** Match ours-mcp's env integer semantics: parseInt, invalid → absent. */
+function envInt(env, name) {
+    const raw = env[name];
+    if (raw === undefined)
+        return undefined;
+    const n = parseInt(raw, 10);
+    return Number.isNaN(n) ? undefined : n;
+}
+/**
+ * Read the daemon config the way the MCP client does — best-effort. Any missing,
+ * malformed, or unreadable config yields `{}` so token resolution falls through
+ * (issue #17). Only the well-typed fields we consume are surfaced.
+ */
+export function readDaemonConfig(env) {
+    try {
+        const p = JSON.parse(readFileSync(daemonConfigPath(env), 'utf8'));
+        const o = {};
+        if (typeof p.apiToken === 'string' && p.apiToken.trim())
+            o.apiToken = p.apiToken.trim();
+        if (typeof p.port === 'number' && Number.isFinite(p.port))
+            o.port = p.port;
+        if (typeof p.stateDir === 'string')
+            o.stateDir = p.stateDir;
+        return o;
+    }
+    catch {
+        return {};
+    }
+}
+/**
+ * Resolve the daemon API token exactly like the MCP client (issue #17), a 3-step
+ * chain: `OURS_API_TOKEN` (trimmed) → config `apiToken` (trimmed) → the 0600 owner
+ * token at `<stateDir>/daemon-token`. Never generates a token; a failed read of
+ * any source (missing/unreadable) silently falls through to the next.
+ */
+export function resolveApiToken(env, file = readDaemonConfig(env)) {
+    const e = env.OURS_API_TOKEN?.trim();
+    if (e)
+        return e;
+    if (file.apiToken)
+        return file.apiToken;
+    const sd = env.OURS_STATE_DIR ?? file.stateDir ?? join(homedir(), '.ours');
+    try {
+        const t = readFileSync(join(sd, 'daemon-token'), 'utf8').trim();
+        if (t)
+            return t;
+    }
+    catch { /* missing/unreadable (e.g. cross-user 0600) → fall through */ }
+    return undefined;
+}
+/** Resolve the daemon endpoint + auth header from env → config → defaults. */
 export function resolveEndpoint(env) {
-    const port = Number(env.OURS_PORT) || DEFAULT_PORT;
-    const token = env.OURS_API_TOKEN;
+    const file = readDaemonConfig(env);
+    const port = envInt(env, 'OURS_PORT') ?? file.port ?? DEFAULT_PORT;
+    const configPath = daemonConfigPath(env);
+    const stateDir = env.OURS_STATE_DIR ?? file.stateDir ?? join(homedir(), '.ours');
+    const token = resolveApiToken(env, file);
+    const origin = `http://127.0.0.1:${port}`;
     return {
-        url: (name) => `http://127.0.0.1:${port}/identities/${encodeURIComponent(name)}/notifications`,
+        origin,
+        port,
+        configPath,
+        stateDir,
+        url: (name) => `${origin}/identities/${encodeURIComponent(name)}/notifications`,
         headers: token ? { 'x-ours-api-token': token } : {},
     };
 }
+/** Actionable, secret-free description of every token source for this profile. */
+export function authResolutionHint(ep) {
+    const tokenPath = join(ep.stateDir, 'daemon-token');
+    return `set OURS_API_TOKEN, set apiToken in ${JSON.stringify(ep.configPath)}, or ensure ` +
+        `${JSON.stringify(tokenPath)} is readable by the fleet supervisor`;
+}
 /** Keep only the events whose type the role asked to wake on. */
 export function filterEvents(events, wakeSources) {
     const set = new Set(wakeSources);
@@ -242,7 +309,7 @@ export class Monitor {
             this.currentAbort = null;
         }
         if (resp.status === 401)
-            throw new AuthError('daemon rejected the API token (401) — set OURS_API_TOKEN or run as the daemon owner');
+            throw new AuthError(`daemon rejected the API token (401) — ${authResolutionHint(this.ep)}`);
         if (!resp.ok)
             throw new Error(`daemon returned HTTP ${resp.status}`);
         return resp.json();

package/dist/runner.js

@@ -41,8 +41,8 @@ export function buildPaneCommand(launch, roleEnv, exitStatusPath, paneArgv = lau
     const cmd = paneArgv.map(shq).join(' ');
     return `${envPfx} ${cmd}; echo $? > ${shq(exitStatusPath)}`;
 }
-/** Adapt the runner's injected deps into the monitor's dependency surface. */
-function monitorDeps(deps) {
+/** Adapt runner deps and the role's daemon-profile overrides for the monitor. */
+function monitorDeps(deps, roleEnv) {
     return {
         fetch: deps.fetch,
         tmux: deps.tmux,
@@ -50,7 +50,9 @@ function monitorDeps(deps) {
         sleep: deps.sleep,
         now: deps.now,
         log: deps.log,
-        env: process.env,
+        // The agent pane receives role.env too. The supervisor monitor must select
+        // the same ours daemon profile, with per-role values winning over service env.
+        env: { ...process.env, ...(roleEnv ?? {}) },
         timers: { set: (fn, ms) => setTimeout(fn, ms), clear: t => clearTimeout(t) },
     };
 }
@@ -232,7 +234,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     // as disabled (monitor may be undefined on an old role.yaml).
     const monitor = role.monitor?.enabled ? deps.createMonitor({
         name, agentDir: dir, cfg: role.monitor,
-        deps: monitorDeps(deps),
+        deps: monitorDeps(deps, role.env),
     }) : null;
     if (monitor)
         await monitor.prime();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "0.9.0",
+  "version": "0.9.1",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, tmux consoles, systemd/launchd supervision, ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",