@ours.network/fleet 0.13.2 → 0.14.0

package/dist/loops/manager.js

@@ -7,6 +7,7 @@ export class ScheduledLoopManager {
     definitions = new Map();
     store;
     timer;
+    runTimeouts = new Set();
     stopping = false;
     constructor(role, definitions, stateDir, arbiter, deps) {
         this.role = role;
@@ -27,6 +28,9 @@ export class ScheduledLoopManager {
         if (this.timer !== undefined)
             this.deps.clearTimer(this.timer);
         this.timer = undefined;
+        for (const timeout of this.runTimeouts)
+            this.deps.clearTimer(timeout);
+        this.runTimeouts.clear();
         this.store.state.clock.lastWallMs = this.deps.now();
         this.store.persist();
     }
@@ -140,7 +144,25 @@ export class ScheduledLoopManager {
             return { state: 'unavailable', runId };
         }
         this.deps.log(`[${this.role}] loop ${definition.name} started run=${runId.slice(0, 11)} scheduled=${new Date(scheduledAt).toISOString()}`);
-        void result.queued.completion.then(turn => this.finish(definition, state, runId, turn));
+        // Maintenance is best-effort and must never monopolize a persistent role.
+        // A cancellation which the ACP adapter ignores is escalated by AcpSession
+        // into an adapter restart, preserving the session and deferred owner mail.
+        const timeoutMs = Math.max(60_000, Math.min(5 * 60_000, Math.floor(definition.intervalMs / 2)));
+        const timeout = this.deps.setTimer(() => {
+            this.runTimeouts.delete(timeout);
+            if (state.activeRunId !== runId || this.stopping)
+                return;
+            this.deps.log(`[${this.role}] loop ${definition.name} timed out run=${runId.slice(0, 11)} after ${timeoutMs}ms; cancelling`);
+            void this.arbiter.interrupt('scheduled-loop').catch(error => {
+                this.deps.log(`[${this.role}] loop ${definition.name} timeout cancellation failed: ${error?.name ?? 'Error'}`);
+            });
+        }, timeoutMs);
+        this.runTimeouts.add(timeout);
+        void result.queued.completion.then(turn => {
+            this.deps.clearTimer(timeout);
+            this.runTimeouts.delete(timeout);
+            this.finish(definition, state, runId, turn);
+        });
         return { state: 'started', runId };
     }
     finish(definition, state, runId, result) {

package/dist/owner-channel/channel.d.ts

@@ -1,12 +1,15 @@
 import { type ChildProcessWithoutNullStreams } from 'node:child_process';
 import { type OwnerChannelConfig } from '../config.js';
 import type { SessionHandle } from '../session/types.js';
+import { type OwnerFleetOps } from './commands.js';
 import { type OursToolClient } from './mcp.js';
 import { type OwnerUpdatePhase } from './notices.js';
 import { type OwnerEntry } from './state.js';
 import { type OwnerTaskPhase } from './tasks.js';
 export interface OwnerChannelOptions {
     role: string;
+    /** Harness id of the role (e.g. 'claude-code', 'codex'); gates which slash commands may be forwarded. */
+    harness: string;
     config: OwnerChannelConfig;
     session: SessionHandle;
     stateDir: string;
@@ -16,6 +19,10 @@ export interface OwnerChannelOptions {
     client?: OursToolClient;
     /** Test seam; production uses `ours-mcp watch <identity>`. */
     watch?: (identity: string) => ChildProcessWithoutNullStreams;
+    /** Test seam; production uses the detached ours-fleet CLI (`fleetCliOps`). */
+    fleet?: OwnerFleetOps;
+    /** Forwarded to fleet CLI invocations spawned for owner commands. */
+    configPath?: string;
 }
 export interface OwnerChannelHandle {
     start(): Promise<void>;
@@ -109,6 +116,7 @@ export declare class OwnerChannel implements OwnerChannelHandle {
     private readonly client;
     private readonly state;
     private readonly authorizations;
+    private readonly conversations;
     private readonly tasks;
     private readonly attachmentRecovery;
     private readonly attachmentConfig;
@@ -118,6 +126,8 @@ export declare class OwnerChannel implements OwnerChannelHandle {
      * (a crash must replay them) but must not be queued twice while live.
      */
     private readonly inFlight;
+    /** Wires already NACKed to the managed agent, so a deferred replay stays quiet. */
+    private readonly relayNacks;
     private stopping;
     private watchProcess?;
     private watchTask?;
@@ -127,6 +137,7 @@ export declare class OwnerChannel implements OwnerChannelHandle {
     private readonly activeRequests;
     private managementTail;
     private ready;
+    private readonly fleetOps;
     constructor(options: OwnerChannelOptions);
     start(): Promise<void>;
     drain(): Promise<void>;
@@ -139,14 +150,55 @@ export declare class OwnerChannel implements OwnerChannelHandle {
     private assertLabel;
     private safeMetadata;
     private sendOwnerUpdate;
+    private sendProactiveMessage;
     private openOwnerTask;
     private sendOwnerTaskReport;
     private safeOwnerUpdate;
     private safeTaskReport;
+    private safeProactiveMessage;
     private drainAll;
     private attachmentGroups;
     private handleAttachmentGroup;
     private handle;
+    /**
+     * Deterministic command path: the message never becomes an agent prompt.
+     * Authorization already happened — the managed-agent relay branch and the
+     * owner-CID check in handle() both run before dispatch, so only an
+     * authenticated owner reaches this: neither ordinary peers nor the managed
+     * agent itself can execute /force-restart, /model, or any other command.
+     */
+    private handleCommand;
+    /** Queue raw slash text to the harness and report the turn's outcome. */
+    private runHarnessCommand;
+    /**
+     * Confirmation and the durable wire record must both land BEFORE the fleet
+     * CLI is asked to bounce this very process; neither can happen afterwards.
+     */
+    private restartSelf;
+    /** Code-point-safe tail of the worklog, or undefined when there is none. */
+    private readWorklogTail;
+    /** Bound harness-command output to a single outbound message. */
+    private commandOutput;
+    private acceptedSender;
+    private isAgentSender;
+    private isEffectiveOwner;
+    private relayManagedAgentMessage;
+    /**
+     * One bounded NACK per wire: an unroutable or refused relay must be visible
+     * to the authenticated agent, while its deferred replays stay quiet. NACK
+     * delivery is best-effort — it must never make the failure worse.
+     */
+    private nackManagedAgent;
+    /**
+     * Daemon contact resolution is case-exact, so a canonical config CID picked
+     * by the sole-owner fallback is translated to the daemon-known contact form
+     * when one exists. Last-inbound routes already carry the daemon form.
+     */
+    private routableContact;
+    private safeRelayMessage;
+    private warnOwnerOfUnauthorizedSender;
+    private effectiveOwners;
+    private authorizationIntegrity;
     private complete;
     private ownerAttachmentPrompt;
     private ownerPrompt;