@ours.network/fleet 1.2.0-nightly.8 → 1.2.0-nightly.80

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/model-catalog.d.ts

@@ -14,7 +14,7 @@ export interface HarnessModelCatalog {
 export declare function codexModelCatalog(path?: string): HarnessModelCatalog;
 /**
  * Claude Code 2.1 has no typed model-list endpoint. These exact IDs are the
- * versioned adapter contract shipped by the installed 2.1 CLI, not aliases and
+ * versioned adapter contract verified with CLI 2.1.281, not aliases and
  * not a claim about account entitlement (which Claude validates at launch).
  */
 export declare function claudeModelCatalog(): HarnessModelCatalog;

package/dist/application/model-catalog.js

@@ -41,17 +41,20 @@ export function codexModelCatalog(path = join(homedir(), '.codex', 'models_cache
 }
 /**
  * Claude Code 2.1 has no typed model-list endpoint. These exact IDs are the
- * versioned adapter contract shipped by the installed 2.1 CLI, not aliases and
+ * versioned adapter contract verified with CLI 2.1.281, not aliases and
  * not a claim about account entitlement (which Claude validates at launch).
  */
 export function claudeModelCatalog() {
     const reasoningEfforts = ['low', 'medium', 'high', 'xhigh', 'max'];
     return {
         models: [
+            { id: 'claude-fable-5-1', label: 'Claude Fable 5.1', reasoningEfforts, source: 'claude-adapter-2.1' },
+            { id: 'claude-opus-5-5', label: 'Claude Opus 5.5', reasoningEfforts, source: 'claude-adapter-2.1' },
+            { id: 'claude-haiku-4-5-20251001', label: 'Claude Haiku 4.5', reasoningEfforts: [], source: 'claude-adapter-2.1' },
             { id: 'claude-fable-5', label: 'Claude Fable 5', reasoningEfforts, source: 'claude-adapter-2.1' },
             { id: 'claude-opus-5', label: 'Claude Opus 5', reasoningEfforts, source: 'claude-adapter-2.1' },
             { id: 'claude-sonnet-5', label: 'Claude Sonnet 5', reasoningEfforts, source: 'claude-adapter-2.1' },
         ],
-        warnings: ['Claude Code exposes no typed model-list endpoint; choices are exact 2.1 adapter IDs and entitlement is validated at launch.'],
+        warnings: ['Claude Code exposes no typed model-list endpoint; choices require a current Claude runtime (verified with 2.1.281); older bundled SDKs need CLAUDE_CODE_EXECUTABLE. Entitlement is validated at launch.'],
     };
 }

package/dist/application/preset-provenance.d.ts

@@ -0,0 +1,19 @@
+export declare const PROVENANCE_KINDS: {
+    readonly role: "roles";
+    readonly brain: "brains";
+    readonly template: "agent_templates";
+    readonly layout: "room_layouts";
+};
+export type ProvenanceKind = keyof typeof PROVENANCE_KINDS;
+export type ProvenanceStatus = 'predefined' | 'changed' | 'custom';
+export interface ProvenanceEntry {
+    status: ProvenanceStatus;
+    preset?: string;
+}
+export type Provenance = Record<ProvenanceKind, Record<string, ProvenanceEntry>>;
+export declare class PresetProvenance {
+    private configPath?;
+    private presetRoot;
+    constructor(configPath?: string | undefined, presetRoot?: string);
+    read(): Provenance;
+}

package/dist/application/preset-provenance.js

@@ -0,0 +1,59 @@
+/** Where each configured definition came from, compared with the packaged presets.
+ * A definition is `predefined` when it has the same value as the shipped preset of
+ * the same name, `changed` when a preset of that name exists but the value differs,
+ * and `custom` otherwise. Values are compared after parsing, so the formatting the
+ * configuration editor writes does not count as a change. Preset text is returned
+ * so users can see exactly what ships; it contains no host data.
+ */
+import { isDeepStrictEqual } from 'node:util';
+import { existsSync, lstatSync, readFileSync, readdirSync } from 'node:fs';
+import { basename, extname, join } from 'node:path';
+import { parse } from 'yaml';
+import { defaultConfigPath } from '../paths.js';
+import { splitRootFor } from '../config.js';
+import { packagedPresetRoot } from '../preset-bootstrap.js';
+export const PROVENANCE_KINDS = { role: 'roles', brain: 'brains', template: 'agent_templates', layout: 'room_layouts' };
+const MAX_BYTES = 256 * 1024;
+/** Regular, bounded YAML files of one directory, by definition name. Anything else is skipped. */
+function yamlFiles(dir) {
+    const files = new Map();
+    if (!existsSync(dir) || !lstatSync(dir).isDirectory())
+        return files;
+    for (const file of readdirSync(dir).sort()) {
+        if (!/\.ya?ml$/.test(file))
+            continue;
+        const path = join(dir, file), stat = lstatSync(path);
+        if (!stat.isFile() || stat.size > MAX_BYTES)
+            continue;
+        files.set(basename(file, extname(file)), readFileSync(path, 'utf8'));
+    }
+    return files;
+}
+const parsed = (text) => { try {
+    return parse(text);
+}
+catch {
+    return Symbol('unparseable');
+} };
+export class PresetProvenance {
+    configPath;
+    presetRoot;
+    constructor(configPath, presetRoot = join(packagedPresetRoot(), 'fleet')) {
+        this.configPath = configPath;
+        this.presetRoot = presetRoot;
+    }
+    read() {
+        const split = splitRootFor(this.configPath ?? defaultConfigPath());
+        const result = {};
+        for (const [kind, dir] of Object.entries(PROVENANCE_KINDS)) {
+            const presets = yamlFiles(join(this.presetRoot, dir)), installed = yamlFiles(join(split, dir));
+            result[kind] = Object.fromEntries([...installed].map(([name, text]) => {
+                const preset = presets.get(name);
+                if (preset === undefined)
+                    return [name, { status: 'custom' }];
+                return [name, { status: isDeepStrictEqual(parsed(text), parsed(preset)) ? 'predefined' : 'changed', preset }];
+            }));
+        }
+        return result;
+    }
+}

package/dist/application/resource-observer.d.ts

@@ -0,0 +1,43 @@
+import { type FSWatcher } from 'node:fs';
+export interface FleetResourceState {
+    protocolVersion: 1;
+    producerGeneration: string;
+    position: number;
+    health: 'healthy' | 'failed' | 'unsupported';
+}
+export interface FleetResourceScope {
+    configPath?: string;
+    subscribeMutations?: (listener: () => void) => () => void;
+    /** Durable notification owners may reinstall degraded watches without idle content polling. */
+    retryWatchFailures?: boolean;
+    roots?: string[];
+    /** Overrides full Fleet discovery for narrow owners such as task delivery. */
+    paths?: string[];
+    /** Path routing precedes a coalesced committed callback. Undefined means
+     * unknown/recovered coverage and requires conservative discovery. */
+    onInvalidated?: (path: string | undefined) => void;
+    watch?: (path: string, listener: (event: string, filename: string | null) => void) => Pick<FSWatcher, 'on' | 'close'>;
+}
+/** Only call after durable persistence succeeds. Observers cannot fail a commit. */
+export declare function publishFleetResourceCommit(path: string): void;
+/** Native notifications cover supported local mounts. No idle content scan or
+ * silent claim of coverage after watch failure. Parents survive atomic rename.
+ * Discovery reads directory metadata only, never opens a controller or transcript. */
+export declare function observeFleetResources(scope: FleetResourceScope, onCommitted: (state: FleetResourceState) => void, signal: AbortSignal): {
+    snapshot: () => {
+        health: "healthy" | "failed" | "unsupported";
+        protocolVersion: 1;
+        producerGeneration: string;
+        position: number;
+    };
+    cursor: (accepts: (path: string) => boolean, lifetime: AbortSignal) => {
+        snapshot: () => {
+            position: number;
+            health: "healthy" | "failed" | "unsupported";
+            protocolVersion: 1;
+            producerGeneration: string;
+        };
+        dispose: () => void;
+    };
+    dispose: () => void;
+};

package/dist/application/resource-observer.js

@@ -0,0 +1,323 @@
+import { EventEmitter } from 'node:events';
+import { randomUUID } from 'node:crypto';
+import { lstatSync, statSync, readdirSync, watch } from 'node:fs';
+import { homedir } from 'node:os';
+import { dirname, join, resolve, sep } from 'node:path';
+import { splitRootFor } from '../config.js';
+import { agentsRoot, tmpRoot, stateRoot, defaultConfigPath } from '../paths.js';
+// Directory discovery is shared by payload and notification owners. Each owner
+// has its own lifetime/coverage; the underlying OS watch is reference counted.
+const sharedWatches = new Map();
+function sharedWatch(path, listener) {
+    const key = `${path}:${identity(path, true)}`;
+    let entry = sharedWatches.get(key);
+    if (!entry) {
+        const clients = new Set(), listeners = new Map();
+        const handle = watch(path, { persistent: false }, (event, name) => { for (const fn of [...listeners.values()])
+            fn(event, name); });
+        entry = { handle, clients, listeners };
+        sharedWatches.set(key, entry);
+        handle.on('error', error => { for (const client of [...clients])
+            client.emit('error', error); });
+        handle.on('close', () => { for (const client of [...clients])
+            client.emit('close'); });
+    }
+    const current = entry, client = new EventEmitter();
+    let closed = false;
+    current.clients.add(client);
+    current.listeners.set(client, listener);
+    return Object.assign(client, { close() {
+            if (closed)
+                return;
+            closed = true;
+            current.clients.delete(client);
+            current.listeners.delete(client);
+            if (!current.clients.size) {
+                sharedWatches.delete(key);
+                current.handle.close();
+            }
+        } });
+}
+const commits = new Set();
+/** Only call after durable persistence succeeds. Observers cannot fail a commit. */
+export function publishFleetResourceCommit(path) {
+    for (const listener of [...commits]) {
+        try {
+            listener(resolve(path));
+        }
+        catch { }
+    }
+}
+function directoryGone(error) {
+    return ['ENOENT', 'ENOTDIR'].includes(error.code ?? '');
+}
+function identity(path, followLink = false) {
+    try {
+        const value = followLink ? statSync(path) : lstatSync(path);
+        if (value.isSymbolicLink())
+            throw Error('symbolic resource directory');
+        return value.isDirectory() ? `${value.dev}:${value.ino}:${value.birthtimeMs}` : undefined;
+    }
+    catch (error) {
+        if (directoryGone(error))
+            return;
+        throw error;
+    }
+}
+function within(path, root) { return path === root || path.startsWith(root + sep); }
+/** Lock directories and the claim/reclaim entries derived from their names
+ * (`<lock>.claim.<pid>.<uuid>`, `<lock>.reclaim`) are never resources. */
+const lockClaim = /\.claim\.\d+\.[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$|\.reclaim$/;
+function lockName(name) { return name === '.locks' || name.endsWith('.lock'); }
+function lockArtifact(name) { return lockName(name) || (lockClaim.test(name) && lockName(name.replace(lockClaim, ''))); }
+/** Full discovery is synchronous and lstats every covered directory. Wakes are
+ * still delivered promptly, but discovery runs at most once per window. */
+const DISCOVERY_WINDOW_MS = 100;
+/** Native notifications cover supported local mounts. No idle content scan or
+ * silent claim of coverage after watch failure. Parents survive atomic rename.
+ * Discovery reads directory metadata only, never opens a controller or transcript. */
+export function observeFleetResources(scope, onCommitted, signal) {
+    const config = resolve(scope.configPath ?? defaultConfigPath());
+    const roots = (scope.roots ?? [agentsRoot(), tmpRoot()]).map(p => resolve(p));
+    const paths = (scope.paths ?? (scope.roots && !scope.configPath ? roots : [...roots, splitRootFor(config), join(stateRoot(), 'tasks'), join(stateRoot(), 'rooms'), join(stateRoot(), 'watchdogs'), join(stateRoot(), 'layouts'), join(stateRoot(), 'member-additions'), join(stateRoot(), 'subscriptions')])).map(p => resolve(p));
+    // Explicit roots without config select discovery only (notification producers).
+    const configEnabled = scope.configPath !== undefined || (!scope.paths && !scope.roots);
+    const adoptedHomes = configEnabled ? [join(homedir(), '.claude'), join(homedir(), '.codex')] : [];
+    if (configEnabled)
+        paths.push(dirname(config), resolve(stateRoot()), ...adoptedHomes);
+    // Explicit resource locations and their ancestors already belong to the
+    // caller's read scope (e.g. /home -> /var/home or a linked state root).
+    // Discovered descendants keep lstat validation and never traverse child links.
+    const trustedPaths = new Set(paths);
+    for (const path of paths) {
+        let parent = path;
+        for (let depth = 0; depth < 4 && dirname(parent) !== parent; depth++, parent = dirname(parent))
+            trustedPaths.add(parent);
+    }
+    const resourceIdentity = (path) => identity(path, trustedPaths.has(path));
+    const locks = resolve(stateRoot(), 'locks');
+    const ignored = (path) => within(path, locks) || path.split(sep).some(name => lockArtifact(name) || name.endsWith('.tmp'));
+    let state = { protocolVersion: 1, producerGeneration: randomUUID(), position: 0, health: 'healthy' };
+    let disposed = signal.aborted, queued = false, discoveredAt = -Infinity;
+    let recovery, discovery;
+    let installing = false, installFailure;
+    const cursors = new Set();
+    const watchers = new Map();
+    const release = () => { const old = [...watchers.values()]; watchers.clear(); for (const entry of old)
+        entry.handle.close(); };
+    const fail = (error) => {
+        if (installing) {
+            installFailure = error;
+            return;
+        }
+        if (disposed || state.health !== 'healthy')
+            return;
+        state = { ...state, position: state.position + 1, health: ['ENOSYS', 'ENOTSUP', 'ERR_FEATURE_UNAVAILABLE_ON_PLATFORM'].includes(error.code ?? '') ? 'unsupported' : 'failed' };
+        release();
+        onCommitted({ ...state });
+        recover();
+    };
+    const install = () => {
+        installing = true;
+        installFailure = undefined;
+        let added = 0;
+        try {
+            const wanted = new Set();
+            const cover = (dir) => {
+                const id = resourceIdentity(dir);
+                if (!id)
+                    return;
+                wanted.add(dir);
+                const existing = watchers.get(dir);
+                if (existing && existing.identity === id)
+                    return;
+                if (existing) {
+                    watchers.delete(dir);
+                    existing.handle.close();
+                }
+                let handle;
+                try {
+                    handle = (scope.watch ?? sharedWatch)(dir, (_event, filename) => {
+                        if (watchers.get(dir)?.handle !== handle)
+                            return;
+                        // Ignore sibling noise from ancestor coverage, lock churn and delivery acknowledgements.
+                        const changed = filename === null ? dir : resolve(dir, String(filename));
+                        if (ignored(changed))
+                            return;
+                        if (paths.some(path => within(changed, path) || within(path, changed)) || (configEnabled && changed === config) || filename === null)
+                            wake(filename === null ? undefined : changed);
+                    });
+                }
+                catch (error) {
+                    // Parent coverage owns removal/recreation. Only verified disappearance
+                    // is benign; permissions, unsupported watches and other errors fail.
+                    if (directoryGone(error) && !resourceIdentity(dir))
+                        return;
+                    throw error;
+                }
+                watchers.set(dir, { identity: id, handle });
+                added++;
+                handle.on('error', (error) => { if (watchers.get(dir)?.handle === handle)
+                    fail(error); });
+                handle.on('close', () => { if (watchers.get(dir)?.handle === handle)
+                    fail(Error('resource watch closed')); });
+                if (installFailure)
+                    throw installFailure;
+            };
+            const visit = (dir, depth) => {
+                if (within(dir, locks))
+                    return;
+                const id = resourceIdentity(dir);
+                if (!id)
+                    return;
+                // Watch before enumerating children: creation before watch is covered by
+                // this scan; creation after watch schedules another discovery pass.
+                cover(dir);
+                if (!depth)
+                    return;
+                let entries;
+                try {
+                    entries = readdirSync(dir, { withFileTypes: true });
+                }
+                catch (error) {
+                    if (directoryGone(error) && !resourceIdentity(dir))
+                        return;
+                    throw error;
+                }
+                for (const entry of entries) {
+                    if (!entry.isDirectory() || entry.isSymbolicLink() || lockArtifact(entry.name))
+                        continue;
+                    visit(join(dir, entry.name), depth - 1);
+                }
+            };
+            for (const path of paths) {
+                // Enough ancestors to retain the subscription when its state root is replaced.
+                let parent = path;
+                for (let depth = 0; depth < 4 && dirname(parent) !== parent; depth++, parent = dirname(parent)) {
+                    if (resourceIdentity(parent)) {
+                        wanted.add(parent);
+                        cover(parent);
+                    }
+                }
+                visit(path, configEnabled && (path === dirname(config) || adoptedHomes.includes(path)) ? 0 : 3);
+            }
+            for (const [dir, entry] of watchers) {
+                if (!wanted.has(dir) || resourceIdentity(dir) !== entry.identity) {
+                    watchers.delete(dir);
+                    entry.handle.close();
+                }
+            }
+            if (installFailure)
+                throw installFailure;
+            return added;
+        }
+        finally {
+            installing = false;
+        }
+    };
+    const recover = () => {
+        if (disposed || state.health === 'healthy' || !scope.retryWatchFailures || recovery)
+            return;
+        recovery = setTimeout(() => {
+            recovery = undefined;
+            if (disposed)
+                return;
+            try {
+                install();
+            }
+            catch {
+                release();
+                recover();
+                return;
+            }
+            state = { ...state, position: state.position + 1, health: 'healthy' };
+            scope.onInvalidated?.(undefined);
+            // Reinstallation precedes one checkpoint recovery pass; later work is
+            // event driven again. Degraded retries inspect directory metadata only.
+            onCommitted({ ...state });
+        }, 3000);
+        recovery.unref();
+    };
+    const wake = (path) => {
+        if (disposed || state.health !== 'healthy')
+            return;
+        scope.onInvalidated?.(path);
+        state = { ...state, position: state.position + 1 };
+        for (const cursor of cursors)
+            if (path === undefined || cursor.accepts(path))
+                cursor.position = state.position;
+        if (queued)
+            return;
+        queued = true;
+        queueMicrotask(() => {
+            queued = false;
+            if (disposed || state.health !== 'healthy')
+                return;
+            if (!discovery) {
+                const wait = discoveredAt + DISCOVERY_WINDOW_MS - performance.now();
+                if (wait <= 0) {
+                    discover(false);
+                    return;
+                }
+                discovery = setTimeout(() => { discovery = undefined; discover(true); }, wait);
+                discovery.unref();
+            }
+            // Covered directories were watched before this wake; directories created
+            // since the last pass are covered by the pending one.
+            onCommitted({ ...state });
+        });
+    };
+    const discover = (deferred) => {
+        if (disposed || state.health !== 'healthy')
+            return;
+        discoveredAt = performance.now();
+        let added;
+        try {
+            added = install();
+        }
+        catch (error) {
+            fail(error);
+            return;
+        }
+        // Every wake before a deferred pass was already delivered. Writes into
+        // directories it newly covers have no event of their own: treat as unknown.
+        if (deferred) {
+            if (!added)
+                return;
+            state = { ...state, position: state.position + 1 };
+            scope.onInvalidated?.(undefined);
+            for (const cursor of cursors)
+                cursor.position = state.position;
+        }
+        onCommitted({ ...state });
+    };
+    const direct = (path) => { if (paths.some(root => within(path, root)) || (configEnabled && path === config))
+        wake(path); };
+    let detach;
+    const dispose = () => { if (disposed)
+        return; disposed = true; clearTimeout(recovery); recovery = undefined; clearTimeout(discovery); discovery = undefined; detach?.(); for (const cursor of [...cursors])
+        cursor.dispose(); commits.delete(direct); signal.removeEventListener('abort', dispose); release(); };
+    if (!disposed) {
+        commits.add(direct);
+        detach = scope.subscribeMutations?.(wake);
+        signal.addEventListener('abort', dispose, { once: true });
+        try {
+            install();
+        }
+        catch (error) {
+            fail(error);
+        }
+    }
+    const snapshot = () => ({ ...state, ...(disposed ? { health: 'failed' } : {}) });
+    // View-local cursors share coverage and health, but unrelated file commits
+    // cannot invalidate a capture. Unknown wakes remain conservative.
+    const cursor = (accepts, lifetime) => {
+        const entry = { accepts, position: state.position, dispose() { cursors.delete(entry); lifetime.removeEventListener('abort', entry.dispose); } };
+        if (!disposed && !lifetime.aborted) {
+            cursors.add(entry);
+            lifetime.addEventListener('abort', entry.dispose, { once: true });
+        }
+        return { snapshot: () => ({ ...snapshot(), position: entry.position }), dispose: entry.dispose };
+    };
+    return { snapshot, cursor, dispose };
+}

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) => {
@@ -138,7 +139,7 @@ export class RoleCreationService {
             reasoningEffort: resolved.effort,
             cwd, lifetime: request.lifetime,
             permissions: resolvePermissions(defaults.permissions, request.permissions),
-            monitor: resolveMonitorConfig(defaults.monitor, request.monitor),
+            monitor: resolveMonitorConfig(defaults.monitor, request.monitor, { harness: resolved.harness }),
         };
         const warnings = [];
         if (request.permissions.approval === 'allow')

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

@@ -1,9 +1,11 @@
+import { retireNotificationTarget } from '../notifications/target-cleanup.js';
 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 { removeReminderState } from '../reminders/store.js';
 import { provesGeneratedAgentSource } from '../generated-agent-source.js';
 export class RoleRemovalService {
     options;
@@ -18,6 +20,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 {
@@ -76,8 +84,11 @@ export class RoleRemovalService {
         const stamp = new Date().toISOString().replaceAll(/[:.]/g, '-');
         const recoveryPath = join(stateRoot(), 'recovery', 'removed', `${stamp}-${preview.role}`);
         mkdirSync(recoveryPath, { recursive: true, mode: 0o700 });
-        if (existsSync(sourceState))
+        if (existsSync(sourceState)) {
             cpSync(sourceState, join(recoveryPath, 'state'), { recursive: true });
+            // Recovery evidence is not a schedule: a removed agent's reminders end here.
+            removeReminderState(join(recoveryPath, 'state'));
+        }
         if (role && provesGeneratedAgentSource(agentDir(preview.role), cfg.files[0], role.sourceFile)
             && existsSync(role.sourceFile))
             cpSync(role.sourceFile, join(recoveryPath, basename(role.sourceFile)));
@@ -85,8 +96,11 @@ export class RoleRemovalService {
             await rmRole(cfg, preview.role, this.options.ops);
         else {
             await this.options.ops.backend.uninstall(preview.role);
-            if (existsSync(sourceState))
+            if (existsSync(sourceState)) {
                 renameSync(sourceState, join(recoveryPath, 'orphan-state'));
+                removeReminderState(join(recoveryPath, 'orphan-state'));
+            }
+            await retireNotificationTarget({ kind: 'agent', agentId: preview.role }).catch(() => { });
             this.options.ops.log(`removed orphaned backend/state '${preview.role}'`);
         }
         return { ...preview, removed: true, recoveryPath };

package/dist/application/role-repository.d.ts

@@ -14,7 +14,7 @@ export interface RoleRepositoryOptions {
 export declare class RoleRepository {
     private readonly options;
     constructor(options?: RoleRepositoryOptions);
-    list(): Promise<RoleRecord[]>;
+    list(strict?: boolean): Promise<RoleRecord[]>;
     get(id: string): Promise<RoleRecord | undefined>;
     stateDir(record: RoleRecord): string | undefined;
     private detect;