@ours.network/fleet 1.2.0-nightly.53 → 1.2.0-nightly.55

package/README.md

@@ -10,8 +10,9 @@ turns such sessions into **roles**: long-lived agents that
 
 - **run through structured managed sessions** behind one provider-neutral
   agent-session interface, which you can inspect or prompt,
-- are **supervised** — systemd (Linux) or launchd (macOS) restarts them on crash
-  and brings them back after a reboot,
+- are **supervised** — one Fleet systemd service (Linux) or LaunchAgent (macOS)
+  runs their existing agent runners, restarts them on crash, and restores the
+  desired running roster at boot or login,
 - **resume their context** across restarts (when the harness supports it),
 - **bind an ours.network identity**, so you — and every other agent — can message
   them by name over an end-to-end-encrypted channel
@@ -44,11 +45,11 @@ brain: { inline: { harness: codex, session: codex-app-server } }
 
 ```
 ~/fleet.yaml + ~/fleet/{agents,agent_templates,roles,brains,room_templates}/*.yaml   your declaration
-        │  ours-fleet up
+        │  ours-fleet init, then up
         ▼
-briefing.md per role  ──►  agent session adapter  ──►  native app-server or ACP transport
-        ▲                        │
- systemd --user / launchd ───────┘   restart on crash, start at boot/login
+one Fleet OS service  ──►  private member catalog + existing agent runners
+                                               │
+briefing.md per member  ──►  session adapter  ──►  native app-server or ACP transport
 ```
 
 Each role gets a state dir (`~/.ours-fleet/agents/<Name>/`) holding its briefing,
@@ -81,9 +82,10 @@ The state dir contract:
 | a harness CLI, logged in | the agent itself | e.g. Claude Code (`claude`) or Codex CLI (`codex`) |
 | `ours` CLI + shared daemon | identity + agent-to-agent messaging | `ours-install client --config /absolute/private/profile.json --integrations fleet --fleet-settings /absolute/fleet-settings.json` |
 
-Linux only: `ours-fleet init` enables *linger* so roles run without a login session
-and survive reboots. macOS: launchd agents start **at login** (no linger
-equivalent); logs land in `~/.ours-fleet/logs/`.
+Linux only: `ours-fleet init` enables *linger* so Fleet runs without a login session
+and restores running members after reboot. On macOS the Fleet LaunchAgent starts
+**at login** (no linger equivalent). Member logs live in each member's state
+directory; use `ours-fleet logs <Name>` to read them.
 
 ## Install
 
@@ -103,6 +105,12 @@ maintained adapters require Node 22 or newer.
 Each OS user manages their own fleet — to host roles under a sandboxed account,
 become that account and repeat.
 
+When upgrading from per-agent services, coordinate package installation with
+explicit `ours-fleet init`. Preserve operator readiness hooks on the common
+parent before migration; new task/temporary creation requires that parent.
+See the [migration and rollback runbook](docs/fleet-migration.md)
+for changed stop/restart behaviour and legacy task transfer limits.
+
 ## Quickstart
 
 ```sh
@@ -331,9 +339,9 @@ Installs predating the stamp are compared by hashing their `dist/`, so two of
 those are still told apart.
 
 A permanent role brought up via `-c custom.yaml` remembers that file (`.config-path`
-in its state dir) across supervisor-triggered restarts — systemd/launchd re-invoke the
-agent process with no arguments, so without this the role would silently fall back to
-the default `~/fleet.yaml` on its very first crash-restart and fail to resolve.
+in its state dir and its private member registration) across supervisor-triggered
+restarts. Its runner resolves that original configuration instead of falling back
+to the default `~/fleet.yaml`.
 
 ## split configuration field reference
 
@@ -1920,3 +1928,5 @@ Prerelease rollout requires this Fleet capability to be published first, then th
 installer's normal generated version/integrity lock updated, then installer and
 App released. The currently pinned Fleet nightly.41 does not support v2 grants.
 These source changes do not publish, merge, or deploy any component.
+
+See [ACP file sending](docs/acp-files.md) for the opt-in same-chat `send_file` flow and supported configurations.

package/dist/agent-ours/bridge.js

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { openExportFile } from '../file-delivery/reader.js';
 import { createHash } from 'node:crypto';
 import { connect } from 'node:net';
 import { access, mkdir, open, readFile } from 'node:fs/promises';
@@ -71,7 +72,7 @@ export async function runBridge(descriptorPath) {
                         value = false;
                     }
                 }
-                else if (op === 'read-open' || op === 'write-open') {
+                else if (op === 'read-open' || op === 'write-open' || op === 'export-open') {
                     if (handles.size >= 32 ||
                         typeof args.handle !== 'string' ||
                         handles.has(args.handle) ||
@@ -80,8 +81,9 @@ export async function runBridge(descriptorPath) {
                     const path = resolve(args.path);
                     if (op === 'write-open')
                         await mkdir(dirname(path), { recursive: true });
-                    const file = await open(path, op === 'write-open' ? 'w' : 'r');
-                    handles.set(args.handle, { file, call, write: op === 'write-open' });
+                    const file = op === 'export-open' ? await openExportFile(args.root, process.cwd(), args.path) : await open(path, op === 'write-open' ? 'w' : 'r');
+                    const stat = await file.stat();
+                    handles.set(args.handle, { file, call, write: op === 'write-open', ...(op === 'export-open' ? { original: { size: stat.size, mtimeMs: stat.mtimeMs, ctimeMs: stat.ctimeMs } } : {}) });
                     value =
                         op === 'write-open'
                             ? path
@@ -105,6 +107,11 @@ export async function runBridge(descriptorPath) {
                             value = null;
                         }
                         else if (op === 'read' && !row.write) {
+                            if (row.original) {
+                                const stat = await row.file.stat();
+                                if (!stat.isFile() || stat.nlink !== 1 || stat.size !== row.original.size || stat.mtimeMs !== row.original.mtimeMs || stat.ctimeMs !== row.original.ctimeMs)
+                                    throw Error('EXPORT_SOURCE_CHANGED');
+                            }
                             const buffer = Buffer.alloc(MAX_CHUNK_BYTES);
                             const { bytesRead } = await row.file.read(buffer);
                             value = bytesRead ? buffer.subarray(0, bytesRead).toString('base64') : null;

package/dist/agent-ours/file-rpc.d.ts

@@ -1,3 +1,4 @@
+import type { ExportRoot } from '../file-delivery/reader.js';
 import type { FileExecutionContext } from '@ours.network/mcp/server';
 import type { ToolRequestExtra } from '@ours.network/mcp/dist/types/mcp/tool.js';
 import { type Wire } from './wire.js';
@@ -16,6 +17,13 @@ export declare class FileCallbacks implements FileExecutionContext {
         body: ReadableStream<Uint8Array<ArrayBufferLike>>;
         close: () => Promise<void>;
     }>;
+    readExport(path: string, root: ExportRoot, extra: ToolRequestExtra): Promise<{
+        filename: any;
+        size: any;
+        body: ReadableStream<Uint8Array<ArrayBufferLike>>;
+        close: () => Promise<void>;
+    }>;
+    private openRead;
     write(path: string, body: ReadableStream<Uint8Array>, extra: ToolRequestExtra): Promise<{
         path: string;
         size: number;

package/dist/agent-ours/file-rpc.js

@@ -59,14 +59,24 @@ export class FileCallbacks {
         return (await this.rpc(String(extra.requestId), 'probe', { path }, extra.signal)) === true;
     }
     async read(path, extra) {
+        return this.openRead(path, extra);
+    }
+    async readExport(path, root, extra) {
+        return this.openRead(path, extra, root);
+    }
+    async openRead(path, extra, root) {
         const call = String(extra.requestId), handle = randomUUID();
-        const meta = await this.rpc(call, 'read-open', { path, handle }, extra.signal);
+        const meta = await this.rpc(call, root ? 'export-open' : 'read-open', { path, handle, ...(root ? { root } : {}) }, extra.signal);
         if (!meta ||
             typeof meta.filename !== 'string' ||
             !Number.isSafeInteger(meta.size) ||
             meta.size < 0)
             throw Error('INVALID_FILE_METADATA');
+        let closed = false;
         const close = async () => {
+            if (closed)
+                return;
+            closed = true;
             await this.rpc(call, 'close', { handle }, new AbortController().signal).catch(() => { });
         };
         const body = new ReadableStream({

package/dist/agent-ours/harness.js

@@ -1,10 +1,13 @@
-import { readFileSync } from 'node:fs';
+import { existsSync, readFileSync } from 'node:fs';
+import { dirname, join, resolve } from 'node:path';
+import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
+import { resolveBundledAcpAgent } from '../harness/acp-agent.js';
 /** Do not pass the supervisor's ours connection credentials to harness children. */
 export function managedChildEnvironment(input) {
     const out = {};
     for (const [key, value] of Object.entries(input)) {
-        if (value === undefined || (/^OURS_/i.test(key) && !key.startsWith('OURS_FLEET_')))
+        if (key === 'FLEET_CURRENT_CHAT_FILES' || value === undefined || (/^OURS_/i.test(key) && !key.startsWith('OURS_FLEET_')))
             continue;
         out[key] = value;
     }
@@ -13,6 +16,9 @@ export function managedChildEnvironment(input) {
 }
 /** Replace ours only; retain the user's ordinary harness configuration and plugins. */
 export function prepareManagedHarness(role, stateDir, cwd, descriptor, env) {
+    const child = managedChildEnvironment({ ...process.env, ...env });
+    if (role.file_delivery?.enabled)
+        qualifyFileHarness(role, cwd, child);
     const bridge = fileURLToPath(new URL('./bridge.js', import.meta.url));
     const server = {
         name: 'ours',
@@ -37,7 +43,6 @@ export function prepareManagedHarness(role, stateDir, cwd, descriptor, env) {
         },
         plugins: { 'ours@ours-codex-marketplace': { enabled: false } },
     };
-    const child = managedChildEnvironment({ ...process.env, ...env });
     if (role.harness === 'codex') {
         const config = child.CODEX_CONFIG ? JSON.parse(child.CODEX_CONFIG) : {};
         child.CODEX_CONFIG = JSON.stringify({
@@ -70,3 +75,42 @@ export function managedClaudeMeta(base) {
         },
     };
 }
+/** Bounded stock-adapter support; opt-in never silently erases unrelated tools. */
+function qualifyFileHarness(role, cwd, child) {
+    if (process.platform !== 'linux')
+        throw Error('CURRENT_CHAT_DELIVERY_UNAVAILABLE: Linux required');
+    if (role.session !== 'acp' || role.session_options?.acp?.command)
+        throw Error('CURRENT_CHAT_DELIVERY_UNAVAILABLE: stock ACP adapter required');
+    if (role.harness === 'claude-code') {
+        if (resolveBundledAcpAgent('@agentclientprotocol/claude-agent-acp', 'claude-agent-acp', 'claude-agent-acp').version !== '0.63.0')
+            throw Error('CURRENT_CHAT_DELIVERY_UNAVAILABLE: qualified Claude ACP 0.63.0 required');
+        const options = role.harness_options ?? {}, servers = options.mcp_servers;
+        if (options.mcp_servers_only !== true || !servers || Object.keys(servers).length !== 1 || !servers.ours)
+            throw Error('CURRENT_CHAT_DELIVERY_UNAVAILABLE: Claude requires explicit mcp_servers_only and a single ours connector');
+        return;
+    }
+    if (role.harness !== 'codex' || !child.OURS_FLEET_CODEX_ACP_MANIFEST || child.OURS_FLEET_CODEX_DISABLE_INHERITED_MCP === '1')
+        throw Error('CURRENT_CHAT_DELIVERY_UNAVAILABLE: managed Codex inventory proxy required');
+    const config = JSON.parse(child.CODEX_CONFIG ?? '{}');
+    if (config.mcp_servers?.ours?.enabled === false)
+        throw Error('CURRENT_CHAT_DELIVERY_UNAVAILABLE: ours MCP disabled');
+    // Public inventory sees effective injected config. Before replacing ours, refuse
+    // inherited TOML connector configuration, including disabled/project/profile
+    // entries. No TOML guessing or override of an operator's explicit disable.
+    const home = child.CODEX_HOME ?? join(child.HOME ?? homedir(), '.codex');
+    const paths = [join(home, 'config.toml')];
+    const profile = role.harness_options?.profile;
+    if (typeof profile === 'string')
+        paths.push(join(home, profile + '.config.toml'));
+    for (let p = resolve(cwd); p !== resolve(child.HOME ?? homedir());) {
+        paths.push(join(p, '.codex/config.toml'));
+        const next = dirname(p);
+        if (next === p)
+            break;
+        p = next;
+    }
+    for (const path of new Set(paths))
+        if (existsSync(path) && /mcp_servers|mcpServers/.test(readFileSync(path, 'utf8')))
+            throw Error('CURRENT_CHAT_DELIVERY_UNAVAILABLE: inherited Codex MCP configuration requires inventory support before replacement');
+    child.FLEET_CURRENT_CHAT_FILES = '1';
+}

package/dist/agent-ours/mcp-endpoint.d.ts

@@ -1,5 +1,8 @@
+import type { FileDeliveryInput, DeliveredFile } from '../file-delivery/types.js';
+import type { ToolRequestExtra } from '@ours.network/mcp/dist/types/mcp/tool.js';
 import type { ApplicationIdentityStore } from '@ours.network/mcp/application-identities';
 import type { OursClient } from '@ours.network/sdk/client';
+import { FileCallbacks } from './file-rpc.js';
 import type { AgentOursRuntime } from './runtime.js';
 export interface EndpointOptions {
     socket: string;
@@ -9,6 +12,8 @@ export interface EndpointOptions {
     client: OursClient;
     identities: ApplicationIdentityStore;
     remoteDaemonFiles: boolean;
+    currentChatFileDirectory?: string;
+    currentChatFile?: (input: FileDeliveryInput, extra: ToolRequestExtra, files: FileCallbacks) => Promise<DeliveredFile>;
 }
 export declare function startMcpEndpoint(options: EndpointOptions): Promise<{
     close(): Promise<void>;

package/dist/agent-ours/mcp-endpoint.js

@@ -1,3 +1,4 @@
+import * as managedMcp from '@ours.network/mcp/server';
 import { createServer } from 'node:net';
 import { chmod, unlink } from 'node:fs/promises';
 import { timingSafeEqual } from 'node:crypto';
@@ -6,6 +7,8 @@ import { JSONRPCMessageSchema } from '@modelcontextprotocol/sdk/types.js';
 import { FileCallbacks } from './file-rpc.js';
 import { Wire } from './wire.js';
 export async function startMcpEndpoint(options) {
+    if (options.currentChatFile && managedMcp.MANAGED_FILE_DELIVERY_VERSION !== 1)
+        throw Error('INCOMPATIBLE_MANAGED_FILE_DELIVERY');
     const sockets = new Set();
     const server = createServer((socket) => {
         if (sockets.size >= 4) {
@@ -33,6 +36,7 @@ export async function startMcpEndpoint(options) {
         };
         const mcp = createManagedOursMcpServer(options.client, 'managed-v1', options.identities, {
             remoteDaemonFiles: options.remoteDaemonFiles,
+            ...(options.currentChatFile ? { currentChatFileDirectory: options.currentChatFileDirectory, currentChatFile: (input, extra) => options.currentChatFile(input, extra, files) } : {}),
             fileContext: files,
             admit: async () => {
                 if (!authenticated || inFlight >= 32)

package/dist/agent-ours/service.d.ts

@@ -1,3 +1,4 @@
+import type { AgentSession } from '../session/types.js';
 import type { ResolvedRole } from '../config.js';
 import { AgentOursRuntime } from './runtime.js';
 export declare const privateRuntimeRoot: () => string;
@@ -5,6 +6,7 @@ export interface ManagedAgentService {
     runtime: AgentOursRuntime;
     descriptor: string;
     privatePaths: string[];
+    setFileDelivery?(sender: AgentSession['sendFileToChat']): void;
     close(terminal: boolean): Promise<void>;
 }
 /** Only trusted launch orchestration may write this descriptor, never the child. */
@@ -20,4 +22,7 @@ export declare function readRoomReadiness(roomCid: string, name: string): {
     generation: number;
 } | undefined;
 /** Explicit logical-instance termination, independent of harness/bridge transport. */
-export declare function releaseManagedAgent(role: ResolvedRole): Promise<void>;
+export declare function releaseManagedAgent(role: ResolvedRole, expected?: {
+    cid: string;
+    action: string;
+}): Promise<void>;

package/dist/agent-ours/service.js

@@ -1,9 +1,13 @@
+import { pinExportRoot, exportPath, ensureExportDirectory } from '../file-delivery/reader.js';
+import { ArtifactStore } from '../file-delivery/store.js';
+import { resolve, basename, extname } from 'node:path';
 import { socketPath as privateSocketPath } from '../socket-path.js';
 import { randomBytes, randomUUID } from 'node:crypto';
-import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { existsSync, lstatSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { attachOursClient } from '@ours.network/sdk/client';
 import { ApplicationIdentityStore } from '@ours.network/mcp/application-identities';
+import { assertSafeAncestors } from '../rooms-tasks/workspace.js';
 import { readClientProfile } from '../client-profile.js';
 import { stateRoot } from '../paths.js';
 import { createCoworkAdapter } from '../rooms-tasks/cowork-adapter.js';
@@ -94,6 +98,8 @@ export async function prepareManagedAgent(role, stateDir, temporary) {
     }
     const controller = await RuntimeController.acquire(root, profile.expectedInstanceId, role.identity, instance);
     let closeClient;
+    let exportRoot;
+    let fileSender;
     let partialEndpoint;
     try {
         let prior = controller.journal.read();
@@ -210,6 +216,18 @@ export async function prepareManagedAgent(role, stateDir, temporary) {
         const bridgeDir = join(stateDir, '.ours-bridge');
         mkdirSync(bridgeDir, { recursive: true, mode: 0o700 });
         const capability = randomBytes(32).toString('hex'), socket = privateSocketPath(join(bridgeDir, `g${generation}.sock`));
+        const cwd = role.cwd && existsSync(role.cwd) ? resolve(role.cwd) : resolve(stateDir);
+        if (role.file_delivery?.enabled) {
+            if (role.session !== 'acp' || !['codex', 'claude-code'].includes(role.harness))
+                throw Error('FILE_DELIVERY_REQUIRES_CODEX_OR_CLAUDE_ACP');
+            const rootPath = resolve(cwd, role.file_delivery.directory);
+            const forbidden = [privateRuntimeRoot(), join(stateRoot(), 'private-file-delivery'), profile.configPath, profile.credentialPath];
+            if (forbidden.some(p => rootPath === resolve(p) || rootPath.startsWith(resolve(p) + '/') || resolve(p).startsWith(rootPath + '/')))
+                throw Error('PRIVATE_STATE_CANNOT_BE_EXPORTED');
+            await ensureExportDirectory(cwd, role.file_delivery.directory);
+            exportRoot = await pinExportRoot(rootPath);
+        }
+        const artifactStore = new ArtifactStore(stateDir);
         const endpoint = await startMcpEndpoint({
             socket,
             capability,
@@ -218,6 +236,26 @@ export async function prepareManagedAgent(role, stateDir, temporary) {
             client,
             identities,
             remoteDaemonFiles: true,
+            ...(exportRoot ? { currentChatFileDirectory: role.file_delivery.directory, currentChatFile: (async (input, extra, files) => {
+                    if (!fileSender || !exportRoot)
+                        throw Error('CURRENT_CHAT_DELIVERY_UNAVAILABLE');
+                    exportPath(exportRoot.root, cwd, input.path); // validate before approval/read
+                    const name = input.filename ?? basename(input.path);
+                    if (!name || Buffer.byteLength(name) > 240 || /[\/\\\x00-\x1f]/.test(name) || name === '.' || name === '..')
+                        throw Error('INVALID_FILENAME');
+                    const mime = input.mime ?? { '.txt': 'text/plain', '.md': 'text/markdown', '.pdf': 'application/pdf', '.json': 'application/json', '.html': 'text/html', '.png': 'image/png' }[extname(name).toLowerCase()] ?? 'application/octet-stream';
+                    if (mime.length > 200 || !/^[A-Za-z0-9.+-]+\/[A-Za-z0-9.+-]+$/.test(mime))
+                        throw Error('INVALID_MIME');
+                    return fileSender(input, extra.signal, async (binding) => {
+                        const source = await files.readExport(input.path, exportRoot.root, extra);
+                        try {
+                            return await artifactStore.copy(source, name, mime, binding, extra.signal);
+                        }
+                        finally {
+                            await source.close();
+                        }
+                    }, role.permissions);
+                }) } : {}),
         });
         partialEndpoint = endpoint;
         const descriptor = join(bridgeDir, 'descriptor.json');
@@ -225,10 +263,13 @@ export async function prepareManagedAgent(role, stateDir, temporary) {
         return {
             runtime,
             descriptor,
-            privatePaths: [root, profile.configPath, profile.credentialPath],
+            privatePaths: [root, profile.configPath, profile.credentialPath, join(stateRoot(), 'private-file-delivery')],
+            setFileDelivery: sender => { fileSender = sender; },
             close: async (terminal) => {
                 try {
+                    fileSender = undefined;
                     await endpoint.close();
+                    await exportRoot?.handle.close();
                     if (terminal)
                         await runtime.terminal();
                     else
@@ -248,6 +289,7 @@ export async function prepareManagedAgent(role, stateDir, temporary) {
     catch (error) {
         try {
             await partialEndpoint?.close();
+            await exportRoot?.handle.close();
         }
         finally {
             try {
@@ -318,24 +360,47 @@ export function readRoomReadiness(roomCid, name) {
     }
 }
 /** Explicit logical-instance termination, independent of harness/bridge transport. */
-export async function releaseManagedAgent(role) {
+export async function releaseManagedAgent(role, expected) {
     const profile = readClientProfile({ ...process.env, ...role.env });
     if (!profile)
         throw Error('MANAGED_OURS_REQUIRES_EXPLICIT_DAEMON_PROFILE');
     const root = privateRuntimeRoot(), dir = join(root, binderKey(profile.expectedInstanceId, role.identity));
-    if (!existsSync(join(dir, 'instance.json')))
+    if (!existsSync(join(dir, 'instance.json'))) {
+        if (expected)
+            throw Error('MEMBER_RUNTIME_RETIREMENT_MISSING');
         return;
-    const instance = JSON.parse(readFileSync(join(dir, 'instance.json'), 'utf8'));
+    }
+    const read = (file) => {
+        const path = join(dir, file);
+        if (expected) {
+            assertSafeAncestors(dir);
+            const stat = lstatSync(path);
+            if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 256 * 1024)
+                throw Error('MEMBER_RUNTIME_UNSAFE_PROOF');
+        }
+        return JSON.parse(readFileSync(path, 'utf8'));
+    };
+    const instance = read('instance.json');
+    if (expected) {
+        read('state.json');
+        read('owner.json');
+    }
     if (instance.role !== role.name)
         throw Error('IDENTITY_ASSIGNED_TO_OTHER_ROLE');
     const controller = await RuntimeController.acquire(root, profile.expectedInstanceId, role.identity, instance.instance);
     try {
         const state = controller.journal.read();
-        if (!state || state.phase === 'RELEASED')
+        if (expected && (!state || state.name !== role.identity || state.daemon !== profile.expectedInstanceId
+            || state.instance !== instance.instance || state.lifetime !== 'temporary' || instance.temporary !== true
+            || state.cid !== expected.cid || state.action !== expected.action))
+            throw Error('MEMBER_RUNTIME_RETIREMENT_MISMATCH');
+        if (!state)
             return;
-        const owner = JSON.parse(readFileSync(join(dir, 'owner.json'), 'utf8'));
-        if (owner.instance !== state.instance)
+        const owner = read('owner.json');
+        if (owner.instance !== state.instance || typeof owner.token !== 'string' || !owner.token)
             throw Error('OWNER_RECORD_MISMATCH');
+        if (state.phase === 'RELEASED')
+            return;
         const client = await attachOursClient({
             endpoint: profile.endpoint,
             expectedInstanceId: profile.expectedInstanceId,

package/dist/application/conversation-history.d.ts

@@ -23,3 +23,5 @@ export declare function resumedConversationPage(stateDir: string, request: {
     after?: string;
     limit?: number;
 }, live: ConversationPageView, expectedSessionId: string): Promise<ConversationPageView>;
+/** Download authorization requires an actual published attachment, never an orphan copy. */
+export declare function conversationHasAttachment(stateDir: string, attachment: import('../file-delivery/types.js').DeliveredFile): Promise<boolean>;

package/dist/application/conversation-history.js

@@ -2,7 +2,7 @@ import { createReadStream } from 'node:fs';
 import { open, readFile, readdir } from 'node:fs/promises';
 import { join } from 'node:path';
 import { createInterface } from 'node:readline';
-const HISTORICAL_KINDS = ['fleet.task_created', 'prompt.admitted', 'message.chunk', 'message.replace', 'tool.upsert', 'tool.content_chunk', 'turn.completed'];
+const HISTORICAL_KINDS = ['file.attached', 'fleet.task_created', 'prompt.admitted', 'message.chunk', 'message.replace', 'tool.upsert', 'tool.content_chunk', 'turn.completed'];
 /** Whether a ledger event belongs in the conversation: the live generation, or history of the resumed ACP session. */
 export function conversationEventVisible(event, sessionGeneration, resumedSessionId) {
     return event.source !== 'agent_replay' && (event.sessionGeneration === sessionGeneration || (!!resumedSessionId && HISTORICAL_KINDS.includes(event.kind) && event.acpSessionId === resumedSessionId));
@@ -162,7 +162,7 @@ export async function resumedConversationPage(stateDir, request, live, expectedS
                 const cursor = Number(event.seq);
                 if (!Number.isSafeInteger(cursor) || cursor <= after)
                     continue;
-                const historical = ['fleet.task_created', 'prompt.admitted', 'message.chunk', 'message.replace', 'tool.upsert', 'tool.content_chunk', 'turn.completed'].includes(event.kind);
+                const historical = ['file.attached', 'fleet.task_created', 'prompt.admitted', 'message.chunk', 'message.replace', 'tool.upsert', 'tool.content_chunk', 'turn.completed'].includes(event.kind);
                 const visible = event.source !== 'agent_replay' && (event.sessionGeneration === live.snapshot.sessionGeneration || (historical && event.acpSessionId === sessionId));
                 if (!visible) {
                     next = String(cursor);
@@ -187,3 +187,26 @@ export async function resumedConversationPage(stateDir, request, live, expectedS
         return live;
     return { ...live, events, firstAvailableCursor: first, nextCursor: next, hasMore };
 }
+/** Download authorization requires an actual published attachment, never an orphan copy. */
+export async function conversationHasAttachment(stateDir, attachment) {
+    const dir = join(stateDir, '.conversation');
+    const names = (await readdir(dir)).filter(n => /^events-\d+\.jsonl$/.test(n)).sort().reverse();
+    let found = false;
+    for (const name of names) {
+        await readLinesBackward(join(dir, name), line => {
+            try {
+                const e = JSON.parse(line);
+                const a = e.payload.attachment;
+                if (e.kind === 'file.attached' && e.source === 'agent' && a?.id === attachment.id
+                    && e.sessionGeneration === attachment.sessionGeneration && e.acpSessionId === attachment.acpSessionId
+                    && e.turnId === attachment.turnId && JSON.stringify(a) === JSON.stringify(attachment))
+                    found = true;
+            }
+            catch { /* unreadable lines cannot authorize a download */ }
+            return !found;
+        });
+        if (found)
+            break;
+    }
+    return found;
+}

package/dist/application/log-service.js

@@ -3,7 +3,6 @@ import { createHmac, randomBytes } from 'node:crypto';
 import { join } from 'node:path';
 import { realExec } from '../exec.js';
 import { logsRoot } from '../paths.js';
-import { unitFor } from '../supervisor/systemd.js';
 import { ROLE_NAME_RE } from '../config.js';
 import { FleetError } from './errors.js';
 const STANDARD_REDACTIONS = [
@@ -78,12 +77,13 @@ export class StructuredLogService {
     }
     async tail(roleId, requested, cursor) {
         const limit = Math.min(Math.max(requested, 1), 1_000);
-        const args = this.backend.id === 'systemd'
-            ? {
-                cmd: 'journalctl',
-                args: ['--user', '-u', unitFor(roleId), '-o', 'json', '--no-pager', '-n', String(limit)],
-            }
-            : this.backend.logsArgs(roleId, false);
+        const source = this.backend.logsArgs(roleId, false);
+        const args = { cmd: source.cmd, args: [...source.args] };
+        const count = args.args.indexOf('-n');
+        if (count >= 0)
+            args.args[count + 1] = String(limit);
+        if (args.cmd === 'journalctl')
+            args.args.push('-o', 'json', '--no-pager', '-n', String(limit));
         if (!['journalctl', 'tail', 'tmux'].includes(args.cmd))
             throw new FleetError('capability_unavailable', 'log backend is unsupported');
         const result = await this.exec(args.cmd, args.args);
@@ -93,7 +93,7 @@ export class StructuredLogService {
         const parsed = lines.map((line, index) => {
             let text = line;
             let at;
-            if (this.backend.id === 'systemd') {
+            if (args.cmd === 'journalctl') {
                 try {
                     const json = JSON.parse(line);
                     text = typeof json.MESSAGE === 'string' ? json.MESSAGE : line;

package/dist/application/role-creation-service.js

@@ -59,7 +59,8 @@ export class RoleCreationService {
     }
     async createManaged(caller, requested) {
         const plan = this.previewSpawn({ origin: 'managed', caller, options: requested });
-        const creationActionId = randomUUID();
+        const creationActionId = requested.roomMemberStartup?.task_id
+            ? requested.creationActionId ?? randomUUID() : randomUUID();
         plan.options.creationActionId = creationActionId;
         const statePath = await this.launchSync(plan.options);
         const selectionSummary = (kind) => {

package/dist/application/role-removal-service.js

@@ -3,7 +3,7 @@ import { cpSync, existsSync, mkdirSync, readdirSync, renameSync } from 'node:fs'
 import { basename, dirname, join } from 'node:path';
 import { loadConfig, ROLE_NAME_RE } from '../config.js';
 import { agentDir, stateRoot } from '../paths.js';
-import { rmRole } from '../ops.js';
+import { assertStandaloneRoleRemoval, rmRole } from '../ops.js';
 import { FleetError } from './errors.js';
 import { provesGeneratedAgentSource } from '../generated-agent-source.js';
 export class RoleRemovalService {
@@ -19,6 +19,12 @@ export class RoleRemovalService {
         if (!ROLE_NAME_RE.test(requested))
             throw new FleetError('invalid_request', 'invalid role name');
         const cfg = loadConfig(this.options.configPath);
+        try {
+            assertStandaloneRoleRemoval(cfg, requested);
+        }
+        catch (error) {
+            throw new FleetError('conflict', error instanceof Error ? error.message : String(error));
+        }
         const names = new Set(cfg.roles.map(role => role.name));
         for (const root of [dirname(agentDir('_')), dirname(agentDir('_', true))]) {
             try {

package/dist/application/role-repository.js

@@ -5,6 +5,21 @@ import { loadConfig, resolveSnapshotMonitor, resolvePermissions, ROLE_NAME_RE, }
 import { agentsRoot, tmpRoot } from '../paths.js';
 import { readSpawnLineage } from '../web/topology.js';
 const MAX_SNAPSHOT_BYTES = 256 * 1024;
+function retainedTaskId(dir, name) {
+    try {
+        const path = join(dir, '.temp-supervisor.json');
+        const stat = lstatSync(path);
+        if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 16 * 1024)
+            return undefined;
+        const record = JSON.parse(readFileSync(path, 'utf8'));
+        const id = record?.taskOwner?.taskId;
+        return record?.version === 1 && record?.role === name && typeof id === 'string'
+            && /^[0-9a-z]{9}[0-9a-f]{8}$/.test(id) ? id : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
 function safeDirs(root) {
     try {
         return readdirSync(root, { withFileTypes: true })
@@ -128,10 +143,12 @@ export class RoleRepository {
             const stateRef = inTemporary ? { lifetime: 'temporary' }
                 : inPermanent ? { lifetime: 'permanent' } : undefined;
             const tempStateDir = inTemporary ? join(temporaryRoot, name) : undefined;
+            const taskId = !config && tempStateDir ? retainedTaskId(tempStateDir, name) : undefined;
             return {
                 id: name,
                 lifetime: config ? 'permanent' : inTemporary ? 'temporary' : 'orphan',
                 configured: Boolean(config),
+                ...(taskId ? { taskId } : {}),
                 config: config ? view(config) : tempRole ? view(tempRole) : undefined,
                 stateRef,
                 stateHealth,

package/dist/application/supervisor-ours-tools.js

@@ -1,3 +1,4 @@
+import { socketPath } from '../socket-path.js';
 import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
@@ -35,7 +36,8 @@ export class SupervisorOursTools {
         const identity = legacy
             ? legacySupervisorIdentity(role, identityName, selected.temporary, descriptor.generation)
             : { name: identityName, cid: descriptor.cid, generation: descriptor.generation };
-        if (legacy && descriptor.socket !== join(selected.dir, '.ours-bridge', `g${descriptor.generation}.sock`))
+        const legacySocket = join(selected.dir, '.ours-bridge', `g${descriptor.generation}.sock`);
+        if (legacy && descriptor.socket !== legacySocket && descriptor.socket !== socketPath(legacySocket))
             throw new FleetError('capability_unavailable', 'legacy supervisor socket does not match the selected agent');
         if ((!legacy && (descriptor.role !== role || descriptor.identity !== identityName))
             || !/^[a-f0-9]{64}$/i.test(identity.cid ?? '') || !Number.isSafeInteger(descriptor.generation) || descriptor.generation < 1)