@ours.network/fleet 1.1.0-nightly.2 → 1.1.0-nightly.21

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) {
@@ -242,10 +252,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.',
@@ -309,6 +327,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 +366,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 +411,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;
@@ -438,11 +461,7 @@ 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' }],
-                        }));
+                        await ctx.deleteTask(rest[0]);
                         break;
                     }
                     case 'recover': {
@@ -598,10 +617,7 @@ export const ownerCommands = [
             const templates = ctx.listTemplateQueries();
             if (!templates.length)
                 return ctx.reply('📐 No templates.');
-            const lines = templates.map(t => {
-                const tag = t.builtin ? ' (built-in)' : '';
-                return `${t.name}@${t.version}${tag}  ${t.description}`;
-            });
+            const lines = templates.map(t => `${t.name}@${t.version}  ${t.description}  [file: ${t.sourceFile ?? 'manifest'}]`);
             await ctx.reply(`📐 Templates:\n${lines.join('\n')}`);
         }),
     },
@@ -627,10 +643,11 @@ export const ownerCommands = [
                 const lines = [
                     `📐 Template: ${t.name}@${t.version}`,
                     `Description: ${t.description}`,
-                    ...(t.builtin ? ['Source: built-in'] : []),
+                    `Source: ${t.sourceFile ?? 'manifest'}`,
                     ...(t.contract ? [`Contract: ${t.contract}`] : []),
                     'Members:',
-                    ...t.members.map(m => `  ${m.slot} (${m.role}) ×${m.count} → role_ref: ${m.role_ref}`),
+                    ...t.members.map(m => `  ${m.slot} (${m.role}) ×${m.count} → `
+                        + `Agent Template: ${m.agent_template}`),
                 ];
                 await ctx.reply(lines.join('\n'));
             };
@@ -645,10 +662,7 @@ export const ownerCommands = [
                     const templates = ctx.listTemplateQueries();
                     if (!templates.length)
                         return ctx.reply('📐 No templates.');
-                    const lines = templates.map(t => {
-                        const tag = t.builtin ? ' (built-in)' : '';
-                        return `${t.name}@${t.version}${tag}  ${t.description}`;
-                    });
+                    const lines = templates.map(t => `${t.name}@${t.version}  ${t.description}  [file: ${t.sourceFile ?? 'manifest'}]`);
                     await ctx.reply(`📐 Templates:\n${lines.join('\n')}`);
                     break;
                 }
@@ -716,6 +730,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),
+        settleTaskDeletion: taskId => launchFleetWorker(['task', '_settle_delete', taskId], `task-delete-${taskId}`, configPath),
         recoverTask: taskId => launchFleetWorker(['task', '_recover', taskId], `task-recover-${taskId}`, configPath),
     };
 }

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-bootstrap.d.ts

@@ -0,0 +1,10 @@
+export interface BootstrapResult {
+    revision: number;
+    sourceRoot: string;
+    configPath: string;
+    created: string[];
+    preserved: string[];
+}
+export declare const packagedPresetRoot: () => string;
+/** Seed packaged defaults without replacing a single existing byte. */
+export declare function bootstrapPresets(configuration?: string): BootstrapResult;

package/dist/preset-bootstrap.js

@@ -0,0 +1,85 @@
+import { constants, copyFileSync, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, chmodSync, } from 'node:fs';
+import { dirname, join, relative, resolve, sep } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { defaultConfigPath } from './paths.js';
+import { splitRootFor } from './config.js';
+export const packagedPresetRoot = () => fileURLToPath(new URL('../presets', import.meta.url));
+function assertSafeExisting(path, kind) {
+    const stat = lstatSync(path);
+    if (stat.isSymbolicLink())
+        throw new Error(`preset bootstrap refuses symlink target: ${path}`);
+    if (kind === 'file' ? !stat.isFile() : !stat.isDirectory())
+        throw new Error(`preset bootstrap expected ${kind}: ${path}`);
+    const uid = process.getuid?.();
+    if (uid !== undefined && stat.uid !== uid)
+        throw new Error(`preset bootstrap refuses target owned by uid ${stat.uid}: ${path}`);
+    if ((stat.mode & 0o022) !== 0)
+        throw new Error(`preset bootstrap refuses group/world-writable target: ${path}`);
+}
+function ensureDirectory(path) {
+    const parent = dirname(path);
+    if (parent !== path && !existsSync(parent))
+        ensureDirectory(parent);
+    if (existsSync(path)) {
+        assertSafeExisting(path, 'directory');
+        return;
+    }
+    mkdirSync(path, { mode: 0o700 });
+}
+function seedFile(source, target, result) {
+    ensureDirectory(dirname(target));
+    if (existsSync(target)) {
+        assertSafeExisting(target, 'file');
+        result.preserved.push(target);
+        return;
+    }
+    try {
+        copyFileSync(source, target, constants.COPYFILE_EXCL);
+        chmodSync(target, 0o600);
+        result.created.push(target);
+    }
+    catch (error) {
+        if (error.code !== 'EEXIST')
+            throw error;
+        assertSafeExisting(target, 'file');
+        result.preserved.push(target);
+    }
+}
+function presetFiles(root) {
+    const files = [];
+    const visit = (directory) => {
+        for (const entry of readdirSync(directory, { withFileTypes: true })) {
+            const path = join(directory, entry.name);
+            if (entry.isDirectory())
+                visit(path);
+            else if (entry.isFile())
+                files.push(path);
+        }
+    };
+    visit(root);
+    return files.sort();
+}
+/** Seed packaged defaults without replacing a single existing byte. */
+export function bootstrapPresets(configuration = defaultConfigPath()) {
+    const sourceRoot = packagedPresetRoot();
+    const manifest = JSON.parse(readFileSync(join(sourceRoot, 'manifest.json'), 'utf8'));
+    if (manifest.schema_version !== 1 || !Number.isInteger(manifest.preset_revision))
+        throw new Error(`invalid packaged preset manifest: ${join(sourceRoot, 'manifest.json')}`);
+    const configPath = resolve(configuration);
+    const result = {
+        revision: manifest.preset_revision, sourceRoot, configPath, created: [], preserved: [],
+    };
+    ensureDirectory(dirname(configPath));
+    seedFile(join(sourceRoot, 'fleet.yaml'), configPath, result);
+    const sourceSplit = join(sourceRoot, 'fleet');
+    const targetSplit = splitRootFor(configPath);
+    if (existsSync(targetSplit))
+        assertSafeExisting(targetSplit, 'directory');
+    for (const source of presetFiles(sourceSplit)) {
+        const rel = relative(sourceSplit, source);
+        if (rel.startsWith('..') || rel.includes(`..${sep}`))
+            throw new Error(`invalid packaged preset path: ${source}`);
+        seedFile(source, join(targetSplit, rel), result);
+    }
+    return result;
+}

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 packaged revision-3 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 {};