@ours.network/fleet 1.1.0-nightly.8 → 1.1.0

package/dist/owner-channel/commands.d.ts

@@ -1,7 +1,7 @@
 import type { InterruptOutcome, SessionEvent, SessionSnapshot } from '../session/types.js';
 import type { RoomOrchestrationRecord, TaskOutcome, TaskRecord, TaskTerminalIntent, TaskListRecord } from '../rooms-tasks/types.js';
 import { type OwnerCommentsState } from './notices.js';
-import type { CreateRoomRequest, CreateTaskRequest, TaskRoomApplicationService } from '../application/task-room-service.js';
+import type { CreateRoomRequest, CreateTaskRequest, TaskProvisioningOutcome, TaskRoomApplicationService } from '../application/task-room-service.js';
 import type { TaskState } from '../rooms-tasks/types.js';
 /**
  * Fleet-level effects a deterministic owner command may trigger. Production
@@ -17,7 +17,10 @@ export interface OwnerFleetOps {
     closeRoom(roomId: string): Promise<void>;
     /** Resume a task terminal intent outside the caller role's supervisor lifecycle. */
     settleTask(taskId: string): Promise<void>;
-    recoverTask(taskId: string): Promise<void>;
+    /** Settle an accepted task deletion outside the caller role's supervisor lifecycle. */
+    settleTaskDeletion(taskId: string): Promise<void>;
+    /** Continue an accepted provisioning saga until convergence. */
+    provisionTask(taskId: string): Promise<void>;
 }
 /**
  * The narrow capability surface a command executor sees. Everything here is
@@ -25,6 +28,7 @@ export interface OwnerFleetOps {
  * cannot name another agent or another recipient.
  */
 export interface OwnerCommandContext {
+    authenticatedCid?: string;
     role: string;
     /** Harness id of the role (e.g. 'claude-code', 'codex'); gates forwarding. */
     harness: string;
@@ -50,12 +54,11 @@ export interface OwnerCommandContext {
     fleetList(): Promise<string>;
     /** Persist acceptance, acknowledge it, then launch the external close worker. */
     closeRoom(roomId: string): Promise<void>;
-    recoverRoom(roomId: string): Promise<void>;
     /** Persist terminal intent, acknowledge it, then launch the external settle worker. */
     terminalTask(taskId: string, kind: TaskTerminalIntent['kind'], outcome?: TaskOutcome): Promise<void>;
-    recoverTask(taskId: string): Promise<void>;
     createTask(input: Omit<CreateTaskRequest, 'actor'>): Promise<TaskRecord>;
-    startTask(taskId: string): Promise<TaskRecord>;
+    startTask(taskId: string): Promise<TaskProvisioningOutcome | TaskRecord>;
+    taskProvisioningOutcome?(taskId: string): TaskProvisioningOutcome;
     listTasks(filter?: {
         state?: TaskState | TaskState[];
         list?: string;
@@ -83,7 +86,8 @@ export interface OwnerCommandContext {
     blockTask(taskId: string, reason: string): TaskRecord;
     unblockTask(taskId: string): TaskRecord;
     reviewTask(taskId: string): TaskRecord;
-    deleteTask(taskId: string): boolean;
+    /** Accept a permanent any-state deletion, acknowledge it, then launch the external delete worker. */
+    deleteTask(taskId: string): Promise<void>;
     listRoomQueries(filter?: {
         state?: 'active' | 'provisioning';
     }): ReturnType<TaskRoomApplicationService['listRooms']>;
@@ -94,6 +98,7 @@ export interface OwnerCommandContext {
     recentEvents(limit: number): SessionEvent[];
     readWorklogTail(maxChars: number): Promise<string | undefined>;
     reply(text: string): Promise<void>;
+    replyHtml(filename: string, html: string): Promise<void>;
 }
 export interface OwnerCommand {
     /** Primary name without the leading slash. */
@@ -105,6 +110,11 @@ export interface OwnerCommand {
     summary: string;
     execute(ctx: OwnerCommandContext, args: string): Promise<void>;
 }
+export interface OwnerTypedCommandDefinition {
+    name: string;
+    description: string;
+    input_schema: Record<string, unknown>;
+}
 /**
  * Commands each harness's bundled ACP adapter verifiably executes locally,
  * pinned by test/acp-adapter-commands.test.ts against the shipped adapter
@@ -121,6 +131,18 @@ export declare const HARNESS_LOCAL_COMMANDS: Record<string, readonly string[]>;
  * registration step for a new command.
  */
 export declare const ownerCommands: OwnerCommand[];
+/**
+ * Project the slash-command registry into the SDK catalog. Only primary names
+ * are advertised: aliases remain accepted by the slash dispatcher without
+ * cluttering the typed menu with duplicate actions.
+ *
+ * Typed arguments deliberately stay as the exact text following the command
+ * name. That adapter is what lets typed and slash invocations share every
+ * existing parser, usage error, lifecycle guard, and result path.
+ */
+export declare function ownerTypedCommandCatalog(): OwnerTypedCommandDefinition[];
+/** Convert one typed invocation back into the canonical slash input. */
+export declare function ownerTypedCommandText(name: string, input: unknown): string;
 /** Trimmed slash-prefixed text is a command attempt and is never forwarded. */
 export declare const isOwnerCommandText: (text: string) => boolean;
 export declare function ownerCommandHelp(error?: string): string;

package/dist/owner-channel/commands.js

@@ -6,6 +6,16 @@ import { markdownCode, markdownProse, renderMarkdownFailure, renderMarkdownList,
 import { OWNER_COMMENT_LABEL, ownerNotices } from './notices.js';
 import { TaskRoomApplicationError } from '../application/task-room-service.js';
 import { TaskListError } from '../rooms-tasks/task-lists.js';
+import { createTasksReport } from '../reports/index.js';
+async function ownerTaskReport(ctx) {
+    return createTasksReport({
+        viewer: { surface: 'messenger', authenticatedCid: ctx.authenticatedCid ?? 'owner-command-context', roomCids: [] },
+        collect: () => {
+            return { lists: ctx.listTaskLists(), tasks: ctx.listTasks() };
+        },
+        source: { name: 'ours-fleet', version: ctx.version },
+    });
+}
 /** A malformed invocation; the dispatcher answers it with annotated help. */
 class OwnerCommandUsageError extends Error {
 }
@@ -26,7 +36,7 @@ function isKnownOwnerTaskState(message) {
         /^task is not blocked$/u,
         new RegExp(`^task ${SAFE_ID_WORD} already has a conflicting '(?:done|cancelled)' terminal intent$`, 'u'),
         new RegExp(`^task ${SAFE_ID_WORD} is already in terminal state '${TASK_STATE_WORD}'$`, 'u'),
-        new RegExp(`^cannot delete a '${TASK_STATE_WORD}' task; only 'done' tasks can be deleted$`, 'u'),
+        new RegExp(`^task ${SAFE_ID_WORD} is pending deletion; run 'ours-fleet task delete ${SAFE_ID_WORD} ${SAFE_ID_WORD}' to retry cleanup$`, 'u'),
     ].some(pattern => pattern.test(message));
 }
 function isKnownOwnerRoomState(message) {
@@ -96,6 +106,22 @@ const taskAction = (title, task, fields = []) => renderMarkdownResult({
         ...fields,
     ],
 });
+const taskProvisioningAction = (outcome) => {
+    if (outcome.kind === 'failed')
+        return renderMarkdownFailure({
+            kind: 'state', subject: `/task start ${outcome.task.task_id}`,
+            detail: outcome.blocker ?? 'Provisioning reached a terminal failure.',
+            action: outcome.next_action ?? `Run /task start ${outcome.task.task_id}.`,
+        });
+    return taskAction(outcome.kind === 'ready' ? 'Room provisioning complete'
+        : outcome.next_action ? 'Room provisioning needs attention' : 'Room provisioning continues', outcome.task, [
+        ...(outcome.room ? [{ label: 'Room', value: `${outcome.room.room_id} — ${outcome.room.room_name}` }] : []),
+        ...(outcome.launch.template ? [{ label: 'Template', value: outcome.launch.template, kind: 'code' }] : []),
+        { label: 'Members', value: `${outcome.members.active}/${outcome.members.expected} active; ${outcome.members.launched}/${outcome.members.expected} launched` },
+        ...(outcome.blocker ? [{ label: 'Blocker', value: outcome.blocker }] : []),
+        ...(outcome.next_action ? [{ label: 'Next action', value: outcome.next_action }] : []),
+    ]);
+};
 const roomAction = (title, room, fields = []) => renderMarkdownResult({
     icon: '🏠', title,
     fields: [
@@ -242,10 +268,18 @@ export const ownerCommands = [
         execute: noArgs('/version', async (ctx) => ctx.reply(`ℹ️ ours-fleet ${ctx.version}`)),
     },
     {
-        name: 'tasks', usage: '/tasks [state]',
-        summary: 'list tasks (optionally filter by state)',
+        name: 'tasks', usage: '/tasks [state|html]',
+        summary: 'list tasks, or attach the HTML report with /tasks html',
         execute: async (ctx, args) => {
             const stateFilter = args?.trim() || undefined;
+            if (stateFilter === 'html') {
+                const artifact = await ownerTaskReport(ctx);
+                await ctx.replyHtml(artifact.metadata.filename, artifact.html);
+                await ctx.reply(`HTML report attached: ${artifact.metadata.filename}`);
+                return;
+            }
+            if (stateFilter && /\s/u.test(stateFilter))
+                throw new OwnerCommandUsageError('usage: /tasks [state|html]');
             const tasks = ctx.listTasks(stateFilter && stateFilter !== 'all' ? { state: stateFilter } : undefined);
             await ctx.reply(renderMarkdownList({
                 icon: '📋', title: 'Tasks', empty: 'No tasks found.',
@@ -255,7 +289,7 @@ export const ownerCommands = [
     },
     {
         name: 'task',
-        usage: '/task <create|list|show|start|block|unblock|review|done|cancel|delete|recover> ...',
+        usage: '/task <create|list|show|start|block|unblock|review|done|cancel|delete> ...',
         summary: 'task lifecycle subcommands',
         execute: async (ctx, args) => {
             if (!args)
@@ -301,6 +335,12 @@ export const ownerCommands = [
                             title: titleParts.join(' '), origin: { type: 'owner_channel' },
                             backlog, template, noRoom, brief: trailingLines, list,
                         });
+                        const provisioning = !backlog && !noRoom && t.room_id
+                            ? ctx.taskProvisioningOutcome?.(t.task_id) : undefined;
+                        if (provisioning) {
+                            await ctx.reply(taskProvisioningAction(provisioning));
+                            break;
+                        }
                         await ctx.reply(taskAction('Task created', t, [
                             { label: 'Title', value: t.title },
                             ...(template ? [{ label: 'Template', value: template, kind: 'code' }] : []),
@@ -309,6 +349,9 @@ export const ownerCommands = [
                         break;
                     }
                     case 'list': {
+                        if (rest.some(value => value.startsWith('--')
+                            && value !== '--group-by-list' && !value.startsWith('--list=')))
+                            throw new OwnerCommandUsageError('usage: /task list [state] [--list=<name>] [--group-by-list]');
                         const listFlag = rest.find(r => r.startsWith('--list='));
                         const list = trailingLines ?? listFlag?.slice('--list='.length);
                         const grouped = rest.includes('--group-by-list');
@@ -345,6 +388,8 @@ export const ownerCommands = [
                         break;
                     }
                     case 'lists': {
+                        if (rest.length || trailingLines)
+                            throw new OwnerCommandUsageError('usage: /task lists');
                         const lists = ctx.listTaskLists();
                         await ctx.reply(renderMarkdownList({ icon: '📚', title: 'Task lists', empty: 'No task lists found.',
                             records: lists.map(list => `${markdownCode(list.name)}${list.built_in ? ' — built-in' : ''}`) }));
@@ -388,7 +433,7 @@ export const ownerCommands = [
                         break;
                     }
                     case 'show': {
-                        if (!rest[0])
+                        if (rest.length !== 1 || rest[0].startsWith('--'))
                             throw new OwnerCommandUsageError('usage: /task show <id>');
                         await showTask(rest[0]);
                         break;
@@ -396,8 +441,9 @@ export const ownerCommands = [
                     case 'start': {
                         if (!rest[0])
                             throw new OwnerCommandUsageError('usage: /task start <id>');
-                        const t = await ctx.startTask(rest[0]);
-                        await ctx.reply(taskAction('Task started', t));
+                        const started = await ctx.startTask(rest[0]);
+                        await ctx.reply('kind' in started
+                            ? taskProvisioningAction(started) : taskAction('Task started', started));
                         break;
                     }
                     case 'block': {
@@ -438,21 +484,13 @@ export const ownerCommands = [
                     case 'delete': {
                         if (rest.length !== 2 || rest[0] !== rest[1])
                             throw new OwnerCommandUsageError('destructive: /task delete <id> <id> — provide the task ID twice');
-                        const deleted = ctx.deleteTask(rest[0]);
-                        await ctx.reply(renderMarkdownResult({
-                            icon: '🗑️', title: deleted ? 'Task deleted' : 'Task already absent',
-                            fields: [{ label: 'ID', value: rest[0], kind: 'code' }],
-                        }));
-                        break;
-                    }
-                    case 'recover': {
-                        if (!rest[0])
-                            throw new OwnerCommandUsageError('usage: /task recover <id>');
-                        await ctx.recoverTask(rest[0]);
+                        await ctx.deleteTask(rest[0]);
                         break;
                     }
                     default:
                         // bare /task <id> → show
+                        if (sub === 'recover' || sub === 'await' || rest.length)
+                            throw new OwnerCommandUsageError(`unknown task subcommand: ${sub}`);
                         await showTask(sub);
                 }
             }
@@ -482,7 +520,7 @@ export const ownerCommands = [
     },
     {
         name: 'room',
-        usage: '/room <create|list|show|delete|close|recover> ...',
+        usage: '/room <create|list|show|delete|close> ...',
         summary: 'room lifecycle subcommands',
         execute: async (ctx, args) => {
             if (!args)
@@ -567,14 +605,10 @@ export const ownerCommands = [
                         await ctx.closeRoom(rest[0]);
                         break;
                     }
-                    case 'recover': {
-                        if (!rest[0])
-                            throw new OwnerCommandUsageError('usage: /room recover <id>');
-                        await ctx.recoverRoom(rest[0]);
-                        break;
-                    }
                     default:
                         // bare /room <id> → show
+                        if (sub === 'recover' || rest.length)
+                            throw new OwnerCommandUsageError(`unknown room subcommand: ${sub}`);
                         await showRoom(sub);
                 }
             }
@@ -628,7 +662,7 @@ export const ownerCommands = [
                     ...(t.contract ? [`Contract: ${t.contract}`] : []),
                     'Members:',
                     ...t.members.map(m => `  ${m.slot} (${m.role}) ×${m.count} → `
-                        + `${'ref' in m.agent ? `Agent ref: ${m.agent.ref}` : 'inline Agent'}`),
+                        + `Agent Template: ${m.agent_template}`),
                 ];
                 await ctx.reply(lines.join('\n'));
             };
@@ -654,6 +688,53 @@ export const ownerCommands = [
         },
     },
 ];
+/**
+ * Project the slash-command registry into the SDK catalog. Only primary names
+ * are advertised: aliases remain accepted by the slash dispatcher without
+ * cluttering the typed menu with duplicate actions.
+ *
+ * Typed arguments deliberately stay as the exact text following the command
+ * name. That adapter is what lets typed and slash invocations share every
+ * existing parser, usage error, lifecycle guard, and result path.
+ */
+export function ownerTypedCommandCatalog() {
+    return ownerCommands.map(command => {
+        const usage = command.usage ?? `/${command.name}`;
+        const suffix = usage.slice(usage.indexOf(' ') + 1);
+        const acceptsArguments = usage.includes(' ');
+        const requiresArguments = acceptsArguments && !suffix.startsWith('[');
+        return {
+            name: command.name,
+            description: `${command.summary} (${usage})`,
+            input_schema: {
+                type: 'object',
+                properties: acceptsArguments ? {
+                    arguments: {
+                        type: 'string', title: 'Arguments',
+                        description: `Text after /${command.name}. Usage: ${usage}`,
+                    },
+                } : {},
+                ...(requiresArguments ? { required: ['arguments'] } : {}),
+            },
+        };
+    });
+}
+/** Convert one typed invocation back into the canonical slash input. */
+export function ownerTypedCommandText(name, input) {
+    const command = ownerCommands.find(entry => entry.name === name);
+    if (!command)
+        throw new Error(`unknown typed owner command: ${name}`);
+    if (!input || typeof input !== 'object' || Array.isArray(input))
+        throw new Error('typed owner command arguments must be an object');
+    const record = input;
+    if (Object.keys(record).some(key => key !== 'arguments'))
+        throw new Error('typed owner command arguments contain an unknown field');
+    const value = record.arguments;
+    if (value !== undefined && typeof value !== 'string')
+        throw new Error('typed owner command arguments must be text');
+    const args = value?.trim() ?? '';
+    return `/${command.name}${args ? ` ${args}` : ''}`;
+}
 /** Trimmed slash-prefixed text is a command attempt and is never forwarded. */
 export const isOwnerCommandText = (text) => text.trim().startsWith('/');
 export function ownerCommandHelp(error) {
@@ -711,6 +792,7 @@ export function fleetCliOps(role, configPath) {
         }),
         closeRoom: roomId => launchFleetWorker(['room', '_delete', roomId], `room-delete-${roomId}`, configPath),
         settleTask: taskId => launchFleetWorker(['task', '_settle', taskId], `task-settle-${taskId}`, configPath),
-        recoverTask: taskId => launchFleetWorker(['task', '_recover', taskId], `task-recover-${taskId}`, configPath),
+        settleTaskDeletion: taskId => launchFleetWorker(['task', '_settle_delete', taskId], `task-delete-${taskId}`, configPath),
+        provisionTask: taskId => launchFleetWorker(['task', '_provision', taskId], `task-provision-${taskId}`, configPath),
     };
 }

package/dist/owner-channel/lifecycle-outbox.d.ts

@@ -0,0 +1,24 @@
+import { type FleetAuditPresentation } from '../fleet-command-audit.js';
+type LifecycleDelivery = 'pending' | 'delivered' | 'uncertain';
+interface LifecycleOutboxEntry {
+    digest: string;
+    presentation: FleetAuditPresentation;
+    delivery: LifecycleDelivery;
+}
+/** Durable lifecycle acceptance queue; plaintext is limited to validated concise presentations. */
+export declare class FleetLifecycleOutbox {
+    private readonly path;
+    private entries;
+    private corruptReason?;
+    constructor(path: string);
+    integrity(): {
+        ok: boolean;
+        error?: string;
+    };
+    enqueue(presentations: FleetAuditPresentation[]): void;
+    pending(): readonly LifecycleOutboxEntry[];
+    finish(digest: string, delivery: Exclude<LifecycleDelivery, 'pending'>): void;
+    private assertHealthy;
+    private persist;
+}
+export {};

package/dist/owner-channel/lifecycle-outbox.js

@@ -0,0 +1,87 @@
+import { createHash } from 'node:crypto';
+import { chmodSync, existsSync, readFileSync } from 'node:fs';
+import { replaceFileAtomically } from '../atomic-file.js';
+import { lifecycleEventDigestBasis, validateFleetAuditPresentations, } from '../fleet-command-audit.js';
+const DIGEST = /^[a-f0-9]{64}$/u;
+const LIMIT = 5_000;
+/** Durable lifecycle acceptance queue; plaintext is limited to validated concise presentations. */
+export class FleetLifecycleOutbox {
+    path;
+    entries = [];
+    corruptReason;
+    constructor(path) {
+        this.path = path;
+        if (!existsSync(path))
+            return;
+        try {
+            const value = JSON.parse(readFileSync(path, 'utf8'));
+            if (value.version !== 1 || !Array.isArray(value.entries) || value.entries.length > LIMIT)
+                throw new Error('invalid lifecycle outbox');
+            const digests = new Set();
+            for (const entry of value.entries) {
+                validateFleetAuditPresentations([entry?.presentation]);
+                if (!DIGEST.test(entry.digest)
+                    || !['pending', 'delivered', 'uncertain'].includes(entry.delivery)
+                    || digests.has(entry.digest))
+                    throw new Error('invalid lifecycle outbox entry');
+                digests.add(entry.digest);
+            }
+            this.entries = structuredClone(value.entries);
+            chmodSync(path, 0o600);
+        }
+        catch {
+            this.corruptReason = 'invalid persisted Fleet lifecycle outbox';
+            this.entries = [];
+            try {
+                chmodSync(path, 0o600);
+            }
+            catch { /* remain fail-closed */ }
+        }
+    }
+    integrity() {
+        return this.corruptReason ? { ok: false, error: this.corruptReason } : { ok: true };
+    }
+    enqueue(presentations) {
+        this.assertHealthy();
+        validateFleetAuditPresentations(presentations);
+        let changed = false;
+        for (const presentation of presentations) {
+            const digest = createHash('sha256').update(lifecycleEventDigestBasis(presentation)).digest('hex');
+            if (this.entries.some(entry => entry.digest === digest))
+                continue;
+            if (this.entries.length >= LIMIT) {
+                const settled = this.entries.findIndex(entry => entry.delivery !== 'pending');
+                if (settled < 0)
+                    throw new Error(`Fleet lifecycle outbox is limited to ${LIMIT} pending events`);
+                this.entries.splice(settled, 1);
+            }
+            this.entries.push({ digest, presentation: structuredClone(presentation), delivery: 'pending' });
+            changed = true;
+        }
+        if (changed)
+            this.persist();
+    }
+    pending() {
+        this.assertHealthy();
+        return this.entries.filter(entry => entry.delivery === 'pending').map(entry => structuredClone(entry));
+    }
+    finish(digest, delivery) {
+        this.assertHealthy();
+        const entry = this.entries.find(candidate => candidate.digest === digest);
+        if (!entry)
+            throw new Error('unknown Fleet lifecycle outbox entry');
+        if (entry.delivery === delivery)
+            return;
+        if (entry.delivery !== 'pending')
+            throw new Error('conflicting Fleet lifecycle delivery state');
+        entry.delivery = delivery;
+        this.persist();
+    }
+    assertHealthy() {
+        if (this.corruptReason)
+            throw new Error(this.corruptReason);
+    }
+    persist() {
+        replaceFileAtomically(this.path, `${JSON.stringify({ version: 1, entries: this.entries })}\n`, 0o600);
+    }
+}

package/dist/owner-channel/ours-client.d.ts

@@ -23,6 +23,22 @@ export type OursRetrievedFiles = Res<'getFiles'>;
 export type OursRetrievedFile = OursRetrievedFiles['files'][number];
 export type OursHistoryFile = NonNullable<Res<'getFileInfo'>>;
 export type OursNotificationEvent = NotificationEvent;
+export type OursJsonValue = null | boolean | number | string | OursJsonValue[] | {
+    [key: string]: OursJsonValue;
+};
+export interface OursCommandContext {
+    readonly sender_cid: string;
+    readonly sender_name: string;
+    readonly request_wire_id: string;
+}
+export interface OursRegisteredCommand {
+    name: string;
+    description?: string;
+    input_schema: {
+        [key: string]: OursJsonValue;
+    };
+    handler(argumentsValue: OursJsonValue, context: Readonly<OursCommandContext>): OursJsonValue | Promise<OursJsonValue>;
+}
 export declare class OursWatchDeadlineError extends OursDaemonError {
 }
 /**
@@ -41,6 +57,8 @@ export interface OursOps {
     start(): Promise<void>;
     /** Bind this session's identity. Throws `BOUND_ELSEWHERE` when it is held live. */
     bindIdentity(name: string): Promise<void>;
+    /** Replace the bound identity's advertised typed-command catalog and handlers. */
+    registerCommands(commands: OursRegisteredCommand[]): Promise<void>;
     listContacts(): Promise<OursContactsView>;
     generateInvite(name?: string): Promise<OursInviteResult>;
     addContact(a: {
@@ -114,6 +132,7 @@ export declare class OursSdkClient implements OursOps {
     constructor(env?: Record<string, string>, log?: (line: string) => void, deps?: OursSdkClientDeps);
     start(): Promise<void>;
     bindIdentity(name: string): Promise<void>;
+    registerCommands(commands: OursRegisteredCommand[]): Promise<void>;
     listContacts(): Promise<OursContactsView>;
     generateInvite(name?: string): Promise<OursInviteResult>;
     addContact(a: {

package/dist/owner-channel/ours-client.js

@@ -140,6 +140,9 @@ export class OursSdkClient {
         // from an identity, it waits for the bounded handoff window and then fails.
         await this.ops().chooseIdentity({ name, force: false });
     }
+    async registerCommands(commands) {
+        await this.ops().registerCommands(commands);
+    }
     async listContacts() {
         return this.ops().listContacts();
     }

package/dist/owner-channel/state.d.ts

@@ -1,5 +1,7 @@
 /** A send whose (dedupe-scoped) digest was already recorded: it must not repeat. */
 export declare class DuplicateSendError extends Error {
+    readonly status: OwnerProactiveSend['status'];
+    constructor(status: OwnerProactiveSend['status']);
 }
 /** Durable bounded dedupe containing wire IDs only — never message or reply plaintext. */
 export declare class OwnerChannelState {

package/dist/owner-channel/state.js

@@ -5,6 +5,11 @@ import { replaceFileAtomically } from '../atomic-file.js';
 import { canonicalCid } from '../config.js';
 /** A send whose (dedupe-scoped) digest was already recorded: it must not repeat. */
 export class DuplicateSendError extends Error {
+    status;
+    constructor(status) {
+        super('duplicate proactive owner message refused');
+        this.status = status;
+    }
 }
 /** Durable bounded dedupe containing wire IDs only — never message or reply plaintext. */
 export class OwnerChannelState {
@@ -184,8 +189,9 @@ export class OwnerConversationState {
         // 'all' scope serves wire-keyed idempotency: a crash replay must not
         // deliver the same wire to a second owner after the route moved.
         const scope = dedupe === 'all' ? this.sends : recent;
-        if (scope.some(send => send.digest === digest))
-            throw new DuplicateSendError('duplicate proactive owner message refused');
+        const duplicate = scope.find(send => send.digest === digest);
+        if (duplicate)
+            throw new DuplicateSendError(duplicate.status);
         const last = recent.at(-1);
         if (last && now - last.at < minIntervalMs)
             throw new Error(`proactive owner messages are rate-limited to one every ${minIntervalMs}ms`);

package/dist/permissions.js

@@ -85,7 +85,7 @@ export function analyzeRolePermissions(role) {
         translation = { ...translation, capabilities: inspection.capabilities };
     }
     const conflicts = neutral.supported
-        ? findConflicts(role, neutral.native, adapter.nativePermissionOverrides(role.harness_options))
+        ? findConflicts(role, neutral.native, adapter.nativePermissionOverrides(role.harness_options, role))
         : [];
     const floor = checkUnattendedFloor(translation.capabilities, requiredUnattendedFloor(role));
     const floorSeverity = role.permissions.unattended === 'deny' ? 'fail' : 'warn';

package/dist/preset-migration.d.ts

@@ -0,0 +1,42 @@
+import { renameSync } from 'node:fs';
+export declare const legacyStarterMigrationManifest: Readonly<{
+    schemaVersion: 1;
+    presetRevision: 2;
+    fingerprints: Readonly<Record<string, string>>;
+}>;
+export interface PresetMigrationResult {
+    write: boolean;
+    root: string;
+    stagingPath: string;
+    backupPath: string;
+    moves: Array<{
+        from: string;
+        to: string;
+    }>;
+    additions: string[];
+}
+export interface RoleDefaultMigrationResult {
+    write: boolean;
+    root: string;
+    stagingPath: string;
+    backupPath: string;
+    removals: string[];
+    replacements: string[];
+    additions: string[];
+    preserved: string[];
+}
+interface MigrationHooks {
+    rename?: typeof renameSync;
+    nonce?: string;
+    beforeLockClaim?: () => void;
+    beforeRoleDefaultPublish?: () => void;
+}
+/** Explicit adoption of exact known packaged role defaults; customized files are never changed. */
+export declare function migratePackagedRoleDefaults(configuration: string, options?: {
+    write?: boolean;
+}, hooks?: MigrationHooks): RoleDefaultMigrationResult;
+/** Explicit safe migration of the exact revision-2 six-worker starter set. Dry-run unless write=true. */
+export declare function migrateLegacyStarterPresets(configuration: string, options?: {
+    write?: boolean;
+}, hooks?: MigrationHooks): PresetMigrationResult;
+export {};