@ours.network/fleet 2.2.5 → 2.3.0

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

@@ -174,6 +174,15 @@ export interface TaskRecord {
     notification_manifest?: import('./notification-manifest.js').TaskNotificationManifest;
     workspace?: import('./workspace.js').OwnedWorkspace;
     task_id: string;
+    /**
+     * Immutable human mission key (`MSN-1`), issued once from a durable
+     * per-prefix high-water mark. Absent only before the one-time migration.
+     */
+    key?: string;
+    /** Set when the key was backfilled for a task that existed before mission keys. */
+    key_from_migration?: true;
+    /** Durable per-mission agent name allocations; absent until first allocation or migration. */
+    member_naming?: MemberNaming;
     /** Stable organizational list identifier. Missing legacy values mean `default`. */
     list_id: string;
     /** Derived presentation field; repositories must never persist it. */
@@ -211,9 +220,30 @@ export interface TaskRecord {
     terminal_intent?: TaskTerminalIntent;
     deletion?: TaskDeletionIntent;
 }
+/**
+ * Role-scoped agent names: `<KEY>-<Stem>` for the first member of a stem,
+ * `<KEY>-<Stem>-<n>` (n >= 2) after it. Counters only grow; an allocation is
+ * reused by provisioning, recovery and restart, never by a replacement.
+ */
+export interface MemberNameAllocation {
+    name: string;
+    /** Counter bucket: the case-folded truncated stem. Absent on frozen legacy names. */
+    bucket?: string;
+    ordinal?: number;
+    label_source?: 'role_override' | 'template_ref' | 'room_role' | 'participant_key' | 'slot' | 'fallback';
+    /** A historical name kept exactly as launched before mission keys existed. */
+    frozen?: true;
+}
+export interface MemberNaming {
+    version: 2;
+    counters: Record<string, number>;
+    allocations: Record<string, MemberNameAllocation>;
+}
 export interface TaskListRecord {
     list_id: string;
     name: string;
+    /** Prefix for new mission keys; absent only before the one-time key migration. */
+    prefix?: string;
     built_in: boolean;
     created_at: string;
 }
@@ -387,6 +417,8 @@ export interface TemplateSnapshotMember extends TemplateMemberSlot {
         id: string;
         hash: string;
     };
+    /** Named Role of the member's Agent Template, sealed at plan time for agent naming. */
+    role_label?: string;
 }
 export interface TemplateSnapshot extends Omit<TemplateDefinition, 'members'> {
     members: TemplateSnapshotMember[];
@@ -418,13 +450,15 @@ export interface TasksConfig {
     create_mode?: 'start' | 'backlog';
     close_room_on_done?: boolean;
     retain_completed_for?: string;
+    /** Default list prefix (default MSN); may change only before the first mission key. */
+    default_prefix?: string;
 }
 export type RoomTemplatesConfig = Record<string, TemplateDefinition>;
 export declare const ROOMS_KEYS: readonly ["cowork", "owner", "defaults"];
 export declare const ROOMS_OWNER_KEYS: readonly ["provider", "public_invite", "public_invite_file", "expected_cid", "role"];
 export declare const ROOMS_COWORK_KEYS: readonly ["config"];
 export declare const ROOMS_DEFAULTS_KEYS: readonly ["template", "attach_owner", "close_when_task_done"];
-export declare const TASKS_KEYS: readonly ["default_room_template", "create_mode", "close_room_on_done", "retain_completed_for"];
+export declare const TASKS_KEYS: readonly ["default_room_template", "create_mode", "close_room_on_done", "retain_completed_for", "default_prefix"];
 export declare const TEMPLATE_KEYS: readonly ["version", "description", "room", "contract", "members", "override_builtin"];
 export declare const TEMPLATE_ROOM_KEYS: readonly ["quiet_membership", "anonymous"];
 /** `agent` is accepted only so validation can emit its actionable migration error. */

package/dist/rooms-tasks/types.js

@@ -23,7 +23,7 @@ export const ROOMS_KEYS = ['cowork', 'owner', 'defaults'];
 export const ROOMS_OWNER_KEYS = ['provider', 'public_invite', 'public_invite_file', 'expected_cid', 'role'];
 export const ROOMS_COWORK_KEYS = ['config'];
 export const ROOMS_DEFAULTS_KEYS = ['template', 'attach_owner', 'close_when_task_done'];
-export const TASKS_KEYS = ['default_room_template', 'create_mode', 'close_room_on_done', 'retain_completed_for'];
+export const TASKS_KEYS = ['default_room_template', 'create_mode', 'close_room_on_done', 'retain_completed_for', 'default_prefix'];
 export const TEMPLATE_KEYS = ['version', 'description', 'room', 'contract', 'members', 'override_builtin'];
 export const TEMPLATE_ROOM_KEYS = ['quiet_membership', 'anonymous'];
 /** `agent` is accepted only so validation can emit its actionable migration error. */

package/dist/web/runtime.js

@@ -193,13 +193,16 @@ export async function startWebConsole(options) {
     const topologyPromote = new TopologyPromoteService({
         drafts: topologyDrafts, configuration, topology: readTopology,
     });
+    const taskRooms = new TaskRoomApplicationService(options.configPath, { binPath: () => options.binPath });
+    // One-time, lock-guarded mission key migration before serving; failure leaves it to the next mutation.
+    await taskRooms.prepareMissionKeys().catch(error => console.warn(`mission key migration deferred: ${error.message}`));
     let server;
     try {
         server = await buildWebServer({
             query, repository, logs, commands, creation, removal, audit, events, watchdogs, configuration, observeRole,
             resourceScope: { configPath: configuration.path, subscribeMutations: listener => events.subscribeResources(listener) },
             invalidateResourceCaches: () => { watchdogConfigProvider.invalidate(); watchdogFindings.invalidate(); },
-            taskRooms: new TaskRoomApplicationService(options.configPath, { binPath: () => options.binPath }),
+            taskRooms,
             roomLayouts: new RoomLayoutDefinitions(options.configPath),
             layoutBindings: new LayoutBindingGrants(new RoomLayoutService(options.configPath).supervisor()),
             presetProvenance: new PresetProvenance(options.configPath),

package/dist/web/server.js

@@ -26,7 +26,8 @@ import { WebAuth } from './auth.js';
 import { FleetEventBus } from './events.js';
 import { ROLE_NAME_RE } from '../config.js';
 import { TaskListError } from '../rooms-tasks/task-lists.js';
-import { acknowledgeTaskProgress, acknowledgeTaskReview, contributionUnread, TaskStateError } from '../rooms-tasks/task-state.js';
+import { acknowledgeTaskProgress, acknowledgeTaskReview, contributionUnread, resolveTaskRef, TaskStateError } from '../rooms-tasks/task-state.js';
+import { MissionKeyError } from '../rooms-tasks/mission-keys.js';
 import { appendTaskProgress, getTaskReview, taskProgressSnapshot, publicProgressEntry, publicReview, readTaskReviewArtifact, setTaskReviewMarkdown, taskContributionSummary, TaskReviewError, } from '../rooms-tasks/task-review.js';
 import { isProvider } from '../subscriptions/store.js';
 const ONBOARDING_WORK = ['coordination', 'development', 'review'];
@@ -321,6 +322,8 @@ export async function buildWebServer(services, boundary, options = {}) {
                         ? 'conflict' : 'invalid_request';
                 throw new FleetError(code, error.message);
             }
+            if (error instanceof MissionKeyError)
+                throw new FleetError(error.code === 'invalid_prefix' ? 'invalid_request' : 'conflict', error.message, { details: { reason: error.code } });
             if (error instanceof TaskStateError && 'accepted' in error && error.accepted === false)
                 return Promise.reject(Object.assign(new FleetError('invalid_request', error.message), { memberNotAccepted: true }));
             if (error instanceof TaskStateError) {
@@ -329,6 +332,20 @@ export async function buildWebServer(services, boundary, options = {}) {
             throw error;
         }
     };
+    /** Canonical task ID for a `:id` param holding an ID or a mission key; call only after authentication. */
+    const taskRef = (request, options = {}) => {
+        const ref = String(request.params.id ?? '');
+        try {
+            return resolveTaskRef(ref, options);
+        }
+        catch (error) {
+            if (error instanceof MissionKeyError)
+                throw new FleetError('resource_not_found', error.message);
+            if (error instanceof TaskStateError)
+                throw new FleetError(error.message.startsWith('task not found:') ? 'resource_not_found' : 'invalid_request', error.message);
+            throw error;
+        }
+    };
     const reviewApi = async (fn) => taskApi(async () => {
         try {
             return await fn();
@@ -345,7 +362,7 @@ export async function buildWebServer(services, boundary, options = {}) {
     });
     /** Browser task payloads carry Progress/To review counts; bodies have their own routes. */
     const wireTask = (task) => {
-        const { progress: _progress, review: _review, ...rest } = task;
+        const { progress: _progress, review: _review, member_naming: _naming, ...rest } = task;
         return { ...rest, ...taskContributionSummary(task) };
     };
     const wireTaskResult = (result) => {
@@ -517,15 +534,29 @@ export async function buildWebServer(services, boundary, options = {}) {
     });
     app.post('/api/v1/task-lists', async (request, reply) => {
         auth.authenticate(request, true);
-        const name = String(request.body?.name ?? '');
-        const list = await taskApi(() => requireTaskRooms().createTaskList({ actor: { kind: 'local_control', surface: 'web' }, name }));
+        const body = request.body;
+        const name = String(body?.name ?? '');
+        if (body?.prefix !== undefined && typeof body.prefix !== 'string')
+            throw new FleetError('invalid_request', 'prefix must be a string');
+        const list = await taskApi(() => requireTaskRooms().createTaskList({ actor: { kind: 'local_control', surface: 'web' }, name,
+            prefix: body?.prefix }));
         reply.code(201);
         return { list };
     });
+    app.get('/api/v1/task-lists/prefix-suggestion', async (request) => {
+        auth.authenticate(request);
+        const name = String(request.query.name ?? '');
+        return { prefix: await taskApi(() => requireTaskRooms().suggestTaskListPrefix(name)) };
+    });
     app.patch('/api/v1/task-lists/:name', async (request) => {
         auth.authenticate(request, true);
         const name = request.params.name;
-        const newName = String(request.body?.name ?? '');
+        const body = request.body;
+        if (body?.prefix !== undefined && typeof body.prefix !== 'string')
+            throw new FleetError('invalid_request', 'prefix must be a string');
+        if (body?.name === undefined && typeof body?.prefix === 'string')
+            return { list: await taskApi(() => requireTaskRooms().setTaskListPrefix({ actor: { kind: 'local_control', surface: 'web' }, name, prefix: body.prefix })) };
+        const newName = String(body?.name ?? '');
         return { list: await taskApi(() => requireTaskRooms().renameTaskList({ actor: { kind: 'local_control', surface: 'web' }, name, newName })) };
     });
     app.delete('/api/v1/task-lists/:name', async (request) => {
@@ -540,11 +571,13 @@ export async function buildWebServer(services, boundary, options = {}) {
     });
     app.delete('/api/v1/tasks/:id', async (request, reply) => {
         auth.authenticate(request, true);
-        const taskId = request.params.id;
+        const submitted = request.params.id;
         const confirm = request.query.confirm;
-        // Exact-ID-twice confirmation is validated before existence or idempotency.
-        if (confirm !== taskId)
-            throw new FleetError('invalid_request', 'confirm must exactly repeat the task id');
+        // Exact raw ref-twice confirmation is validated before existence or idempotency.
+        if (confirm !== submitted)
+            throw new FleetError('invalid_request', 'confirm must exactly repeat the task id or key');
+        // A deleted key still maps to its canonical ID, so a repeated DELETE stays idempotent.
+        const taskId = taskRef(request, { allowDeleted: true });
         const accepted = await taskApi(() => requireTaskRooms().requestTaskDeletion({
             actor: { kind: 'local_control', surface: 'web' }, taskId,
         }));
@@ -559,7 +592,7 @@ export async function buildWebServer(services, boundary, options = {}) {
         return {
             task_id: taskId, accepted: true, deletion: 'pending',
             ...(outcome.error ? { error: outcome.error } : {}),
-            recovery: `Repeat DELETE /api/v1/tasks/${taskId}?confirm=${taskId}.`,
+            recovery: `Repeat DELETE /api/v1/tasks/${submitted}?confirm=${submitted}.`,
         };
     });
     app.post('/api/v1/tasks', async (request, reply) => {
@@ -588,7 +621,7 @@ export async function buildWebServer(services, boundary, options = {}) {
     });
     app.patch('/api/v1/tasks/:id/list', async (request) => {
         auth.authenticate(request, true);
-        const taskId = request.params.id;
+        const taskId = taskRef(request);
         const list = String(request.body?.list ?? '');
         return { task: wireTask(await taskApi(() => requireTaskRooms().moveTask({ actor: { kind: 'local_control', surface: 'web' }, taskId, list }))) };
     });
@@ -598,17 +631,17 @@ export async function buildWebServer(services, boundary, options = {}) {
         if (typeof body?.brief !== 'string' || typeof body.expectedBrief !== 'string' || body.brief.length > 100_000)
             throw new FleetError('invalid_request', 'brief and expectedBrief must be strings; brief maximum is 100000 characters');
         return { task: wireTask(await taskApi(() => requireTaskRooms().editTaskDescription({
-                actor: { kind: 'local_control', surface: 'web' }, taskId: request.params.id,
+                actor: { kind: 'local_control', surface: 'web' }, taskId: taskRef(request),
                 brief: body.brief, expectedBrief: body.expectedBrief,
             }))) };
     });
     app.get('/api/v1/tasks/:id', async (request) => {
         auth.authenticate(request);
-        return wireTaskResult(await taskApi(() => requireTaskRooms().getTask(request.params.id)));
+        return wireTaskResult(await taskApi(() => requireTaskRooms().getTask(taskRef(request))));
     });
     app.get('/api/v1/tasks/:id/progress', async (request) => {
         auth.authenticate(request);
-        return { progress: await reviewApi(() => taskProgressSnapshot(request.params.id)) };
+        return { progress: await reviewApi(() => taskProgressSnapshot(taskRef(request))) };
     });
     app.post('/api/v1/tasks/:id/progress', async (request, reply) => {
         auth.authenticate(request, true);
@@ -617,7 +650,7 @@ export async function buildWebServer(services, boundary, options = {}) {
         const requestKey = typeof body?.requestKey === 'string' ? body.requestKey : typeof header === 'string' ? header : undefined;
         if (typeof body?.text !== 'string' || (body.requestKey !== undefined && typeof body.requestKey !== 'string'))
             throw new FleetError('invalid_request', 'text must be a string; requestKey, when given, a string');
-        const result = await reviewApi(() => appendTaskProgress(request.params.id, {
+        const result = await reviewApi(() => appendTaskProgress(taskRef(request), {
             text: body.text, requestKey, author: { kind: 'local_control', surface: 'web' },
         }));
         if (!result.replayed)
@@ -630,7 +663,7 @@ export async function buildWebServer(services, boundary, options = {}) {
         const ids = request.body?.ids;
         if (!Array.isArray(ids) || ids.length > 200 || ids.some(id => typeof id !== 'string' || id.length > 64))
             throw new FleetError('invalid_request', 'ids must be at most 200 progress entry IDs');
-        return { unread: await reviewApi(() => acknowledgeTaskProgress(request.params.id, ids)) };
+        return { unread: await reviewApi(() => acknowledgeTaskProgress(taskRef(request), ids)) };
     });
     /** Acknowledge the To review revision the browser fetched and rendered. */
     app.post('/api/v1/tasks/:id/review/read', async (request) => {
@@ -638,11 +671,11 @@ export async function buildWebServer(services, boundary, options = {}) {
         const revision = request.body?.revision;
         if (!Number.isSafeInteger(revision) || revision < 0)
             throw new FleetError('invalid_request', 'revision must be a non-negative integer');
-        return { unread: await reviewApi(() => acknowledgeTaskReview(request.params.id, revision)) };
+        return { unread: await reviewApi(() => acknowledgeTaskReview(taskRef(request), revision)) };
     });
     app.get('/api/v1/tasks/:id/review', async (request) => {
         auth.authenticate(request);
-        const review = await reviewApi(() => getTaskReview(request.params.id));
+        const review = await reviewApi(() => getTaskReview(taskRef(request)));
         return { review: review ? publicReview(review) : null };
     });
     app.put('/api/v1/tasks/:id/review', async (request) => {
@@ -650,7 +683,7 @@ export async function buildWebServer(services, boundary, options = {}) {
         const body = request.body;
         if (typeof body?.markdown !== 'string' || typeof body.expectedMarkdown !== 'string')
             throw new FleetError('invalid_request', 'markdown and expectedMarkdown must be strings');
-        const review = await reviewApi(() => setTaskReviewMarkdown(request.params.id, {
+        const review = await reviewApi(() => setTaskReviewMarkdown(taskRef(request), {
             markdown: body.markdown, expectedMarkdown: body.expectedMarkdown,
             author: { kind: 'local_control', surface: 'web' },
         }));
@@ -658,7 +691,7 @@ export async function buildWebServer(services, boundary, options = {}) {
     });
     app.get('/api/v1/tasks/:id/review/artifacts/:artifactId', async (request, reply) => {
         auth.authenticate(request);
-        const { artifact, bytes } = await reviewApi(() => readTaskReviewArtifact(request.params.id, request.params.artifactId));
+        const { artifact, bytes } = await reviewApi(() => readTaskReviewArtifact(taskRef(request), request.params.artifactId));
         reply.header('Cache-Control', 'private, no-store');
         reply.header('X-Content-Type-Options', 'nosniff');
         reply.header('Content-Security-Policy', "default-src 'none'; sandbox");
@@ -669,7 +702,7 @@ export async function buildWebServer(services, boundary, options = {}) {
         auth.authenticate(request, true);
         const body = request.body;
         try {
-            const result = await taskApi(() => requireTaskRooms().addMember(request.params.id, body));
+            const result = await taskApi(() => requireTaskRooms().addMember(taskRef(request), body));
             reply.code(result.state === 'running' ? 202 : 200);
             return result;
         }
@@ -681,7 +714,8 @@ export async function buildWebServer(services, boundary, options = {}) {
     });
     app.get('/api/v1/tasks/:id/member-additions/:requestId', async (request) => {
         auth.authenticate(request);
-        const { id, requestId } = request.params;
+        const { requestId } = request.params;
+        const id = taskRef(request);
         return taskApi(() => requireTaskRooms().memberAddition(id, requestId));
     });
     app.patch('/api/v1/tasks/:id/layout', async (request) => {
@@ -691,18 +725,19 @@ export async function buildWebServer(services, boundary, options = {}) {
         if (!name(body?.layout) || !(body.expectedLayout === null || name(body.expectedLayout)))
             throw new FleetError('invalid_request', 'layout must be a layout name; expectedLayout a layout name or null');
         const task = await taskApi(() => requireTaskRooms().setTaskLayout({ actor: { kind: 'local_control', surface: 'web' },
-            taskId: request.params.id, layout: body.layout, expectedLayout: body.expectedLayout }));
+            taskId: taskRef(request), layout: body.layout, expectedLayout: body.expectedLayout }));
         await audit.record({ requestId: request.id, browser: session.id, action: 'task.layout.set', result: 'succeeded' });
         return { task: wireTask(requireTaskRooms().withLayoutRooms(task)) };
     });
     app.get('/api/v1/tasks/:id/layout', async (request) => {
         auth.authenticate(request);
-        return { layout: await taskApi(async () => requireTaskRooms().taskLayout(request.params.id)) };
+        return { layout: await taskApi(async () => requireTaskRooms().taskLayout(taskRef(request))) };
     });
     for (const operation of ['open', 'close']) {
         app.post(`/api/v1/tasks/:id/layout/rooms/:room/${operation}`, async (request, reply) => {
             const session = auth.authenticate(request, true);
-            const { id, room } = request.params;
+            const { room } = request.params;
+            const id = taskRef(request);
             const accepted = await taskApi(() => requireTaskRooms().launchTaskLayoutOperation({
                 actor: { kind: 'local_control', surface: 'web' }, taskId: id, room,
                 operation: operation === 'open' ? 'open' : 'close-room',
@@ -715,7 +750,7 @@ export async function buildWebServer(services, boundary, options = {}) {
     app.post('/api/v1/tasks/:id/layout/cleanup', async (request, reply) => {
         auth.authenticate(request, true);
         const accepted = await taskApi(() => requireTaskRooms().retryTaskLayoutCleanup({
-            actor: { kind: 'local_control', surface: 'web' }, taskId: request.params.id,
+            actor: { kind: 'local_control', surface: 'web' }, taskId: taskRef(request),
         }));
         reply.code(202);
         return { operation: accepted };
@@ -761,7 +796,7 @@ export async function buildWebServer(services, boundary, options = {}) {
     for (const action of ['start', 'block', 'unblock', 'review', 'finish', 'cancel']) {
         app.post(`/api/v1/tasks/:id/${action}`, async (request, reply) => {
             auth.authenticate(request, true);
-            const taskId = request.params.id;
+            const taskId = taskRef(request);
             const body = (request.body ?? {});
             const input = { actor: { kind: 'local_control', surface: 'web' }, taskId };
             const api = requireTaskRooms();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "2.2.5",
+  "version": "2.3.0",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, managed native/ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",
@@ -49,9 +49,9 @@
   "dependencies": {
     "@agentclientprotocol/sdk": "^1.3.0",
     "@fastify/websocket": "^11.2.0",
-    "@ours.network/cli": "4.1.0",
-    "@ours.network/mcp": "2.0.2",
-    "@ours.network/sdk": "5.1.0",
+    "@ours.network/cli": "4.2.0",
+    "@ours.network/mcp": "2.0.3",
+    "@ours.network/sdk": "5.2.0",
     "commander": "^12.1.0",
     "fastify": "^5.4.0",
     "qrcode": "1.5.4",
@@ -65,7 +65,7 @@
     "@agentclientprotocol/codex-acp": "1.10.0"
   },
   "devDependencies": {
-    "@ours.network/daemon": "5.1.0",
+    "@ours.network/daemon": "5.2.0",
     "@types/node": "^22.20.4",
     "@types/qrcode": "^1.5.6",
     "@types/ws": "^8.18.1",