@ours.network/fleet 0.12.0 → 0.13.0

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,8 @@ 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;
 }
@@ -41,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>;
 }
@@ -77,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, output?: 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;
 }
@@ -107,6 +129,8 @@ export interface SessionEvent {
     title?: string;
     status?: string;
     stopReason?: string;
+    origin?: PromptOrigin;
+    cancellationSource?: TurnCancellationSource;
     options?: Array<{
         optionId: string;
         name: string;
@@ -135,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, output) {
-    return { accepted, outcome, succeeded: isTerminalSuccess(outcome), detail, output };
+export function turnResult(accepted, outcome, detail, output, cancellationSource) {
+    return {
+        accepted, outcome, succeeded: isTerminalSuccess(outcome), detail, output,
+        ...(outcome === 'cancelled' && cancellationSource ? { cancellationSource } : {}),
+    };
 }

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.12.0",
+  "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",