@ours.network/fleet 0.17.5 → 0.17.6

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

@@ -1,5 +1,6 @@
 import { lstatSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
+import { classifyActivity } from '../session/activity.js';
 import { controlRequest } from '../session/control.js';
 import { SessionControlError } from '../session/types.js';
 import { readExitRecord, readRestartLedger } from '../runner.js';
@@ -55,6 +56,10 @@ function sessionOverall(supervisor, session, restart, monitor, isolation, proble
     if (session.reachability === 'online'
         && (session.readiness === 'running' || session.readiness === 'awaiting_permission'))
         return 'busy';
+    // `readiness: idle` alone never justifies `ready`. A steered wake turn is
+    // invisible to readiness (FLEET-002), so observed activity outranks it.
+    if (session.reachability === 'online' && session.activity.state === 'active')
+        return 'busy';
     if (session.reachability === 'online' && session.readiness === 'idle')
         return 'ready';
     if (session.reachability === 'offline'
@@ -153,6 +158,7 @@ export class FleetQueryService {
                     protocolVersion: snapshot.protocolVersion, features: snapshot.features,
                     runtimeModel: snapshot.runtimeModel, reasoningEffort: snapshot.reasoningEffort,
                     permissionMode: snapshot.permissionMode,
+                    activity: classifyActivity(snapshot.activity),
                 };
             }
             catch (error) {
@@ -164,6 +170,7 @@ export class FleetQueryService {
                         : failure === 'control-unavailable' ? 'unavailable' : 'unknown',
                     readiness: offline ? 'failed' : 'unknown',
                     evidence: 'authoritative', lastError: clean(error.message),
+                    activity: { state: 'unobservable' },
                 };
             }
         }
@@ -174,18 +181,23 @@ export class FleetQueryService {
                     backend: 'tmux', reachability: has ? 'online' : supervisor === 'stopped' ? 'offline' : 'unknown',
                     readiness: has ? 'idle' : supervisor === 'running' ? 'starting' : 'failed',
                     evidence: 'inferred',
+                    // tmux exposes no agent-side evidence at all, and `readiness: idle`
+                    // here is a pane-liveness inference, not an activity claim.
+                    activity: { state: 'unobservable' },
                 };
             }
             catch (error) {
                 return {
                     backend: 'tmux', reachability: 'unknown', readiness: 'unknown',
                     evidence: 'inferred', lastError: clean(error.message),
+                    activity: { state: 'unobservable' },
                 };
             }
         }
         return {
             backend: 'unknown', reachability: supervisor === 'stopped' ? 'offline' : 'unknown',
             readiness: supervisor === 'stopped' ? 'failed' : 'unknown', evidence: 'inferred',
+            activity: { state: 'unobservable' },
         };
     }
 }

package/dist/application/types.d.ts

@@ -72,6 +72,17 @@ export interface RoleStatus {
         runtimeModel?: SessionSnapshot['runtimeModel'];
         reasoningEffort?: SessionSnapshot['reasoningEffort'];
         permissionMode?: SessionSnapshot['permissionMode'];
+        /**
+         * Activity evidence, kept separate from `readiness` on purpose: `readiness`
+         * answers "is a fleet-tracked turn in flight" (the prompt-admission gate),
+         * NOT "is this agent working". `state` is the only field a human-facing
+         * surface may use to call a role idle or stalled.
+         */
+        activity: {
+            state: 'active' | 'quiet' | 'unobservable';
+            activeToolCalls?: number;
+            lastUpdateAt?: string;
+        };
     };
     restart: {
         circuit: 'closed' | 'open';

package/dist/briefing.js

@@ -168,6 +168,11 @@ export function generateBriefing(role, v, opts) {
         L.push('Never translate any other failure into "dead". A busy agent, an unanswered control');
         L.push('plane and a confirmed stop look identical if you only look at one command.');
         L.push('');
+        L.push('`ours-fleet status` reports `session.readiness`, which is TURN OCCUPANCY only: a mail');
+        L.push('wake delivered by steering runs a whole turn with readiness pinned at `idle`. Read the');
+        L.push('`activity:` line beside it — `active` means the role is working — and never call a role');
+        L.push('idle or stalled from `readiness=idle` alone.');
+        L.push('');
         L.push('Then judge the console content: stuck on a prompt/menu/trust dialog → answer it directly');
         L.push('with `ours-fleet send <Name> "<text>"` (or `--key <K>` for raw keys); idle with work');
         L.push('assigned → nudge; actively working → do nothing, and do not mistake a long turn for a');

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "0.17.5",
-  "buildId": "aa2336deef48",
-  "commit": "aa6e64e28f7a1f2f4da66b43de003f9ada8c6a9b",
+  "version": "0.17.6",
+  "buildId": "a2f7650e3a39",
+  "commit": "96df9112202bb3957d18d95bc4210c1cf49d867f",
   "dirty": false,
-  "builtAt": "2026-08-17T00:27:59.980Z",
+  "builtAt": "2026-08-17T11:51:49.146Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/cli.js

@@ -27,6 +27,7 @@ import { creationBuildNote, formatProvenance, readProvenance } from './creation.
 import { doctor } from './doctor.js';
 import { allWarnings, analyzeFleetPermissions, effectivePermissionMode, formatNative, } from './permissions.js';
 import { AI_DOCS } from './docs.js';
+import { classifyActivity, describeSessionState } from './session/activity.js';
 import { controlRequest, controlSocketPath, followControl, livenessNote, } from './session/control.js';
 import { SessionControlError } from './session/types.js';
 import { readScheduledLoops, storedLoopHealth } from './loops/state.js';
@@ -363,8 +364,14 @@ program.command('ls').description('list running fleet sessions')
                 continue;
             try {
                 const response = await controlRequest(stateDir, { command: 'status' }, 2_000);
-                if (response.ok && response.result?.alive)
-                    acp.push(`${name}: acp`);
+                const result = response.result;
+                if (response.ok && result?.alive) {
+                    // Activity, not readiness: an idle-readiness role may be running a
+                    // steered wake turn (FLEET-002), so `ls` reports what was observed.
+                    const observed = classifyActivity(result.activity);
+                    acp.push(`${name}: acp${observed.state === 'active' ? ' (working)'
+                        : observed.state === 'quiet' ? ' (no recent agent activity)' : ''}`);
+                }
             }
             catch { /* ignore stale sockets */ }
         }
@@ -523,8 +530,14 @@ program.command('status <name>').description('unit/agent state')
     if (stateDir) {
         try {
             const response = await controlRequest(stateDir, { command: 'status' }, 2_000);
-            if (response.ok)
+            if (response.ok) {
+                const snapshot = response.result;
                 console.log(`session: ${JSON.stringify(response.result)}`);
+                // `readiness` is turn occupancy, never an activity claim: a steered
+                // wake turn runs to completion with readiness pinned at `idle`
+                // (FLEET-002). Say which question each field answers.
+                console.log(describeSessionState(snapshot.readiness, snapshot.activity));
+            }
         }
         catch {
             console.log('session: acp control unavailable');

package/dist/session/acp.d.ts

@@ -60,6 +60,12 @@ export declare class AcpSession implements SessionHandle {
     private connection;
     private sessionId?;
     private readiness;
+    /**
+     * Last non-replayed session update from the agent. `readiness` cannot answer
+     * "is this agent working" for a steered turn (FLEET-002), and this is the
+     * evidence that can.
+     */
+    private lastUpdateAt?;
     private lastError?;
     private promptTail;
     private queueDepth;

package/dist/session/acp.js

@@ -202,6 +202,12 @@ export class AcpSession {
     connection;
     sessionId;
     readiness = 'starting';
+    /**
+     * Last non-replayed session update from the agent. `readiness` cannot answer
+     * "is this agent working" for a steered turn (FLEET-002), and this is the
+     * evidence that can.
+     */
+    lastUpdateAt;
     lastError;
     promptTail = Promise.resolve();
     queueDepth = 0;
@@ -358,6 +364,10 @@ export class AcpSession {
             runtimeModel: this.runtimeModel,
             reasoningEffort: this.reasoningEffort,
             permissionMode: this.options.permissionMode,
+            activity: {
+                activeToolCalls: this.activeToolCalls.size,
+                ...(this.lastUpdateAt ? { lastUpdateAt: this.lastUpdateAt } : {}),
+            },
         };
     }
     toolCall(toolCallId) {
@@ -1219,6 +1229,10 @@ export class AcpSession {
             && params.options.some(option => option.optionId === 'decline' && option.kind === 'reject_once');
     }
     recordUpdate(update) {
+        // Replayed history is not current activity: `session/load` would otherwise
+        // make a cold session look like it had just been working.
+        if (!this.replaying)
+            this.lastUpdateAt = new Date().toISOString();
         const scheduled = this.activeTurn?.origin?.kind === 'scheduled-loop';
         const messagePhase = update.sessionUpdate === 'agent_message_chunk'
             ? this.codexMessagePhase(update) : undefined;

package/dist/session/activity.d.ts

@@ -0,0 +1,31 @@
+import type { SessionActivity } from './types.js';
+/**
+ * How long after the agent's last session update it still counts as working.
+ *
+ * FLEET-002: a wake delivered by ACP steering answers `startedNewTurn` and runs
+ * an entire turn that fleet never receives a `session/prompt` response for (ACP
+ * has no turn-end session update), so `readiness` stays `idle` throughout. Tool
+ * reservations and update recency are the only activity evidence fleet holds.
+ * The trade-off is deliberate and one-directional: at worst a role reads busy
+ * for one window after it genuinely stopped, instead of reading ready — or
+ * being classified stalled — while it is executing tools.
+ */
+export declare const ACTIVITY_WINDOW_MS = 60000;
+export type ActivityState = 'active' | 'quiet' | 'unobservable';
+export interface ObservedActivity {
+    state: ActivityState;
+    activeToolCalls?: number;
+    lastUpdateAt?: string;
+}
+/**
+ * Classify agent-side activity. `unobservable` is NOT `quiet`: a backend that
+ * cannot see the agent (tmux) has no evidence, and no evidence must never be
+ * reported as "doing nothing".
+ */
+export declare function classifyActivity(activity: SessionActivity | undefined, now?: number): ObservedActivity;
+/**
+ * One operator-facing line that never lets turn occupancy pose as liveness:
+ * the readiness value is labelled as the turn field it is, and the activity
+ * verdict is stated separately with the evidence behind it.
+ */
+export declare function describeSessionState(readiness: string | undefined, activity: SessionActivity | undefined, now?: number): string;

package/dist/session/activity.js

@@ -0,0 +1,48 @@
+/**
+ * How long after the agent's last session update it still counts as working.
+ *
+ * FLEET-002: a wake delivered by ACP steering answers `startedNewTurn` and runs
+ * an entire turn that fleet never receives a `session/prompt` response for (ACP
+ * has no turn-end session update), so `readiness` stays `idle` throughout. Tool
+ * reservations and update recency are the only activity evidence fleet holds.
+ * The trade-off is deliberate and one-directional: at worst a role reads busy
+ * for one window after it genuinely stopped, instead of reading ready — or
+ * being classified stalled — while it is executing tools.
+ */
+export const ACTIVITY_WINDOW_MS = 60_000;
+/**
+ * Classify agent-side activity. `unobservable` is NOT `quiet`: a backend that
+ * cannot see the agent (tmux) has no evidence, and no evidence must never be
+ * reported as "doing nothing".
+ */
+export function classifyActivity(activity, now = Date.now()) {
+    if (!activity)
+        return { state: 'unobservable' };
+    const lastUpdate = activity.lastUpdateAt ? Date.parse(activity.lastUpdateAt) : NaN;
+    const recent = Number.isFinite(lastUpdate) && now - lastUpdate <= ACTIVITY_WINDOW_MS;
+    return {
+        state: activity.activeToolCalls > 0 || recent ? 'active' : 'quiet',
+        activeToolCalls: activity.activeToolCalls,
+        ...(activity.lastUpdateAt ? { lastUpdateAt: activity.lastUpdateAt } : {}),
+    };
+}
+/**
+ * One operator-facing line that never lets turn occupancy pose as liveness:
+ * the readiness value is labelled as the turn field it is, and the activity
+ * verdict is stated separately with the evidence behind it.
+ */
+export function describeSessionState(readiness, activity, now = Date.now()) {
+    const observed = classifyActivity(activity, now);
+    const evidence = [];
+    if (observed.activeToolCalls)
+        evidence.push(`${observed.activeToolCalls} tool calls in flight`);
+    if (observed.lastUpdateAt) {
+        const age = Math.max(0, Math.round((now - Date.parse(observed.lastUpdateAt)) / 1000));
+        if (Number.isFinite(age))
+            evidence.push(`last agent update ${age}s ago`);
+    }
+    const detail = observed.state === 'unobservable'
+        ? 'no agent-side evidence on this backend'
+        : evidence.join(', ') || 'no updates yet';
+    return `turn: ${readiness ?? 'unknown'} (turn occupancy only) | activity: ${observed.state} (${detail})`;
+}

package/dist/session/types.d.ts

@@ -1,5 +1,16 @@
 import type { SessionBackendId } from '../config.js';
 import type { ConversationEventV1, ConversationSnapshot, PromptReceipt, SubmitPromptCommand } from './conversation-types.js';
+/**
+ * TURN OCCUPANCY, and nothing else: `idle` means no fleet-tracked turn is in
+ * flight, which is exactly the question `arbiter.tryScheduled` asks before it
+ * admits a prompt. It is NOT a claim that the agent is doing nothing — a wake
+ * delivered through the `_session/steering` extension answers `startedNewTurn`
+ * and runs a whole turn that fleet never gets a `session/prompt` response for
+ * (ACP has no turn-end session update), so `readiness` stays `idle` for its
+ * entire duration. Anything reporting activity or liveness to a human must
+ * corroborate with `SessionSnapshot.activity` instead of reading `idle` here as
+ * "not working".
+ */
 export type SessionReadiness = 'starting' | 'idle' | 'running' | 'awaiting_permission' | 'failed';
 export type TurnOutcome = 'completed' | 'refused' | 'cancelled' | 'failed' | 'inconclusive';
 export type TurnCancellationSource = 'owner' | 'local-console' | 'fleet-monitor' | 'scheduled-loop' | 'shutdown';
@@ -170,6 +181,19 @@ export interface SessionSnapshot {
         /** Exact harness-native approval/permission mode used by this runner. */
         nativeMode: string;
     };
+    /**
+     * Observed agent activity, independent of turn occupancy: the evidence a
+     * human-facing surface needs before calling a role idle. Absent on backends
+     * that cannot observe the agent at all (tmux), which is itself honest — no
+     * evidence is not evidence of inactivity.
+     */
+    activity?: SessionActivity;
+}
+export interface SessionActivity {
+    /** ACP tool calls currently reserved (lifecycle open or permission pending). */
+    activeToolCalls: number;
+    /** When the agent last sent ANY session update, replay excluded. */
+    lastUpdateAt?: string;
 }
 export type SessionEventKind = 'state' | 'agent_text' | 'thought' | 'tool_call' | 'tool_update' | 'permission' | 'monitor_delivery' | 'turn_stop' | 'error';
 /** What a settled permission request resolved to. */

package/dist/watchdog/briefing.js

@@ -80,6 +80,13 @@ export function generateWatchdogBriefing(opts) {
     L.push('- `healthy` — alive, on-briefing, recent progress.');
     L.push('- `idle` — alive, nothing assigned or nothing to do. Not an anomaly.');
     L.push('- `stale` = no worklog append and no console progress for ≥ 3 intervals.');
+    L.push('');
+    L.push('`session.readiness` from `ours-fleet status` is TURN OCCUPANCY, not activity: a mail');
+    L.push('wake delivered by ACP steering runs an entire turn while readiness stays `idle`. Never');
+    L.push('report `idle` or `stale` from `readiness=idle` alone — corroborate with the');
+    L.push('`activity:` line of the same `status` output (`active` means the agent is working),');
+    L.push('the worklog, or `ours-fleet peek`. `activity: unobservable` is missing evidence, not');
+    L.push('an idle agent.');
     L.push('- `blocked` = waiting on a permission/prompt/modal longer than one interval.');
     L.push('- `off_briefing` — activity contradicts the briefing (wrong repo, out-of-scope work,');
     L.push('  ignored routine).');

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "0.17.5",
+  "version": "0.17.6",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, tmux or ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",