@ours.network/fleet 0.11.1 → 0.13.0

package/dist/session/acp.js

@@ -40,6 +40,7 @@ export class AcpSession {
     steeringSupported = false;
     capabilities;
     controllerCount = 0;
+    activeTurn;
     constructor(options, child, connection) {
         this.options = options;
         this.child = child;
@@ -117,24 +118,24 @@ export class AcpSession {
         if (!this.sessionId || !this.isAlive())
             throw new SessionControlError('offline', this.lastError ?? 'ACP session is offline');
         if (options.interrupt)
-            await this.interrupt();
+            await this.cancelActive(options.interruptSource ?? 'local-console');
         // Interrupting delivery must still use steering when supported. With no
         // live turn, the extension starts one and acknowledges `startedNewTurn`
         // immediately; a normal session/prompt would keep the monitor blocked until
         // the entire wake-triggered turn terminated.
         if (options.steer && this.steeringSupported) {
             const promptId = randomUUID();
-            return { promptId, queuedBehind: 0, completion: this.steerPrompt(text) };
+            return { promptId, queuedBehind: 0, completion: this.steerPrompt(text), origin: options.origin };
         }
         const promptId = randomUUID();
         const queuedBehind = this.queueDepth++;
-        const run = this.promptTail.then(() => this.runPrompt(text, promptId));
+        const run = this.promptTail.then(() => this.runPrompt(text, promptId, options.origin));
         this.promptTail = run.then(() => undefined, () => undefined);
         const completion = run.then(result => { this.queueDepth = Math.max(0, this.queueDepth - 1); return result; }, error => {
             this.queueDepth = Math.max(0, this.queueDepth - 1);
             return turnResult(false, 'failed', error?.message ?? String(error));
         });
-        return { promptId, queuedBehind, completion };
+        return { promptId, queuedBehind, completion, origin: options.origin };
     }
     async submitPrompt(text, options = {}) {
         try {
@@ -146,10 +147,24 @@ export class AcpSession {
             throw error;
         }
     }
-    async interrupt() {
+    async interrupt(source = 'local-console') {
+        await this.cancelActive(source);
+    }
+    async cancelActive(source) {
         if (!this.sessionId)
             return;
-        await this.connection.agent.notify(acp.methods.agent.session.cancel, { sessionId: this.sessionId });
+        const active = this.activeTurn;
+        const previousSource = active?.cancellationSource;
+        if (active && (source === 'owner' || source === 'local-console' || !previousSource))
+            active.cancellationSource = source;
+        try {
+            await this.connection.agent.notify(acp.methods.agent.session.cancel, { sessionId: this.sessionId });
+        }
+        catch (error) {
+            if (this.activeTurn === active && active?.cancellationSource === source)
+                active.cancellationSource = previousSource;
+            throw error;
+        }
         for (const pending of this.pendingPermissions.values())
             pending.resolve({ outcome: { outcome: 'cancelled' } });
         this.pendingPermissions.clear();
@@ -162,6 +177,8 @@ export class AcpSession {
         this.pendingPermissions.delete(permissionId);
         pending.resolve({ outcome: { outcome: 'selected', optionId } });
         this.events.emit('permission', {
+            turnId: this.activeTurn?.id,
+            origin: this.activeTurn?.origin,
             permissionId,
             status: 'completed',
             decision: chosen.kind.startsWith('reject') ? 'denied' : 'allowed',
@@ -237,30 +254,43 @@ export class AcpSession {
         this.readiness = 'idle';
         this.events.emit('state', { status: 'idle', text: `ACP session ${this.sessionId}` });
     }
-    async runPrompt(text, turnId = randomUUID()) {
+    async runPrompt(text, turnId = randomUUID(), origin) {
         if (!this.sessionId || !this.isAlive())
             return turnResult(false, 'failed', this.lastError ?? 'ACP session is offline');
         this.readiness = 'running';
-        this.events.emit('state', { turnId, status: 'running' });
+        this.activeTurn = { id: turnId, output: '', origin };
+        this.events.emit('state', { turnId, status: 'running', origin });
         try {
             const response = await this.connection.agent.request(acp.methods.agent.session.prompt, {
                 sessionId: this.sessionId,
                 prompt: [{ type: 'text', text }],
             });
             this.readiness = 'idle';
-            this.events.emit('turn_stop', { turnId, stopReason: response.stopReason });
+            this.events.emit('turn_stop', {
+                turnId, stopReason: response.stopReason, origin,
+                cancellationSource: this.activeTurn?.id === turnId
+                    ? this.activeTurn.cancellationSource : undefined,
+            });
             this.events.emit('state', { status: 'idle' });
             // The prompt was accepted either way — the agent answered. Whether the
             // turn SUCCEEDED is a separate question, and only `stopReason` answers it.
-            return turnResult(true, classifyStopReason(response.stopReason), response.stopReason);
+            return turnResult(true, classifyStopReason(response.stopReason), response.stopReason, this.activeTurn?.id === turnId ? this.activeTurn.output : undefined, this.activeTurn?.id === turnId ? this.activeTurn.cancellationSource : undefined);
         }
         catch (error) {
-            this.lastError = error?.message ?? String(error);
+            const detail = error?.message ?? String(error);
+            this.lastError = origin?.kind === 'scheduled-loop' ? 'scheduled-loop turn failed' : detail;
             this.readiness = this.isAlive() ? 'idle' : 'failed';
-            this.events.emit('error', { turnId, text: this.lastError });
+            this.events.emit('error', {
+                turnId, origin,
+                text: origin?.kind === 'scheduled-loop' ? 'scheduled-loop turn failed' : this.lastError,
+            });
             if (this.isAlive())
                 this.events.emit('state', { status: 'idle' });
-            return turnResult(false, 'failed', this.lastError);
+            return turnResult(false, 'failed', this.lastError, this.activeTurn?.id === turnId ? this.activeTurn.output : undefined);
+        }
+        finally {
+            if (this.activeTurn?.id === turnId)
+                this.activeTurn = undefined;
         }
     }
     async steerPrompt(text) {
@@ -312,12 +342,18 @@ export class AcpSession {
         const permissionId = randomUUID();
         this.readiness = 'awaiting_permission';
         this.events.emit('permission', {
+            turnId: this.activeTurn?.id,
+            origin: this.activeTurn?.origin,
             permissionId,
-            toolCallId: params.toolCall.toolCallId,
-            title: params.toolCall.title ?? 'Permission requested',
+            toolCallId: this.activeTurn?.origin?.kind === 'scheduled-loop'
+                ? 'scheduled-loop-tool' : params.toolCall.toolCallId,
+            title: this.activeTurn?.origin?.kind === 'scheduled-loop'
+                ? 'Scheduled-loop permission requested' : params.toolCall.title ?? 'Permission requested',
             status: 'pending',
             options: params.options.map(option => ({
-                optionId: option.optionId, name: option.name, kind: option.kind,
+                optionId: option.optionId,
+                name: this.activeTurn?.origin?.kind === 'scheduled-loop' ? option.kind : option.name,
+                kind: option.kind,
             })),
         });
         return new Promise(resolve => {
@@ -332,16 +368,24 @@ export class AcpSession {
     settleAutomatically(params, option, decision, policy, reason) {
         const settled = option ? decision : 'cancelled';
         this.events.emit('permission', {
+            turnId: this.activeTurn?.id,
+            origin: this.activeTurn?.origin,
             permissionId: randomUUID(),
-            toolCallId: params.toolCall.toolCallId,
-            title: params.toolCall.title ?? 'Permission requested',
+            toolCallId: this.activeTurn?.origin?.kind === 'scheduled-loop'
+                ? 'scheduled-loop-tool' : params.toolCall.toolCallId,
             status: 'completed',
             decision: settled,
             decisionSource: 'automatic',
             policy,
             reason: option ? reason : `${reason}, but the agent offered no matching option`,
             optionId: option?.optionId,
-            options: params.options.map(o => ({ optionId: o.optionId, name: o.name, kind: o.kind })),
+            title: this.activeTurn?.origin?.kind === 'scheduled-loop'
+                ? 'Scheduled-loop permission requested' : params.toolCall.title ?? 'Permission requested',
+            options: params.options.map(o => ({
+                optionId: o.optionId,
+                name: this.activeTurn?.origin?.kind === 'scheduled-loop' ? o.kind : o.name,
+                kind: o.kind,
+            })),
         });
         return option
             ? { outcome: { outcome: 'selected', optionId: option.optionId } }
@@ -364,28 +408,41 @@ export class AcpSession {
         });
     }
     recordUpdate(update) {
+        const scheduled = this.activeTurn?.origin?.kind === 'scheduled-loop';
         switch (update.sessionUpdate) {
             case 'agent_message_chunk':
+                if (this.activeTurn && update.content.type === 'text')
+                    this.activeTurn.output += update.content.text;
                 this.events.emit('agent_text', {
-                    text: update.content.type === 'text' ? update.content.text : `[${update.content.type}]`,
+                    turnId: this.activeTurn?.id,
+                    origin: this.activeTurn?.origin,
+                    text: scheduled ? '[scheduled-loop output redacted]'
+                        : update.content.type === 'text' ? update.content.text : `[${update.content.type}]`,
                 });
                 break;
             case 'agent_thought_chunk':
                 this.events.emit('thought', {
-                    text: update.content.type === 'text' ? update.content.text : `[${update.content.type}]`,
+                    turnId: this.activeTurn?.id,
+                    origin: this.activeTurn?.origin,
+                    text: scheduled ? '[scheduled-loop thought redacted]'
+                        : update.content.type === 'text' ? update.content.text : `[${update.content.type}]`,
                 });
                 break;
             case 'tool_call':
                 this.events.emit('tool_call', {
-                    toolCallId: update.toolCallId,
-                    title: update.title,
+                    turnId: this.activeTurn?.id,
+                    origin: this.activeTurn?.origin,
+                    toolCallId: scheduled ? 'scheduled-loop-tool' : update.toolCallId,
+                    title: scheduled ? 'scheduled-loop tool' : update.title,
                     status: update.status,
                 });
                 break;
             case 'tool_call_update':
                 this.events.emit('tool_update', {
-                    toolCallId: update.toolCallId,
-                    title: update.title ?? undefined,
+                    turnId: this.activeTurn?.id,
+                    origin: this.activeTurn?.origin,
+                    toolCallId: scheduled ? 'scheduled-loop-tool' : update.toolCallId,
+                    title: scheduled ? 'scheduled-loop tool' : update.title ?? undefined,
                     status: update.status ?? undefined,
                 });
                 break;

package/dist/session/arbiter.d.ts

@@ -0,0 +1,42 @@
+import type { ExitRecord, PromptOrigin, QueuedPrompt, SessionEvent, SessionHandle, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnResult } from './types.js';
+export type ScheduledAttempt = {
+    state: 'started';
+    queued: QueuedPrompt;
+} | {
+    state: 'skipped_busy';
+} | {
+    state: 'unavailable';
+    error: string;
+};
+/**
+ * One in-process admission boundary for every producer targeting a role.
+ * Scheduled callers get an atomic idle recheck plus submission; ordinary
+ * producers retain ACP queue semantics while making their unsettled claim
+ * visible before another producer can inspect idle state.
+ */
+export declare class RoleTurnArbiter implements SessionHandle {
+    private readonly session;
+    readonly backend: import("../config.js").SessionBackendId;
+    readonly pid: number;
+    private tail;
+    private unsettled;
+    private stopping;
+    constructor(session: SessionHandle);
+    private exclusive;
+    private track;
+    queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
+    submitPrompt(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
+    tryScheduled(text: string, origin: Extract<PromptOrigin, {
+        kind: 'scheduled-loop';
+    }>, beforeQueue?: () => void | Promise<void>): Promise<ScheduledAttempt>;
+    stopScheduledAdmission(): void;
+    isAlive(): boolean;
+    snapshot(): SessionSnapshot;
+    interrupt(source?: TurnCancellationSource): Promise<void>;
+    respondPermission(permissionId: string, optionId: string): boolean;
+    eventsSince(seq: number): SessionEvent[];
+    subscribe(listener: (event: SessionEvent) => void): () => void;
+    setControllerAttached(attached: boolean): void;
+    exitResult(): ExitRecord | null;
+    close(): Promise<void>;
+}

package/dist/session/arbiter.js

@@ -0,0 +1,72 @@
+/**
+ * One in-process admission boundary for every producer targeting a role.
+ * Scheduled callers get an atomic idle recheck plus submission; ordinary
+ * producers retain ACP queue semantics while making their unsettled claim
+ * visible before another producer can inspect idle state.
+ */
+export class RoleTurnArbiter {
+    session;
+    backend;
+    pid;
+    tail = Promise.resolve();
+    unsettled = 0;
+    stopping = false;
+    constructor(session) {
+        this.session = session;
+        this.backend = session.backend;
+        this.pid = session.pid;
+    }
+    exclusive(operation) {
+        const run = this.tail.then(operation);
+        this.tail = run.then(() => undefined, () => undefined);
+        return run;
+    }
+    track(queued) {
+        this.unsettled++;
+        const completion = queued.completion.finally(() => { this.unsettled = Math.max(0, this.unsettled - 1); });
+        return { ...queued, completion };
+    }
+    queuePrompt(text, options = {}) {
+        return this.exclusive(async () => this.track(await this.session.queuePrompt(text, options)));
+    }
+    async submitPrompt(text, options = {}) {
+        return (await this.queuePrompt(text, options)).completion;
+    }
+    async tryScheduled(text, origin, beforeQueue) {
+        // Give owner/console/I/O callbacks already ready in this event-loop turn a
+        // chance to claim the arbiter first. Scheduled work is best-effort; humans
+        // and authenticated ingress have priority at the idle boundary.
+        await new Promise(resolve => setImmediate(resolve));
+        return this.exclusive(async () => {
+            const snapshot = this.session.snapshot();
+            if (this.stopping || !snapshot.alive || snapshot.readiness === 'failed')
+                return { state: 'unavailable', error: this.stopping ? 'role is stopping' : 'session is unavailable' };
+            if (snapshot.readiness !== 'idle' || this.unsettled > 0)
+                return { state: 'skipped_busy' };
+            try {
+                await beforeQueue?.();
+                const queued = await this.session.queuePrompt(text, { interrupt: false, origin });
+                if (queued.queuedBehind > 0)
+                    return { state: 'unavailable', error: 'scheduled admission race' };
+                return { state: 'started', queued: this.track(queued) };
+            }
+            catch (error) {
+                return { state: 'unavailable', error: error?.message ?? String(error) };
+            }
+        });
+    }
+    stopScheduledAdmission() { this.stopping = true; }
+    isAlive() { return this.session.isAlive(); }
+    snapshot() { return this.session.snapshot(); }
+    interrupt(source = 'local-console') {
+        return this.exclusive(() => this.session.interrupt(source));
+    }
+    respondPermission(permissionId, optionId) {
+        return this.session.respondPermission(permissionId, optionId);
+    }
+    eventsSince(seq) { return this.session.eventsSince(seq); }
+    subscribe(listener) { return this.session.subscribe(listener); }
+    setControllerAttached(attached) { this.session.setControllerAttached(attached); }
+    exitResult() { return this.session.exitResult(); }
+    close() { return this.session.close(); }
+}

package/dist/session/control.d.ts

@@ -1,16 +1,20 @@
 import { type Socket } from 'node:net';
 import type { ControlFailureKind, SessionHandle } from './types.js';
+import type { OwnerChannelHandle, OwnerChannelManagementRequest } from '../owner-channel/channel.js';
+import type { ScheduledLoopManagerHandle } from '../loops/manager.js';
 export interface ControlRequest {
     version: 1 | 2;
     id: string;
     token: string;
-    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since';
+    command: 'status' | 'snapshot' | 'submit_prompt' | 'respond_permission' | 'interrupt' | 'follow' | 'events_since' | 'owner_channel_manage' | 'loop_status' | 'loop_run_now' | 'loop_disable' | 'loop_enable' | 'reload_config';
     text?: string;
     permissionId?: string;
     optionId?: string;
     since?: number;
     /** Existing clients omit this and remain interactive controllers. */
     controller?: boolean;
+    ownerChannel?: OwnerChannelManagementRequest;
+    loop?: string;
 }
 export interface ControlResponse {
     version: 1;
@@ -71,9 +75,16 @@ export declare class RoleControlServer {
     private readonly socketPath;
     private readonly token;
     private readonly sockets;
+    private ownerChannel?;
+    private loopManager?;
+    private reloadConfig?;
     constructor(stateDir: string, session: SessionHandle, log: (line: string) => void);
     start(): Promise<void>;
     close(): Promise<void>;
+    /** Attach only the already-started supervisor-owned channel client. */
+    setOwnerChannel(ownerChannel: OwnerChannelHandle | undefined): void;
+    setLoopManager(loopManager: ScheduledLoopManagerHandle | undefined): void;
+    setConfigReloader(reloadConfig: (() => Promise<unknown>) | undefined): void;
     private accept;
     private handle;
     private write;

package/dist/session/control.js

@@ -95,6 +95,9 @@ export class RoleControlServer {
     socketPath;
     token;
     sockets = new Set();
+    ownerChannel;
+    loopManager;
+    reloadConfig;
     constructor(stateDir, session, log) {
         this.session = session;
         this.log = log;
@@ -127,6 +130,16 @@ export class RoleControlServer {
         await new Promise(resolve => this.server.close(() => resolve()));
         rmSync(this.socketPath, { force: true });
     }
+    /** Attach only the already-started supervisor-owned channel client. */
+    setOwnerChannel(ownerChannel) {
+        this.ownerChannel = ownerChannel;
+    }
+    setLoopManager(loopManager) {
+        this.loopManager = loopManager;
+    }
+    setConfigReloader(reloadConfig) {
+        this.reloadConfig = reloadConfig;
+    }
     accept(socket) {
         this.sockets.add(socket);
         socket.setEncoding('utf8');
@@ -202,7 +215,9 @@ export class RoleControlServer {
                     // Answer on QUEUE ACCEPTANCE, not on turn completion. A turn can run
                     // for minutes; blocking here made every `send` into a busy agent time
                     // out, and the timeout was then reported as a dead agent.
-                    const queued = await this.session.queuePrompt(request.text);
+                    const queued = await this.session.queuePrompt(request.text, {
+                        origin: { kind: 'local-console' },
+                    });
                     this.write(socket, {
                         version: 1, id: request.id, ok: true,
                         result: {
@@ -224,9 +239,47 @@ export class RoleControlServer {
                     return;
                 }
                 case 'interrupt':
-                    await this.session.interrupt();
+                    await this.session.interrupt('local-console');
                     this.write(socket, { version: 1, id: request.id, ok: true });
                     return;
+                case 'loop_status': {
+                    if (!this.loopManager)
+                        throw new SessionControlError('rejected', 'scheduled loops are unavailable for this role');
+                    this.write(socket, { version: 1, id: request.id, ok: true, result: this.loopManager.status() });
+                    return;
+                }
+                case 'loop_run_now':
+                case 'loop_disable':
+                case 'loop_enable': {
+                    if (request.version !== 2 || !request.loop)
+                        throw new SessionControlError('rejected', 'version 2 and loop name are required');
+                    if (!this.loopManager)
+                        throw new SessionControlError('rejected', 'scheduled loops are unavailable for this role');
+                    const result = request.command === 'loop_run_now'
+                        ? await this.loopManager.runNow(request.loop)
+                        : request.command === 'loop_disable'
+                            ? this.loopManager.disable(request.loop)
+                            : this.loopManager.enable(request.loop);
+                    this.write(socket, { version: 1, id: request.id, ok: true, result });
+                    return;
+                }
+                case 'reload_config': {
+                    if (request.version !== 2 || !this.reloadConfig)
+                        throw new SessionControlError('rejected', 'config reload is unavailable for this role');
+                    this.write(socket, {
+                        version: 1, id: request.id, ok: true, result: await this.reloadConfig(),
+                    });
+                    return;
+                }
+                case 'owner_channel_manage': {
+                    if (!request.ownerChannel || typeof request.ownerChannel.action !== 'string')
+                        throw new SessionControlError('rejected', 'owner-channel management action is required');
+                    if (!this.ownerChannel)
+                        throw new SessionControlError('rejected', 'owner channel is disabled or unavailable for this role');
+                    const result = await this.ownerChannel.manage(request.ownerChannel);
+                    this.write(socket, { version: 1, id: request.id, ok: true, result });
+                    return;
+                }
                 case 'events_since': {
                     const since = Number.isFinite(request.since) ? Number(request.since) : 0;
                     const events = this.session.eventsSince(since);
@@ -323,7 +376,7 @@ export async function controlRequest(stateDir, request, timeoutMs = 120_000) {
             socket.end();
         });
         socket.once('connect', () => socket.write(JSON.stringify({
-            version: 1, id, token, ...request,
+            version: 2, id, token, ...request,
         }) + '\n'));
     });
 }

package/dist/session/types.d.ts

@@ -1,6 +1,21 @@
 import type { SessionBackendId } from '../config.js';
 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';
+export type PromptOrigin = {
+    kind: 'startup';
+} | {
+    kind: 'local-console';
+} | {
+    kind: 'owner';
+    requestId: string;
+} | {
+    kind: 'fleet-monitor';
+} | {
+    kind: 'scheduled-loop';
+    loop: string;
+    runId: string;
+};
 /**
  * Two independent facts about one turn, deliberately kept apart:
  *
@@ -19,6 +34,10 @@ export interface TurnResult {
     outcome: TurnOutcome;
     succeeded: boolean;
     detail?: string;
+    /** Present only when fleet can prove what initiated a cancelled turn. */
+    cancellationSource?: TurnCancellationSource;
+    /** Final assistant text captured structurally by a backend, when available. */
+    output?: string;
 }
 /**
  * Why a control operation failed. The distinctions exist because collapsing
@@ -39,6 +58,7 @@ export interface QueuedPrompt {
     promptId: string;
     /** Turns already queued ahead of this one. 0 means it starts immediately. */
     queuedBehind: number;
+    origin?: PromptOrigin;
     /** The turn's terminal result. Never rejects. */
     completion: Promise<TurnResult>;
 }
@@ -75,10 +95,14 @@ export declare function classifyChildExit(code: number | null, signal: string |
 /** The single definition of terminal success. Nothing else may re-derive it. */
 export declare const isTerminalSuccess: (outcome: TurnOutcome) => boolean;
 /** Build a TurnResult with `succeeded` always consistent with `outcome`. */
-export declare function turnResult(accepted: boolean, outcome: TurnOutcome, detail?: string): TurnResult;
+export declare function turnResult(accepted: boolean, outcome: TurnOutcome, detail?: string, output?: string, cancellationSource?: TurnCancellationSource): TurnResult;
 export interface SubmitPromptOptions {
     /** Cancel active work before delivering this prompt. */
     interrupt?: boolean;
+    /** Internal provenance; ordinary callers must leave this unset. */
+    interruptSource?: TurnCancellationSource;
+    /** Typed in-process provenance. Text markers never grant this origin. */
+    origin?: PromptOrigin;
     /** Use the ACP steering extension when available; ignored by other backends. */
     steer?: boolean;
 }
@@ -105,6 +129,8 @@ export interface SessionEvent {
     title?: string;
     status?: string;
     stopReason?: string;
+    origin?: PromptOrigin;
+    cancellationSource?: TurnCancellationSource;
     options?: Array<{
         optionId: string;
         name: string;
@@ -133,7 +159,7 @@ export interface SessionHandle {
     queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
     /** Queue a prompt and wait for its terminal result. */
     submitPrompt(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
-    interrupt(): Promise<void>;
+    interrupt(source?: TurnCancellationSource): Promise<void>;
     respondPermission(permissionId: string, optionId: string): boolean;
     eventsSince(seq: number): SessionEvent[];
     subscribe(listener: (event: SessionEvent) => void): () => void;

package/dist/session/types.js

@@ -37,6 +37,9 @@ export function classifyChildExit(code, signal) {
 /** The single definition of terminal success. Nothing else may re-derive it. */
 export const isTerminalSuccess = (outcome) => outcome === 'completed';
 /** Build a TurnResult with `succeeded` always consistent with `outcome`. */
-export function turnResult(accepted, outcome, detail) {
-    return { accepted, outcome, succeeded: isTerminalSuccess(outcome), detail };
+export function turnResult(accepted, outcome, detail, output, cancellationSource) {
+    return {
+        accepted, outcome, succeeded: isTerminalSuccess(outcome), detail, output,
+        ...(outcome === 'cancelled' && cancellationSource ? { cancellationSource } : {}),
+    };
 }

package/dist/spawn.js

@@ -4,7 +4,7 @@ import { join } from 'node:path';
 import { parse, stringify } from 'yaml';
 import { agentDir, fleetDDir } from './paths.js';
 import { validateIsolationConfig } from './isolation/policy.js';
-import { loadConfig, resolveAuthProxy, resolveModelChain, resolveMonitorConfig, resolvePermissions, resolveRoleModel, resolveWorklogPolicy, validateMonitorConfig, } from './config.js';
+import { loadConfig, resolveAuthProxy, resolveModelChain, resolveMonitorConfig, resolveOwnerChannelConfig, resolvePermissions, resolveRoleModel, resolveWorklogPolicy, validateMonitorConfig, } from './config.js';
 import { applyRole, up } from './ops.js';
 import { START_STAGGER_FILE } from './runner.js';
 import { buildProvenance, daemonIdentityProvisioner, ensureIdentity, provenanceOf, withCreationTransaction, writeProvenance, writeRoleFile, } from './creation.js';
@@ -186,12 +186,13 @@ export function spawnDryRun(o) {
     const defaultHarness = cfg.defaults.harness ?? 'claude-code';
     const inheritsModelDefaults = harness === defaultHarness && raw.model !== null;
     const model = resolveRoleModel(raw.model, raw.harness, cfg.defaults);
+    const session = raw.session ?? cfg.defaults.session ?? 'tmux';
     const resolvedRole = {
         ...raw,
         name: o.name,
         sourceFile: o.temp ? '(temp dry-run)' : join(fleetDDir(), `${o.name}.yaml`),
         harness,
-        session: raw.session ?? cfg.defaults.session ?? 'tmux',
+        session,
         session_options: raw.session_options,
         permissions: resolvePermissions(cfg.defaults.permissions, raw.permissions),
         permissionsDeclared: raw.permissions !== undefined || cfg.defaults.permissions !== undefined,
@@ -203,6 +204,7 @@ export function spawnDryRun(o) {
         harness_options: Object.keys(harnessOptions).length ? harnessOptions : undefined,
         isolation: raw.isolation ?? cfg.defaults.isolation,
         monitor: resolveMonitorConfig(cfg.defaults.monitor, raw.monitor),
+        owner_channel: resolveOwnerChannelConfig(cfg.defaults.owner_channel, raw.owner_channel, session),
         worklog: resolveWorklogPolicy(cfg.defaults.worklog, raw.worklog),
         auth_proxy: resolveAuthProxy(cfg.defaults.auth_proxy, raw.auth_proxy),
     };
@@ -378,11 +380,12 @@ async function spawnTempInner(o, binPath, launch, tx, guarantee, onStage) {
     const harness = o.harness ?? defaultHarness ?? 'claude-code';
     const inheritsModelDefaults = harness === (defaultHarness ?? 'claude-code') && o.model !== null;
     const model = resolveRoleModel(o.model, o.harness, cfg.defaults);
+    const session = o.session ?? cfg.defaults.session ?? 'tmux';
     const role = {
         ...fromOpts, // includes `isolation` when --isolation-file was given
         name: o.name,
         harness,
-        session: o.session ?? cfg.defaults.session ?? 'tmux',
+        session,
         identity: o.identity ?? o.name,
         model,
         model_chain: resolveModelChain(model, fromOpts.model_chain ?? (inheritsModelDefaults
@@ -393,6 +396,7 @@ async function spawnTempInner(o, binPath, launch, tx, guarantee, onStage) {
         permissionsDeclared: fromOpts.permissions !== undefined || cfg.defaults.permissions !== undefined,
         // Temp agents inherit the fleet-wide monitor defaults via the snapshot (design §2).
         monitor: resolveMonitorConfig(cfg.defaults.monitor, fromOpts.monitor),
+        owner_channel: resolveOwnerChannelConfig(cfg.defaults.owner_channel, fromOpts.owner_channel, session),
         worklog: resolveWorklogPolicy(cfg.defaults.worklog, fromOpts.worklog),
         auth_proxy: resolveAuthProxy(cfg.defaults.auth_proxy, fromOpts.auth_proxy),
         sourceFile: '(temp)',

package/dist/supervisor/systemd.js

@@ -1,5 +1,5 @@
 import { mkdirSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
+import { delimiter, dirname, join } from 'node:path';
 import { userInfo } from 'node:os';
 import { home } from '../paths.js';
 import { realExec } from '../exec.js';
@@ -15,6 +15,8 @@ export const busHint = (stderr) => /user scope bus|XDG_RUNTIME_DIR/.test(stderr)
         `\n      (if linger is already on: export XDG_RUNTIME_DIR=/run/user/$(id -u))`
     : '';
 export const unitFor = (name) => `ours-fleet-agent@${name}.service`;
+/** Quote a systemd unit argument and escape its specifier marker. */
+const unitArg = (value) => `"${value.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/%/g, '%%')}"`;
 /**
  * systemd's own ActiveState vocabulary, classified. `activating` covers
  * `auto-restart` — the unit is mid-restart, not stopped, so its context stands.
@@ -60,6 +62,13 @@ export function makeSystemdBackend(exec = realExec) {
         async init(binPath) {
             const msgs = [];
             const unitDir = join(home(), '.config', 'systemd', 'user');
+            // Lingering user units often start before a login shell imports its PATH.
+            // Pin the Node runtime and persist the install-time PATH so the runner and
+            // children such as `ours-mcp proxy` resolve the same tools after reboot.
+            const servicePath = [...new Set([
+                    dirname(process.execPath),
+                    ...(process.env.PATH ?? '').split(delimiter),
+                ].filter(Boolean))].join(delimiter);
             mkdirSync(unitDir, { recursive: true });
             writeFileSync(join(unitDir, UNIT_TEMPLATE), `[Unit]
 Description=ours-fleet agent %i
@@ -67,7 +76,8 @@ After=default.target
 
 [Service]
 Type=simple
-ExecStart=${binPath} _run %i
+Environment="PATH=${servicePath.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/%/g, '%%')}"
+ExecStart=${unitArg(process.execPath)} ${unitArg(binPath)} _run %i
 # The RUNNER owns the child-session restart loop, with a counted, backed-off
 # circuit breaker (3.2). systemd must only recover the runner PROCESS crashing —
 # Restart=always here would resume the uncounted two-second relaunch loop, and

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "0.11.1",
+  "version": "0.13.0",
   "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",