@ours.network/fleet 0.12.0 → 0.13.1

package/dist/runner.js

@@ -19,6 +19,8 @@ import { classifyShellStatus } from './session/types.js';
 import { effectiveModelForRole, modelRecoveryHeld, reconcileModelRecovery, recordModelFailure, classifyFailureText, } from './model-recovery.js';
 import { rotateWorklog } from './worklog.js';
 import { OwnerChannel } from './owner-channel/channel.js';
+import { RoleTurnArbiter } from './session/arbiter.js';
+import { ScheduledLoopManager, } from './loops/manager.js';
 const defaultDeps = () => ({
     tmux: new Tmux(),
     exec: realExec,
@@ -418,6 +420,12 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     let monitorLoop;
     let acpStartupComplete = false;
     let ownerChannel;
+    let loopManager;
+    let arbiter;
+    let reloadLoopConfig;
+    let loopGeneration = JSON.stringify((role.loops ?? []).map(loop => [
+        loop.name, loop.definitionHash, loop.promptHash,
+    ]));
     if (sessionBackend === 'acp') {
         const perms = role.permissions ?? resolvePermissions(undefined, undefined);
         // Say once, at startup, that this role will decide permission requests by
@@ -434,10 +442,12 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             stateDir: dir,
             mode,
             permissions: perms,
+            modeId: adapter.acpPermissionModeId?.(role),
             log: deps.log,
         });
         pid = acpSession.pid;
-        sessionHandle = acpSession;
+        arbiter = new RoleTurnArbiter(acpSession);
+        sessionHandle = arbiter;
         unsubscribeRecovery = acpSession.subscribe(event => {
             if (event.kind !== 'error' || !event.text)
                 return;
@@ -445,7 +455,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             if (evidence)
                 resolvedMonitorDeps.onFailureEvidence?.(evidence);
         });
-        control = new RoleControlServer(dir, acpSession, deps.log);
+        control = new RoleControlServer(dir, arbiter, deps.log);
         await control.start();
         resolvedMonitorDeps.delivery = {
             // A wake is only delivered when its turn TERMINATES successfully. A
@@ -457,7 +467,11 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 // steer into the live turn instead; after it completes, honor the
                 // configured interrupt policy normally.
                 const interrupt = options?.interrupt === true && acpStartupComplete;
-                const result = await acpSession.submitPrompt(text, { ...options, interrupt, steer: true });
+                const result = await arbiter.submitPrompt(text, {
+                    ...options, interrupt, steer: true,
+                    ...(interrupt ? { interruptSource: 'fleet-monitor' } : {}),
+                    origin: { kind: 'fleet-monitor' },
+                });
                 const steered = result.accepted
                     && (result.detail === 'injected' || result.detail === 'startedNewTurn');
                 return {
@@ -473,7 +487,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
         // Wait for the first turn's TERMINAL result. An agent that accepts the
         // startup prompt and then refuses it has not started; logging the role as
         // up would hide a role that never read its briefing.
-        const starting = acpSession.submitPrompt(firstPrompt);
+        const starting = arbiter.submitPrompt(firstPrompt, { origin: { kind: 'startup' } });
         // Monitoring starts immediately. The delivery adapter above downgrades
         // interruption to steering until this startup turn reaches a terminal
         // success, so there is neither a deaf gap nor a boot-cancellation loop.
@@ -507,7 +521,7 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
             ownerChannel = deps.createOwnerChannel({
                 role: name,
                 config: role.owner_channel,
-                session: acpSession,
+                session: arbiter,
                 stateDir: dir,
                 env: role.env,
                 log: deps.log,
@@ -525,6 +539,48 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
                 throw new Error(`[${name}] owner channel failed to start: `
                     + `${error?.message ?? String(error)}`);
             }
+            control.setOwnerChannel(ownerChannel);
+        }
+        reloadLoopConfig = async () => {
+            const nextRole = findRole(loadConfig(configPath), name);
+            const definitions = nextRole.loops ?? [];
+            const generation = JSON.stringify(definitions.map(loop => [
+                loop.name, loop.definitionHash, loop.promptHash,
+            ]));
+            if (generation === loopGeneration && (loopManager || !definitions.length))
+                return { changed: false, loops: definitions.length };
+            if (!loopManager && definitions.length) {
+                loopManager = new ScheduledLoopManager(name, definitions, dir, arbiter, {
+                    now: deps.now,
+                    setTimer: (callback, ms) => setTimeout(callback, ms),
+                    clearTimer: timer => clearTimeout(timer),
+                    log: deps.log,
+                });
+                control.setLoopManager(loopManager);
+                loopManager.start();
+            }
+            else {
+                loopManager?.reconcile(definitions);
+            }
+            loopGeneration = generation;
+            deps.log(`[${name}] scheduled loops reloaded (${definitions.length} definitions)`);
+            return { changed: true, loops: definitions.length };
+        };
+        control.setConfigReloader(reloadLoopConfig);
+        if (role.loops?.length) {
+            try {
+                loopManager = new ScheduledLoopManager(name, role.loops, dir, arbiter, {
+                    now: deps.now,
+                    setTimer: (callback, ms) => setTimeout(callback, ms),
+                    clearTimer: timer => clearTimeout(timer),
+                    log: deps.log,
+                });
+                control.setLoopManager(loopManager);
+                loopManager.start();
+            }
+            catch (error) {
+                deps.log(`[${name}] scheduled loop manager unavailable: ${error?.name ?? 'Error'}`);
+            }
         }
     }
     else {
@@ -546,10 +602,34 @@ export async function runOnce(name, opts = {}, partialDeps = {}) {
     // pane pid is known and is stopped when that pid dies (task dies with runner).
     monitorLoop ??= monitor?.run(pid);
     const start = deps.now();
-    while (sessionHandle.isAlive())
+    let nextLoopReloadAt = deps.now() + 30_000;
+    let lastReloadError = '';
+    while (sessionHandle.isAlive()) {
         await deps.sleep(2000);
-    if (ownerChannel)
+        const now = deps.now();
+        if (reloadLoopConfig && now >= nextLoopReloadAt) {
+            nextLoopReloadAt = now + 30_000;
+            try {
+                await reloadLoopConfig();
+                lastReloadError = '';
+            }
+            catch (error) {
+                const message = error?.message ?? String(error);
+                if (message !== lastReloadError)
+                    deps.log(`[${name}] scheduled loop config reload rejected: ${message}`);
+                lastReloadError = message;
+            }
+        }
+    }
+    if (loopManager) {
+        control?.setLoopManager(undefined);
+        await loopManager.stop();
+    }
+    control?.setConfigReloader(undefined);
+    if (ownerChannel) {
+        control?.setOwnerChannel(undefined);
         await ownerChannel.close();
+    }
     if (monitor) {
         monitor.stop();
         await monitorLoop;

package/dist/session/acp.d.ts

@@ -1,5 +1,5 @@
 import type { CommonPermissions } from '../config.js';
-import type { ExitRecord, QueuedPrompt, SessionEvent, SessionHandle, SessionSnapshot, SubmitPromptOptions, TurnOutcome, TurnResult } from './types.js';
+import type { ExitRecord, QueuedPrompt, SessionEvent, SessionHandle, SessionSnapshot, SubmitPromptOptions, TurnCancellationSource, TurnOutcome, TurnResult } from './types.js';
 export interface AcpSessionOptions {
     name: string;
     argv: string[];
@@ -8,6 +8,8 @@ export interface AcpSessionOptions {
     stateDir: string;
     mode: 'fresh' | 'resume';
     permissions: CommonPermissions;
+    /** Native permission-mode id to request via session/set_mode; undefined keeps the agent default. */
+    modeId?: string;
     log(line: string): void;
 }
 /**
@@ -50,7 +52,8 @@ export declare class AcpSession implements SessionHandle {
      */
     queuePrompt(text: string, options?: SubmitPromptOptions): Promise<QueuedPrompt>;
     submitPrompt(text: string, options?: SubmitPromptOptions): Promise<TurnResult>;
-    interrupt(): Promise<void>;
+    interrupt(source?: TurnCancellationSource): Promise<void>;
+    private cancelActive;
     respondPermission(permissionId: string, optionId: string): boolean;
     eventsSince(seq: number): SessionEvent[];
     subscribe(listener: (event: SessionEvent) => void): () => void;

package/dist/session/acp.js

@@ -118,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 {
@@ -147,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();
@@ -164,6 +178,7 @@ export class AcpSession {
         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',
@@ -236,31 +251,55 @@ export class AcpSession {
             this.sessionId = created.sessionId;
         }
         writeFileSync(this.sessionFile, this.sessionId + '\n', { mode: 0o600 });
+        // Deliver the configured permission mode whichever way the session came up
+        // (new, resume or load) — the launch flag never reaches an ACP agent. A
+        // refusal is loud but never fatal: the session then simply runs at the
+        // agent's own default.
+        if (this.options.modeId) {
+            try {
+                await this.connection.agent.request(acp.methods.agent.session.setMode, {
+                    sessionId: this.sessionId,
+                    modeId: this.options.modeId,
+                });
+            }
+            catch (e) {
+                this.options.log(`[${this.options.name}] acp: session/set_mode "${this.options.modeId}" failed ` +
+                    `(${e instanceof Error ? e.message : String(e)}) — session runs at the agent default permission mode`);
+            }
+        }
         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.activeTurn = { id: turnId, output: '' };
-        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, this.activeTurn?.id === turnId ? this.activeTurn.output : undefined);
+            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, this.activeTurn?.id === turnId ? this.activeTurn.output : undefined);
@@ -320,12 +359,17 @@ export class AcpSession {
         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 => {
@@ -341,16 +385,23 @@ export class AcpSession {
         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 } }
@@ -373,34 +424,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', {
                     turnId: this.activeTurn?.id,
-                    text: update.content.type === 'text' ? update.content.text : `[${update.content.type}]`,
+                    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', {
                     turnId: this.activeTurn?.id,
-                    text: update.content.type === 'text' ? update.content.text : `[${update.content.type}]`,
+                    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', {
                     turnId: this.activeTurn?.id,
-                    toolCallId: update.toolCallId,
-                    title: update.title,
+                    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', {
                     turnId: this.activeTurn?.id,
-                    toolCallId: update.toolCallId,
-                    title: update.title ?? undefined,
+                    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'));
     });
 }