@ours.network/fleet 0.17.5 → 0.17.7

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.7",
+  "buildId": "8afdf08c9c69",
+  "commit": "1a6243fe213281c0b82f5bfeaf97dfc4c697fcf7",
   "dirty": false,
-  "builtAt": "2026-08-17T00:27:59.980Z",
+  "builtAt": "2026-08-17T12:01:37.858Z",
   "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');
@@ -635,7 +648,10 @@ function renderLoopRows(role, state, loop) {
     return Object.entries(state.loops).filter(([name]) => !loop || name === loop).map(([name, item]) => `${role}/${name} ${item.enabled && !item.operatorDisabled ? 'enabled' : 'disabled'} `
         + `${item.activeRunId ? 'running' : 'idle'} next=${item.nextDueAt} last=${item.lastOutcome ?? 'never'} `
         + `counts=${item.counts.started}/${item.counts.completed}/${item.counts.failed} `
-        + `skip=${item.counts.skipped}(busy=${item.counts.skippedBusy},missed=${item.counts.skippedMissed})`);
+        + `skip=${item.counts.skipped}(busy=${item.counts.skippedBusy},missed=${item.counts.skippedMissed})`
+        + (item.missedGap
+            ? ` gap=${item.missedGap.count}@${item.missedGap.fromAt}..${item.missedGap.throughAt}`
+            : ''));
 }
 cOpt(loopsCommand.command('status [role] [loop]').description('show live or stored loop state'))
     .option('--json', 'emit stable JSON')

package/dist/loops/manager.d.ts

@@ -68,8 +68,32 @@ export declare class ScheduledLoopManager implements ScheduledLoopManagerHandle
     private armAbandon;
     private finish;
     private advance;
+    /**
+     * Coalesce a backlog into one skip. The counters alone say how many
+     * occurrences were lost but never when or for how long, so the window is
+     * recorded too and carried on the state until a run is actually told about it
+     * — a dropped pass has to stay visible to the next one, not just to whoever
+     * was reading the log at the time.
+     */
     private skipMissed;
-    private skipRestartMisses;
+    /**
+     * Restart is not, by itself, a reason to lose an occurrence a running manager
+     * would still have run. `poll` tolerates lateness up to one full interval and
+     * runs the tick late; this path used to drop anything already due however
+     * recently, so a role restarted seconds after its own tick came due lost it
+     * outright. For an oversight role that is precisely the pass which would have
+     * recorded why it restarted, so the failure erased its own witness.
+     *
+     * The tolerance is the only thing shared with `poll`. A backlog at least one
+     * interval deep is still coalesced into a single skip and never replayed —
+     * after a long outage exactly one occurrence survives, and `schedule` then
+     * arms it through the ordinary path rather than firing a burst here.
+     *
+     * Running the survivor late cannot outpace the configured cadence: `advance`
+     * moves the cursor by exactly one `intervalMs` per occurrence from the nominal
+     * time, so a loop that keeps restarting still runs at most once per interval.
+     */
+    private skipRestartBacklog;
     /**
      * A run the store could not record is dropped, not retried: the cursor has
      * already moved, so this can never become a busy loop, and the outage is
@@ -86,5 +110,10 @@ export declare class ScheduledLoopManager implements ScheduledLoopManagerHandle
      * until the process was restarted.
      */
     private recover;
+    /**
+     * The envelope is the only channel a scheduled pass has for learning about
+     * the passes that did not happen. A gap stated here is what lets an oversight
+     * role report its own outage instead of resuming as if nothing was missed.
+     */
     private envelope;
 }

package/dist/loops/manager.js

@@ -39,7 +39,7 @@ export class ScheduledLoopManager {
     }
     start() {
         if (!this.store.fresh)
-            this.skipRestartMisses();
+            this.skipRestartBacklog();
         this.schedule();
     }
     async stop() {
@@ -143,10 +143,15 @@ export class ScheduledLoopManager {
     async attempt(definition, state, scheduledAt) {
         const runId = `sl_${randomUUID()}`;
         const origin = { kind: 'scheduled-loop', loop: definition.name, runId };
-        const prompt = this.envelope(definition, runId, scheduledAt);
+        // The gap is read here and cleared only if the turn is actually admitted:
+        // an attempt that ends `skipped_busy` or `unavailable` reported it to
+        // nobody, so it has to still be there for the attempt that succeeds.
+        const gap = state.missedGap;
+        const prompt = this.envelope(definition, runId, scheduledAt, gap);
         let claimed = false;
         const result = await this.arbiter.tryScheduled(prompt, origin, () => {
             claimed = true;
+            state.missedGap = null;
             state.activeRunId = runId;
             state.lastRunId = runId;
             state.lastStartedAt = new Date(this.deps.now()).toISOString();
@@ -265,7 +270,15 @@ export class ScheduledLoopManager {
         state.nextScheduledAt = new Date(next).toISOString();
         state.nextDueAt = new Date(next + deterministicJitter(this.role, definition.name, next, definition.jitterMs)).toISOString();
     }
+    /**
+     * Coalesce a backlog into one skip. The counters alone say how many
+     * occurrences were lost but never when or for how long, so the window is
+     * recorded too and carried on the state until a run is actually told about it
+     * — a dropped pass has to stay visible to the next one, not just to whoever
+     * was reading the log at the time.
+     */
     skipMissed(definition, state, now) {
+        const from = state.nextScheduledAt;
         let missed = 0;
         while (Date.parse(state.nextDueAt) <= now) {
             this.advance(definition, state);
@@ -275,14 +288,43 @@ export class ScheduledLoopManager {
         state.counts.skippedMissed = increment(state.counts.skippedMissed, missed);
         state.lastOutcome = 'skipped_missed';
         state.lastFinishedAt = new Date(now).toISOString();
+        // Successive outages before any run lands merge into one gap: the earliest
+        // start wins, so the window always spans the whole silence.
+        const previous = state.missedGap;
+        state.missedGap = {
+            count: increment(previous?.count ?? 0, missed),
+            fromAt: previous?.fromAt ?? from,
+            throughAt: state.lastScheduledAt ?? from,
+            detectedAt: new Date(now).toISOString(),
+        };
         this.store.persist();
-        this.deps.log(`[${this.role}] loop ${definition.name} skipped_missed count=${missed}`);
+        this.deps.log(`[${this.role}] loop ${definition.name} skipped_missed count=${missed} `
+            + `gap=${from}..${state.missedGap.throughAt} `
+            + `unreported=${state.missedGap.count}`);
     }
-    skipRestartMisses() {
+    /**
+     * Restart is not, by itself, a reason to lose an occurrence a running manager
+     * would still have run. `poll` tolerates lateness up to one full interval and
+     * runs the tick late; this path used to drop anything already due however
+     * recently, so a role restarted seconds after its own tick came due lost it
+     * outright. For an oversight role that is precisely the pass which would have
+     * recorded why it restarted, so the failure erased its own witness.
+     *
+     * The tolerance is the only thing shared with `poll`. A backlog at least one
+     * interval deep is still coalesced into a single skip and never replayed —
+     * after a long outage exactly one occurrence survives, and `schedule` then
+     * arms it through the ordinary path rather than firing a burst here.
+     *
+     * Running the survivor late cannot outpace the configured cadence: `advance`
+     * moves the cursor by exactly one `intervalMs` per occurrence from the nominal
+     * time, so a loop that keeps restarting still runs at most once per interval.
+     */
+    skipRestartBacklog() {
         const now = this.deps.now();
         for (const definition of this.definitions.values()) {
             const state = this.store.state.loops[definition.name];
-            if (definition.enabled && !state.operatorDisabled && Date.parse(state.nextDueAt) <= now)
+            if (definition.enabled && !state.operatorDisabled
+                && now >= Date.parse(state.nextDueAt) + definition.intervalMs)
                 this.skipMissed(definition, state, now);
         }
     }
@@ -340,17 +382,34 @@ export class ScheduledLoopManager {
             this.deps.clearTimer(this.timer);
         this.arm(backoffMs(this.pollFailures));
     }
-    envelope(definition, runId, scheduledAt) {
+    /**
+     * The envelope is the only channel a scheduled pass has for learning about
+     * the passes that did not happen. A gap stated here is what lets an oversight
+     * role report its own outage instead of resuming as if nothing was missed.
+     */
+    envelope(definition, runId, scheduledAt, gap) {
+        const lateBy = Math.max(0, this.deps.now() - scheduledAt);
         return [
             '[fleet-loop]',
             `loop: ${definition.name}`,
             `run: ${runId}`,
             `scheduled_at: ${new Date(scheduledAt).toISOString()}`,
+            ...(lateBy > 0 ? [`started_late_by_ms: ${lateBy}`] : []),
+            ...(gap ? [
+                `missed_occurrences: ${gap.count}`,
+                `missed_window: ${gap.fromAt}..${gap.throughAt}`,
+                `missed_gap_ms: ${Math.max(0, Date.parse(gap.detectedAt) - Date.parse(gap.fromAt))}`,
+            ] : []),
             'origin: local-trusted-config',
             '',
             'This is a scheduled internal maintenance turn, not an owner message and not ordinary ours mail.',
             'Perform one bounded pass. Do not wait for the next tick. Do not report to an owner unless your',
             'configured policy and an existing authenticated proactive-report route authorize a material report.',
+            ...(gap ? ['',
+                'This loop did not run for the window above: those occurrences were coalesced away while the role',
+                'was unavailable, and this pass is the first since. Treat the gap as part of what you are reporting',
+                'on — it is the record of your own outage, and no later pass will be told about it.',
+            ] : []),
             '',
             definition.prompt,
         ].join('\n');

package/dist/loops/state.d.ts

@@ -8,11 +8,29 @@ export interface LoopCounts {
     skippedBusy: number;
     skippedMissed: number;
 }
+/**
+ * A coalesced run of occurrences that were never submitted, held until a run
+ * actually starts and can be told about it. Without it a dropped occurrence
+ * survives only as a counter, which says how many were lost but never when or
+ * for how long — and an oversight role cannot report an outage it cannot date.
+ */
+export interface LoopMissedGap {
+    /** Occurrences coalesced away, summed across every skip since the last run. */
+    count: number;
+    /** Nominal time of the earliest occurrence in the gap. */
+    fromAt: string;
+    /** Nominal time of the latest occurrence in the gap. */
+    throughAt: string;
+    /** When the manager noticed — the end of the outage, not of the last skip. */
+    detectedAt: string;
+}
 export interface LoopRuntimeState {
     definitionHash: string;
     promptHash: string;
     enabled: boolean;
     operatorDisabled: boolean;
+    /** Unreported gap, cleared by the first run that carries it. */
+    missedGap: LoopMissedGap | null;
     nextScheduledAt: string;
     nextDueAt: string;
     lastScheduledAt: string | null;

package/dist/loops/state.js

@@ -100,6 +100,9 @@ export class ScheduledLoopStateStore {
             if (old?.definitionHash === definition.definitionHash) {
                 next[definition.name] = {
                     ...old, promptHash: definition.promptHash, enabled: definition.enabled,
+                    // A file written before this field existed restores as undefined; an
+                    // unreported gap is absent, not lost, so normalize rather than trust.
+                    missedGap: old.missedGap ?? null,
                 };
             }
             else {
@@ -119,6 +122,7 @@ export class ScheduledLoopStateStore {
                     activeRunId: old?.activeRunId ?? null,
                     counts: old?.counts ?? zeroCounts(), lastError: old?.lastError ?? null,
                     operatorDisabled: old?.operatorDisabled ?? false,
+                    missedGap: old?.missedGap ?? null,
                 };
             }
             if (recoverActive && next[definition.name].activeRunId) {

package/dist/session/acp.d.ts

@@ -5,6 +5,21 @@ import type { ConversationSnapshot, PromptOrigin, PromptReceipt, SubmitPromptCom
 import type { ConversationHandlePage, ExitRecord, InterruptOutcome, QueuedPrompt, SessionEvent, RuntimeSelectorMetadata, SessionHandle, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnOutcome, TurnResult } from './types.js';
 /** Bound safe-boundary waiting without turning a hung tool into cancellation. */
 export declare const AFTER_TOOL_BOUNDARY_TIMEOUT_MS = 120000;
+/**
+ * How long a steering-started turn is presumed to still own the adapter after
+ * its last update. Such a turn has no prompt id, so it never reports a
+ * stopReason and there is no exact end to observe — silence is the only signal
+ * available, and this is the bound that turns it into a decision.
+ *
+ * Sized from the fleet's own scheduled-run history: across 1513 completed
+ * scheduled runs the longest silence WITHIN a working turn was 120.2 s (p99
+ * 41.0 s; 5 runs above 60 s). A shorter grace would release the lease while the
+ * adapter is still working and re-admit a prompt into a busy turn, which is the
+ * FLEET-003 failure itself. The costs are deliberately asymmetric: holding too
+ * long skips one best-effort maintenance tick, releasing too early SIGTERMs a
+ * live role.
+ */
+export declare const STEERING_OCCUPANCY_IDLE_MS = 150000;
 /** Server-generated typed provenance followed by the exact human-authored body. */
 export declare function promptContentBlocks(text: string, origin?: PromptOrigin): acp.ContentBlock[];
 export declare function runtimeSelector(options: acp.SessionConfigOption[] | null | undefined, category: string): RuntimeSelectorMetadata | undefined;
@@ -33,6 +48,8 @@ export interface AcpSessionOptions {
     controllerGraceMs?: number;
     /** Test seam; production uses AFTER_TOOL_BOUNDARY_TIMEOUT_MS. */
     afterToolBoundaryTimeoutMs?: number;
+    /** Test seam; production uses STEERING_OCCUPANCY_IDLE_MS. */
+    steeringOccupancyIdleMs?: number;
 }
 /**
  * Classify an ACP `stopReason` into a terminal outcome. A refusal and a
@@ -60,6 +77,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;
@@ -75,6 +98,13 @@ export declare class AcpSession implements SessionHandle {
     private cancelEscalation?;
     private cancelForceKill?;
     private cancelRecoveryReason?;
+    /**
+     * Held while a steering-started turn is believed to own the adapter. It is a
+     * lease, not a latch: `steeringRelease` always fires, so the role can never be
+     * stranded busy by a wake whose turn ended without telling anyone.
+     */
+    private steeringOccupied;
+    private steeringRelease?;
     /**
      * Rejects the moment the adapter process is gone. Every in-flight ACP request
      * races it, so a dead adapter can never leave a turn — and therefore a
@@ -96,6 +126,20 @@ export declare class AcpSession implements SessionHandle {
      */
     private recoverOpenPrompts;
     isAlive(): boolean;
+    /**
+     * Take the occupancy lease for a turn the adapter started on its own behalf.
+     * Refreshed by every adapter update, so it tracks work actually happening
+     * rather than a fixed guess at how long a wake takes.
+     */
+    private holdSteeringOccupancy;
+    private refreshSteeringOccupancy;
+    /**
+     * Every exit from occupancy comes through here, including the ones that are
+     * not the timer: a real turn boundary, close, and adapter exit. A lease that
+     * can leak is worse than the bug it fixes — it would leave the role reporting
+     * `running` forever and starve scheduled admission permanently.
+     */
+    private releaseSteeringOccupancy;
     snapshot(): SessionSnapshot;
     private toolCall;
     private reserveTool;

package/dist/session/acp.js

@@ -16,6 +16,21 @@ const PERMISSION_TIMEOUT_MS = 10 * 60_000;
 const CONTROLLER_GRACE_MS = 12_000;
 /** Bound safe-boundary waiting without turning a hung tool into cancellation. */
 export const AFTER_TOOL_BOUNDARY_TIMEOUT_MS = 120_000;
+/**
+ * How long a steering-started turn is presumed to still own the adapter after
+ * its last update. Such a turn has no prompt id, so it never reports a
+ * stopReason and there is no exact end to observe — silence is the only signal
+ * available, and this is the bound that turns it into a decision.
+ *
+ * Sized from the fleet's own scheduled-run history: across 1513 completed
+ * scheduled runs the longest silence WITHIN a working turn was 120.2 s (p99
+ * 41.0 s; 5 runs above 60 s). A shorter grace would release the lease while the
+ * adapter is still working and re-admit a prompt into a busy turn, which is the
+ * FLEET-003 failure itself. The costs are deliberately asymmetric: holding too
+ * long skips one best-effort maintenance tick, releasing too early SIGTERMs a
+ * live role.
+ */
+export const STEERING_OCCUPANCY_IDLE_MS = 150_000;
 const TERMINAL_TOOL_STATUSES = new Set(['completed', 'failed']);
 const SCHEDULED_LOOP_REDACTION = '[scheduled-loop content redacted]';
 const OWNER_COMMENTARY_REDACTION = '[assistant commentary redacted]';
@@ -202,6 +217,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;
@@ -217,6 +238,13 @@ export class AcpSession {
     cancelEscalation;
     cancelForceKill;
     cancelRecoveryReason;
+    /**
+     * Held while a steering-started turn is believed to own the adapter. It is a
+     * lease, not a latch: `steeringRelease` always fires, so the role can never be
+     * stranded busy by a wake whose turn ended without telling anyone.
+     */
+    steeringOccupied = false;
+    steeringRelease;
     /**
      * Rejects the moment the adapter process is gone. Every in-flight ACP request
      * races it, so a dead adapter can never leave a turn — and therefore a
@@ -247,6 +275,7 @@ export class AcpSession {
             if (this.cancelForceKill)
                 clearTimeout(this.cancelForceKill);
             this.cancelForceKill = undefined;
+            this.releaseSteeringOccupancy('adapter exited');
             // Record the child's real exit code/signal. The tmux path can only see a
             // shell's `$?`; here the truth is available, so keep it.
             const classified = classifyChildExit(code, signal);
@@ -347,17 +376,60 @@ export class AcpSession {
         // terminal fact (signal exits deliberately leave exitCode null).
         return this.child.exitCode === null && (this.child.signalCode ?? null) === null;
     }
+    /**
+     * Take the occupancy lease for a turn the adapter started on its own behalf.
+     * Refreshed by every adapter update, so it tracks work actually happening
+     * rather than a fixed guess at how long a wake takes.
+     */
+    holdSteeringOccupancy() {
+        if (this.closing || !this.isAlive())
+            return;
+        this.steeringOccupied = true;
+        this.refreshSteeringOccupancy();
+    }
+    refreshSteeringOccupancy() {
+        if (!this.steeringOccupied)
+            return;
+        if (this.steeringRelease)
+            clearTimeout(this.steeringRelease);
+        this.steeringRelease = setTimeout(() => this.releaseSteeringOccupancy('adapter silent'), this.options.steeringOccupancyIdleMs ?? STEERING_OCCUPANCY_IDLE_MS);
+        this.steeringRelease.unref?.();
+    }
+    /**
+     * Every exit from occupancy comes through here, including the ones that are
+     * not the timer: a real turn boundary, close, and adapter exit. A lease that
+     * can leak is worse than the bug it fixes — it would leave the role reporting
+     * `running` forever and starve scheduled admission permanently.
+     */
+    releaseSteeringOccupancy(reason) {
+        if (this.steeringRelease)
+            clearTimeout(this.steeringRelease);
+        this.steeringRelease = undefined;
+        if (!this.steeringOccupied)
+            return;
+        this.steeringOccupied = false;
+        this.options.log(`[${this.options.name}] steering-started turn no longer holds the adapter (${reason})`);
+    }
     snapshot() {
         return {
             backend: 'acp',
             alive: this.isAlive(),
-            readiness: this.readiness,
+            // A steering-started turn is real work with no prompt id. Reporting the
+            // session idle while it runs is what let the arbiter admit a scheduled
+            // prompt into a busy adapter, whose `session/prompt` then never returned
+            // a stopReason and ended in a cancellation deadline and a SIGTERM.
+            readiness: this.readiness === 'idle' && this.steeringOccupied
+                ? 'running' : this.readiness,
             sessionId: this.sessionId,
             lastError: this.lastError,
             pendingPermissionId: this.pendingPermissions.keys().next().value,
             runtimeModel: this.runtimeModel,
             reasoningEffort: this.reasoningEffort,
             permissionMode: this.options.permissionMode,
+            activity: {
+                activeToolCalls: this.activeToolCalls.size,
+                ...(this.lastUpdateAt ? { lastUpdateAt: this.lastUpdateAt } : {}),
+            },
         };
     }
     toolCall(toolCallId) {
@@ -855,6 +927,7 @@ export class AcpSession {
         if (this.controllerGrace)
             clearTimeout(this.controllerGrace);
         this.controllerGrace = undefined;
+        this.releaseSteeringOccupancy('session closed');
         for (const [permissionId, pending] of [...this.pendingPermissions])
             this.settlePendingAutomatically(permissionId, pending, 'cancelled', undefined, 'the session closed while this request was pending');
         this.releaseAllTools();
@@ -1013,6 +1086,10 @@ export class AcpSession {
         }
         finally {
             this.releaseAllTools();
+            // A turn this client owned has ended, so the adapter has reported a
+            // boundary: whatever a steering call started before it is over too. This
+            // is the release path that does not depend on the silence timer.
+            this.releaseSteeringOccupancy('turn boundary');
             if (this.activeTurn?.id === turnId) {
                 this.activeTurn.settle();
                 if (this.cancelEscalation)
@@ -1035,6 +1112,12 @@ export class AcpSession {
             ]);
             if (response.outcome === 'failed')
                 return turnResult(false, 'failed', 'ACP steering failed');
+            // `injected` joined a turn this client already owns and will settle.
+            // `startedNewTurn` created one nobody owns: the adapter is working and
+            // will never answer for it, so admission has to learn about it here or
+            // not at all.
+            if (response.outcome === 'startedNewTurn')
+                this.holdSteeringOccupancy();
             return turnResult(true, 'inconclusive', response.outcome);
         }
         catch (error) {
@@ -1219,6 +1302,14 @@ 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. The same reason
+        // keeps it from extending the steering lease, which is evidence the adapter
+        // is working right now — for a steering-started turn, the only evidence.
+        if (!this.replaying) {
+            this.lastUpdateAt = new Date().toISOString();
+            this.refreshSteeringOccupancy();
+        }
         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.7",
   "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",