@ours.network/fleet 1.2.0-nightly.54 → 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
 

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

@@ -22,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

@@ -3,10 +3,11 @@ 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';
@@ -359,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/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/task-layouts.js

@@ -16,6 +16,9 @@ import { launchFleetWorker } from '../rooms-tasks/external-worker.js';
 import { layoutSupervisorId } from '../rooms-tasks/layout-control.js';
 import { layoutRunPath, RoomLayoutService } from '../rooms-tasks/layout-service.js';
 import { FleetError } from './errors.js';
+import { ownedLayoutRetirementSeats } from '../rooms-tasks/layout-member-retirement.js';
+import { eraseMemberArtifacts } from '../rooms-tasks/erasure.js';
+import { assertTaskRegistrationsAbsent } from '../supervisor/catalog.js';
 /** Hash of the authorable definition only (never the source file path). */
 export function layoutDefinitionHash(definition) {
     const { version, description, participants, rooms } = definition;
@@ -238,8 +241,15 @@ export class TaskLayouts {
         const link = task.layout;
         if (!link)
             return;
-        if (this.runExists(link))
-            await this.service().open(link.run_id, true).close(layoutSupervisorId());
+        if (this.runExists(link)) {
+            const engine = this.service().open(link.run_id, true);
+            await engine.delete(layoutSupervisorId());
+            const state = engine.snapshot();
+            const rooms = Object.values(state.rooms).flatMap(room => room.native ? [room.native.room_id] : []);
+            assertTaskRegistrationsAbsent(task.task_id);
+            await eraseMemberArtifacts('task', task.task_id, ownedLayoutRetirementSeats(state, link.run_id), rooms);
+        }
+        assertTaskRegistrationsAbsent(task.task_id);
         await this.withTaskLock(link.run_id, async () => {
             for (const path of [layoutRunPath(link.run_id), this.provenancePath(link.run_id), taskBriefPath(task)])
                 rmSync(path, { force: true });

package/dist/application/task-room-service.js

@@ -378,23 +378,25 @@ export class TaskRoomApplicationService {
         const ready = task.state === 'active' && room?.state === 'active'
             && active === expected && launched === expected;
         const blocker = task.outcome?.summary ?? task.blocked?.reason ?? room?.saga.error;
-        const nextAction = task.terminal_intent
-            ? `Complete the accepted ${task.terminal_intent.kind} operation; do not restart provisioning.`
-            : room?.state === 'closing' || room?.state === 'closed'
-                ? `Complete room cleanup; do not restart provisioning.`
-                : room?.provisioning_detail === 'member_failed'
-                    ? `Inspect the failed launch, then run ours-fleet task start ${task.task_id}.`
-                    : room?.provisioning_detail === 'waiting_owner_authorization'
-                        ? `Ensure ours-cowork 1.3.0 or newer is running and available, then run ours-fleet task start ${task.task_id}.`
-                        : room?.provisioning_detail === 'waiting_owner_invite'
-                            ? `Rotate rooms.owner.public_invite, then run ours-fleet task start ${task.task_id}.`
-                            : room?.provisioning_detail === 'owner_cid_mismatch'
-                                ? `Verify rooms.owner.expected_cid, rotate the Owner invite, then run ours-fleet task start ${task.task_id}.`
-                                : room?.provisioning_detail === 'waiting_cowork'
-                                    ? `Restore ours-cowork, then run ours-fleet task start ${task.task_id}.`
-                                    : failed
-                                        ? `Correct the blocker, then run ours-fleet task start ${task.task_id}.`
-                                        : undefined;
+        const nextAction = blocker === 'FLEET_SERVICE_NOT_INSTALLED: run ours-fleet init'
+            ? `Run ours-fleet init, then retry ours-fleet task start ${task.task_id}.`
+            : task.terminal_intent
+                ? `Complete the accepted ${task.terminal_intent.kind} operation; do not restart provisioning.`
+                : room?.state === 'closing' || room?.state === 'closed'
+                    ? `Complete room cleanup; do not restart provisioning.`
+                    : room?.provisioning_detail === 'member_failed'
+                        ? `Inspect the failed launch, then run ours-fleet task start ${task.task_id}.`
+                        : room?.provisioning_detail === 'waiting_owner_authorization'
+                            ? `Ensure ours-cowork 1.3.0 or newer is running and available, then run ours-fleet task start ${task.task_id}.`
+                            : room?.provisioning_detail === 'waiting_owner_invite'
+                                ? `Rotate rooms.owner.public_invite, then run ours-fleet task start ${task.task_id}.`
+                                : room?.provisioning_detail === 'owner_cid_mismatch'
+                                    ? `Verify rooms.owner.expected_cid, rotate the Owner invite, then run ours-fleet task start ${task.task_id}.`
+                                    : room?.provisioning_detail === 'waiting_cowork'
+                                        ? `Restore ours-cowork, then run ours-fleet task start ${task.task_id}.`
+                                        : failed
+                                            ? `Correct the blocker, then run ours-fleet task start ${task.task_id}.`
+                                            : undefined;
         return {
             kind: failed ? 'failed' : ready ? 'ready' : 'in_progress', task, room,
             launch: {

package/dist/application/types.d.ts

@@ -26,6 +26,8 @@ export interface RoleRecord {
     id: string;
     lifetime: RoleLifetime;
     configured: boolean;
+    /** Read-only display ownership; never authorizes lifecycle operations. */
+    taskId?: string;
     config?: ResolvedRoleView;
     stateRef?: {
         lifetime: 'permanent' | 'temporary';

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "1.2.0-nightly.54",
-  "buildId": "b10c893ceda0",
-  "commit": "4da7d4782c1caf686836806bc8606fc50887edc5",
+  "version": "1.2.0-nightly.55",
+  "buildId": "6e4199ab6d73",
+  "commit": "a66362bc99a9896700192f5ff2c8454a0e209766",
   "dirty": true,
-  "builtAt": "2026-10-08T10:22:35.148Z",
+  "builtAt": "2026-10-09T12:16:42.572Z",
   "capabilities": [
     "managed-cli.codex-reasoning-effort-v1",
     "managed-cli.setup-v1",

package/dist/cli.js

@@ -617,7 +617,7 @@ cOpt(program.command('status <name>').description('declared persistent Agent uni
             + `${ledger.lastTermination.runStartedAt ?? 'unknown'}) died without an orderly exit; `
             + `observed ${ledger.lastTermination.observedAt}`
             + `\n  abrupt terminations recorded: ${ledger.abruptTerminations ?? 1}`
-            + `\n  cause (signal / OOM-kill): journalctl --user -u ours-fleet-agent@${name}.service`);
+            + `\n  inspect member output: ours-fleet logs ${name}`);
     const modelStatus = joinPath(agentDir(name), '.model-status');
     if (existsSync(modelStatus)) {
         try {
@@ -1867,6 +1867,33 @@ program.command('_wait-daemon <name>', { hidden: true }).description('internal:
         die(e);
     }
 });
+program.command('_wait-temp-daemon <name>', { hidden: true })
+    .action(async (name) => {
+    try {
+        await waitForRoleDaemon(name, undefined, {}, true);
+    }
+    catch (error) {
+        die(error);
+    }
+});
+program.command('_run-fleet', { hidden: true }).action(async () => {
+    try {
+        const { runFleetManager } = await import('./supervisor/manager.js');
+        await runFleetManager(process.argv[1]);
+    }
+    catch (error) {
+        die(error);
+    }
+});
+program.command('_run-managed <key> <generation>', { hidden: true }).action(async (key, generation) => {
+    try {
+        const { runManagedMember } = await import('./supervisor/manager.js');
+        await runManagedMember(key, generation);
+    }
+    catch (error) {
+        die(error);
+    }
+});
 program.command('_run <name>', { hidden: true }).description('internal: supervisor entrypoint')
     .option('-c, --configuration <file>')
     .action(async (name, opts) => {
@@ -1889,9 +1916,10 @@ program.command('_run-temp <name>', { hidden: true }).description('internal: tem
     }
 });
 program.command('_run-temp-worker <name>', { hidden: true })
-    .action(async (name) => {
+    .option('--suspend-on-stop')
+    .action(async (name, options) => {
     try {
-        await runTemp(name);
+        await runTemp(name, { suspendOnStop: options.suspendOnStop === true });
     }
     catch (error) {
         if (error instanceof SupervisorRecycleRequiredError)

package/dist/config.d.ts

@@ -198,6 +198,8 @@ export interface AgentTemplateInstance {
 }
 /** Internal first-boot payload for a Fleet-provisioned Cowork room member. */
 export interface RoomMemberStartup {
+    /** Task ownership; absent for standalone rooms and legacy snapshots. */
+    task_id?: string;
     workspace?: import('./rooms-tasks/workspace.js').OwnedWorkspace;
     room_id: string;
     room_identity_cid: string;

package/dist/harness/agent-session.d.ts

@@ -30,6 +30,8 @@ export interface AgentSessionStartOptions {
     cwd: string;
     stateDir: string;
     mode: 'fresh' | 'resume';
+    /** Durable task context must never silently fall back to a fresh session. */
+    requireResume?: boolean;
     permissions: CommonPermissions;
     permissionMode: {
         fleetMode: FleetPermissionMode;

package/dist/harness/claude-code-session.js

@@ -24,7 +24,7 @@ export class ClaudeCodeAgentSessionAdapter {
         return this.transport({
             name: role.name, harness: role.harness,
             argv: launch.argv, cwd: options.cwd, env: launch.env,
-            stateDir: options.stateDir, mode: options.mode, permissions: options.permissions,
+            stateDir: options.stateDir, mode: options.mode, requireResume: options.requireResume, permissions: options.permissions,
             modeId: this.strategy.permissionModeId(role),
             mcpServers: options.managedOurs ? [...(this.strategy.mcpServers(role) ?? []).filter(s => s.name !== 'ours'), options.managedOurs.server] : this.strategy.mcpServers(role),
             inheritEnvironment: options.managedOurs ? false : undefined,

package/dist/harness/codex-session.js

@@ -32,7 +32,7 @@ export class CodexAgentSessionAdapter {
         if (role.session === 'codex-app-server')
             return this.nativeTransport({
                 name: role.name, argv: launch.argv, cwd: options.cwd, env: launch.env,
-                stateDir: options.stateDir, mode: options.mode, permissions: options.permissions,
+                stateDir: options.stateDir, mode: options.mode, requireResume: options.requireResume, permissions: options.permissions,
                 permissionMode: options.permissionMode,
                 model: role.model, effort: role.effort,
                 approvalPolicy: this.strategy.approvalPolicy(role),
@@ -44,7 +44,7 @@ export class CodexAgentSessionAdapter {
         return this.transport({
             name: role.name, harness: role.harness,
             argv: launch.argv, cwd: options.cwd, env: launch.env,
-            stateDir: options.stateDir, mode: options.mode, permissions: options.permissions,
+            stateDir: options.stateDir, mode: options.mode, requireResume: options.requireResume, permissions: options.permissions,
             modeId: this.strategy.permissionModeId(role),
             mcpServers: options.managedOurs ? [...(this.strategy.mcpServers(role) ?? []).filter(s => s.name !== 'ours'), options.managedOurs.server] : this.strategy.mcpServers(role),
             inheritEnvironment: options.managedOurs ? false : undefined,

package/dist/managed-recovery.d.ts

@@ -0,0 +1,13 @@
+/** Body-free recovery cursor. Dispatching is uncertain after a crash, never
+ * permission to replay an initial task which may already have caused effects. */
+export interface ManagedRecovery {
+    version: 1;
+    session: 'pending' | 'established';
+    readiness: boolean;
+    initial: 'pending' | 'dispatching' | 'completed';
+    active: boolean;
+}
+export declare const managedRecoveryPath: (dir: string) => string;
+export declare function readManagedRecovery(dir: string): ManagedRecovery | undefined;
+export declare function writeManagedRecovery(dir: string, value: ManagedRecovery): void;
+export declare function firstManagedSessionMayStart(dir: string): boolean;

package/dist/managed-recovery.js

@@ -0,0 +1,31 @@
+import { lstatSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { replaceFileAtomically } from './atomic-file.js';
+export const managedRecoveryPath = (dir) => join(dir, '.managed-recovery.json');
+export function readManagedRecovery(dir) {
+    const path = managedRecoveryPath(dir);
+    let stat;
+    try {
+        stat = lstatSync(path);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT')
+            return;
+        throw error;
+    }
+    if (!stat.isFile() || stat.isSymbolicLink() || stat.size > 4096)
+        throw Error('MANAGED_RECOVERY_UNSAFE_PROOF');
+    const value = JSON.parse(readFileSync(path, 'utf8'));
+    if (value.version !== 1 || !['pending', 'established'].includes(value.session)
+        || !['pending', 'dispatching', 'completed'].includes(value.initial)
+        || typeof value.readiness !== 'boolean' || typeof value.active !== 'boolean')
+        throw Error('MANAGED_RECOVERY_INVALID_PROOF');
+    return value;
+}
+export function writeManagedRecovery(dir, value) {
+    replaceFileAtomically(managedRecoveryPath(dir), JSON.stringify(value) + '\n');
+}
+export function firstManagedSessionMayStart(dir) {
+    const proof = readManagedRecovery(dir);
+    return Boolean(proof?.session === 'pending' && proof.initial === 'pending' && !proof.readiness && !proof.active);
+}

package/dist/ops.d.ts

@@ -54,5 +54,7 @@ export declare function up(cfg: FleetConfig, names: string[], deps: OpsDeps, con
 export declare function down(cfg: FleetConfig, names: string[], deps: OpsDeps): Promise<void>;
 /** Re-sync from config + bounce. mode 'keep' resumes context; 'fresh' wipes it. */
 export declare function restartRoles(cfg: FleetConfig, names: string[], deps: OpsDeps, mode: 'keep' | 'fresh', configPath?: string): Promise<void>;
+/** Read-only admission check shared by CLI removal and web preview, before any archive. */
+export declare function assertStandaloneRoleRemoval(cfg: FleetConfig, name: string): void;
 /** Stop + forget a role: unit, state dir, and its fleet.d file when spawned. */
 export declare function rmRole(cfg: FleetConfig, name: string, deps: OpsDeps): Promise<void>;

package/dist/ops.js

@@ -7,8 +7,8 @@ import { findRole } from './config.js';
 import { getAdapter } from './harness/registry.js';
 import { generateBriefing } from './briefing.js';
 import { managedCliBriefing } from './managed-cli.js';
-import { resetRestartLedger } from './runner.js';
-import { archiveTempState, stopTempSupervisor, tempSupervisorLiveness, } from './temp-lifecycle.js';
+import { resetRestartLedger, loadTempRole } from './runner.js';
+import { archiveTempState, stopTempSupervisor, tempSupervisorLiveness, readTempSupervisor, } from './temp-lifecycle.js';
 import { realExec } from './exec.js';
 import { daemonIdentityProvisioner, reconcilePermanentRoleIdentities, } from './creation.js';
 import { provesGeneratedAgentSource } from './generated-agent-source.js';
@@ -223,8 +223,21 @@ export async function restartRoles(cfg, names, deps, mode, configPath) {
             : `↻ ${role.name} — restarted (resumes; briefing re-synced)`);
     }
 }
+/** Read-only admission check shared by CLI removal and web preview, before any archive. */
+export function assertStandaloneRoleRemoval(cfg, name) {
+    if (cfg.roles.some(role => role.name === name) || !/^[A-Za-z0-9_-]+$/.test(name))
+        return;
+    const dir = agentDir(name, true);
+    if (!existsSync(dir))
+        return;
+    const taskId = readTempSupervisor(dir)?.taskOwner?.taskId
+        ?? (existsSync(join(dir, 'role.yaml')) ? loadTempRole(name).roomMemberStartup?.task_id : undefined);
+    if (taskId)
+        throw Error(`TASK_MEMBER_IS_TASK_OWNED: ${name} belongs to task ${taskId}; use the owning task lifecycle; if its record is missing or corrupt, preserve evidence and restore the original records before retrying task delete`);
+}
 /** Stop + forget a role: unit, state dir, and its fleet.d file when spawned. */
 export async function rmRole(cfg, name, deps) {
+    assertStandaloneRoleRemoval(cfg, name);
     const temporaryDir = /^[A-Za-z0-9_-]+$/.test(name) ? agentDir(name, true) : '';
     const configured = cfg.roles.find(role => role.name === name);
     if (!configured && temporaryDir && existsSync(temporaryDir)) {

package/dist/rooms-tasks/cli.js

@@ -891,6 +891,27 @@ export function registerTaskCommands(parent, cOpt) {
             dieTaskRoom(e);
         }
     });
+    cOpt(taskCmd.command('recover-members <id>'))
+        .description('resume proven stopped task members in-place; never create identities or replay invites')
+        .option('--json', 'JSON output')
+        .action(async (id, opts) => {
+        try {
+            const { recoverTaskMembers } = await import('./recovery.js');
+            const task = getTask(id), cfg = loadConfig(opts.configuration);
+            const members = await recoverTaskMembers({ taskId: id, binPath: getBinPath(),
+                cowork: task.layout ? undefined : createCoworkAdapter({ configPath: cfg.rooms?.cowork?.config }) });
+            if (opts.json)
+                console.log(JSON.stringify({ schema_version: 1, task_id: id, members }, null, 2));
+            else
+                for (const member of members)
+                    console.log(`${member.name}: ${member.status}`);
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
     cOpt(taskCmd.command('start <id>'))
         .description('idempotently select a plan, provision, and start a task')
         .option('--template <name>', 'room template')

package/dist/rooms-tasks/close.d.ts

@@ -1,3 +1,4 @@
+import { retireTaskMemberService } from './task-service-retirement.js';
 import { withFileLock } from '../atomic-file.js';
 import { type TempLifecycleDeps } from '../temp-lifecycle.js';
 import { type CoworkAdapter } from './cowork-adapter.js';
@@ -5,6 +6,7 @@ import type { RoomMemberSeat, RoomOrchestrationRecord } from './types.js';
 export declare const CLOSE_LOCK_STALE_MS: number;
 export declare function roomCloseLockPath(roomId: string): string;
 export interface RoomCloseDeps {
+    retireTaskService?: typeof retireTaskMemberService;
     inspectMember?(seat: RoomMemberSeat): Promise<{
         launchId: string;
     }>;