@ours.network/fleet 2.2.3 → 2.2.5

package/dist/notifications/task-producer.js

@@ -16,8 +16,7 @@ export class TaskNotificationProducer {
     offset = 0;
     stopped = false;
     shutdown = new AbortController();
-    bootstrapped = false;
-    bootstrapAt = 0;
+    bootstrapAttempted = false;
     constructor(config, warn = () => { }, request = fetch, 
     /** Existing tasks and their layout room CIDs, registered once per start before own-room OFF can be chosen. */
     missions) {
@@ -68,21 +67,14 @@ export class TaskNotificationProducer {
         // Deletion first: a retired task's notifications go before any other delivery work in this pass.
         if (convertRetiredTaskNotifications() || await drainMissionCleanup(this.config, this.warn, this.request))
             this.retry();
-        if (this.missions && !this.bootstrapped && !this.stopped) {
-            // A failed run waits 30s: unavailable inventory or a refused registration needs repair, not a tight loop.
-            const wait = this.bootstrapAt - Date.now();
-            if (wait > 0)
-                this.retry(wait);
-            else {
-                try {
-                    await bootstrapMissionRooms(this.config, this.missions.tasks, this.missions.layoutRooms, this.request);
-                    this.bootstrapped = true;
-                }
-                catch {
-                    this.warn('Mission room registration pending; own-room message preference stays unavailable');
-                    this.bootstrapAt = Date.now() + 30_000;
-                    this.retry(30_000);
-                }
+        if (this.missions && !this.bootstrapAttempted && !this.stopped) {
+            // One startup attempt. Association failure neither blocks task events nor schedules another registration.
+            this.bootstrapAttempted = true;
+            try {
+                await bootstrapMissionRooms(this.config, this.missions.tasks, this.missions.layoutRooms, this.request);
+            }
+            catch {
+                this.warn('Mission room registration failed; own-room message preference may be unavailable');
             }
         }
         const pending = pendingTaskNotifications(this.warn);

package/dist/preset-migration.js

@@ -99,6 +99,16 @@ const REVIEW_PACKAGE_FINGERPRINTS = Object.freeze({
     'roles/Coordinator.yaml': ['1fa72470f37330a96debdfa6a64004280edcf318fafd5f6a5065a06ee7e87acc'],
     'agent_templates/LocalCoordinator.yaml': ['931908da43df7c85dd2b106c99c765a3aeb4a97361fa00ce110e3ac93221ce32'],
 });
+// The packaged revision-12 charters before the 400-character Progress rules, the single Progress
+// writer and the current-request To review lifecycle with clear. Untouched copies adopt the current
+// text; edited ones stay.
+const CURRENT_REQUEST_FINGERPRINTS = Object.freeze({
+    'roles/Developer.yaml': ['684b4cb278b92746ba3abe29523adb9ab585e0831f8519b17bc17f41a3e992a4'],
+    'roles/Critic.yaml': ['b5b1d00074e6540160b14da256609b42600fa7d94ba776f8d5e7b42771669c41'],
+    'roles/Engineer.yaml': ['79991291c354229a71cdbd7191ad132ea91499b5326b1386c7abe8ce1444f714'],
+    'roles/LocalCoordinator.yaml': ['0fdbb9b56fedcf1897ad8044d6d88eaefcd5ccc48176860da3f7a1efe22da51d'],
+    'roles/Coordinator.yaml': ['c9038f3e33068058884e2ae52f6d569c22c4d56fcdb345e9381866c6de38d9a9'],
+});
 const CURRENT_ROLE_DEFAULTS = new Set([
     'roles/Coordinator.yaml', 'roles/LocalCoordinator.yaml', 'roles/Developer.yaml', 'roles/Critic.yaml',
     'roles/Engineer.yaml',
@@ -232,6 +242,7 @@ export function migratePackagedRoleDefaults(configuration, options = {}, hooks =
             ...Object.keys(REREADING_CONTINUITY_LOOP_FINGERPRINTS),
             ...Object.keys(PEER_WAIT_REMINDER_FINGERPRINTS),
             ...Object.keys(REVIEW_PACKAGE_FINGERPRINTS),
+            ...Object.keys(CURRENT_REQUEST_FINGERPRINTS),
         ]);
         for (const relative of known) {
             const path = join(root, relative);
@@ -249,6 +260,7 @@ export function migratePackagedRoleDefaults(configuration, options = {}, hooks =
                 ...(REREADING_CONTINUITY_LOOP_FINGERPRINTS[relative] ?? []),
                 ...(PEER_WAIT_REMINDER_FINGERPRINTS[relative] ?? []),
                 ...(REVIEW_PACKAGE_FINGERPRINTS[relative] ?? []),
+                ...(CURRENT_REQUEST_FINGERPRINTS[relative] ?? []),
             ].some(expected => expected !== undefined && actual === expected);
             if (recognized)
                 (CURRENT_ROLE_DEFAULTS.has(relative) ? replacements : removals).push(path);

package/dist/rooms-tasks/cli.js

@@ -39,13 +39,13 @@ function cliAnonymousOverride(argv) {
         throw new Error('--anonymous and --no-anonymous are mutually exclusive');
     return enabled ? true : disabled ? false : undefined;
 }
-import { getTask, getDeletingTask, TaskStateError, } from './task-state.js';
+import { getTask, getDeletingTask, TaskStateError, reviewRevision, } from './task-state.js';
 import { getRoomRecord, RoomStateError, } from './room-state.js';
 import { createCoworkAdapter } from './cowork-adapter.js';
 import { markdownCode, markdownProse, renderMarkdownFailure, renderMarkdownList, renderMarkdownResult, roomStatus, taskStatus, } from './markdown.js';
 import { recordTaskProvisioningOutcome, TaskRoomApplicationError, TaskRoomApplicationService, } from '../application/task-room-service.js';
 import { TaskListError } from './task-lists.js';
-import { appendTaskProgress, attachTaskReviewArtifact, detachTaskReviewArtifact, getTaskReview, listTaskProgress, openTaskWorkspaceFile, publicProgressEntry, publicReview, setTaskReviewMarkdown, TaskReviewError, } from './task-review.js';
+import { appendTaskProgress, attachTaskReviewArtifact, clearTaskReview, detachTaskReviewArtifact, getTaskReview, listTaskProgress, openTaskWorkspaceFile, publicProgressEntry, publicReview, setTaskReviewMarkdown, TaskReviewError, } from './task-review.js';
 import { verifiedFleetCaller } from '../fleet-command-audit.js';
 import { beginFleetAuditCollection, consumeFleetAuditCollection, recordFleetAuditFailure, recordFleetAuditPresentation, recordFleetAuditResource, } from '../fleet-command-audit.js';
 import { renderAgentConfiguration } from '../lifecycle-summary.js';
@@ -1108,6 +1108,8 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--attach <path>', 'retain a file from the task workspace in the package (repeatable)', (value, all) => [...all, value], [])
         .option('--detach <artifact-id>', 'remove a file from the package (repeatable)', (value, all) => [...all, value], [])
         .option('--request-key <key>', 'retry key for a single --attach: repeating it with the same file returns the original artifact')
+        .option('--clear', 'remove the resolved request: all Markdown and files, replaced by --markdown[-file] if given (needs --expected-revision)')
+        .option('--expected-revision <n>', 'package revision you last read; --clear is refused if it changed since')
         .option('--json', 'JSON output')
         .action(async (id, opts) => {
         try {
@@ -1115,10 +1117,22 @@ export function registerTaskCommands(parent, cOpt) {
                 throw new Error('use --markdown or --markdown-file, not both');
             if (opts.requestKey !== undefined && opts.attach.length !== 1)
                 throw new Error('--request-key needs exactly one --attach');
+            if (!!opts.clear !== (opts.expectedRevision !== undefined))
+                throw new TaskReviewError('invalid_request', '--clear and --expected-revision go together');
+            if (opts.clear && opts.detach.length)
+                throw new TaskReviewError('invalid_request', '--clear already removes every file; drop --detach');
+            if (opts.clear && opts.attach.length)
+                throw new TaskReviewError('invalid_request', '--clear cannot attach in the same call; attach the next request\'s files after reading the package again');
+            const expectedRevision = opts.expectedRevision !== undefined ? Number(opts.expectedRevision) : undefined;
+            if (expectedRevision !== undefined && (!/^\d+$/.test(opts.expectedRevision) || !Number.isSafeInteger(expectedRevision)))
+                throw new TaskReviewError('invalid_request', '--expected-revision must be a non-negative integer');
             const markdown = opts.markdownFile !== undefined ? readFileSync(opts.markdownFile, 'utf8') : opts.markdown;
-            const author = markdown !== undefined || opts.attach.length || opts.detach.length ? cliContributionAuthor(id) : undefined;
+            const author = markdown !== undefined || opts.attach.length || opts.detach.length || opts.clear ? cliContributionAuthor(id) : undefined;
             const attached = [];
-            if (markdown !== undefined)
+            // A clear with Markdown replaces the request in one fenced change; nothing can land in between.
+            if (opts.clear)
+                clearTaskReview(id, { expectedRevision: expectedRevision, author: author, markdown });
+            else if (markdown !== undefined)
                 setTaskReviewMarkdown(id, { markdown, expectedMarkdown: getTaskReview(id)?.markdown ?? '', author: author });
             for (const artifactId of opts.detach)
                 detachTaskReviewArtifact(id, artifactId, { author: author });
@@ -1136,7 +1150,7 @@ export function registerTaskCommands(parent, cOpt) {
                 return;
             }
             const files = review.artifacts.map(artifact => `- \`${artifact.id}\` ${artifact.name} (${artifact.mime}, ${artifact.size} bytes)`).join('\n');
-            console.log(`## To review — task ${id}\n\n${review.markdown || '_No review Markdown yet._'}\n\n### Files\n\n${files || '_No files._'}`
+            console.log(`## To review — task ${id} (revision ${reviewRevision(review)})\n\n${review.markdown || '_No review Markdown yet._'}\n\n### Files\n\n${files || '_No files._'}`
                 + (attached.some(item => item.replayed) ? '\n\n(The attached file was already recorded.)' : ''));
         }
         catch (e) {

package/dist/rooms-tasks/layout-service.d.ts

@@ -30,7 +30,7 @@ export declare class RoomLayoutService {
     supervisor(id?: string, templates?: Record<string, AgentTemplateDefinition>): NativeLayoutSupervisor;
     private owner;
     private engine;
-    /** A task's layout rooms are registered with the notification service before the Owner can join them. */
+    /** A task's layout rooms attempt notification registration before Owner admission. */
     private beforeOwner;
     open(id: string, cleanup?: boolean): RoomLayout;
     /** `scope` lets an owner (e.g. a Task) snapshot an adjusted definition and pin agent working directories. */

package/dist/rooms-tasks/layout-service.js

@@ -180,7 +180,7 @@ export class RoomLayoutService {
             assertLayoutFile(path);
         return new RoomLayout(path, () => createCoworkAdapter(), this.supervisor(id), cleanup ? undefined : this.owner(), this.beforeOwner(id));
     }
-    /** A task's layout rooms are registered with the notification service before the Owner can join them. */
+    /** A task's layout rooms attempt notification registration before Owner admission. */
     beforeOwner(id) {
         const taskId = /^task-([0-9a-z]{9}[0-9a-f]{8})$/.exec(id)?.[1];
         return taskId ? async (roomCid) => (await import('../notifications/mission-ownership.js')).associateRoomNotifications(taskId, roomCid) : undefined;

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

@@ -104,12 +104,12 @@ export declare class RoomLayout {
     private file;
     private supervisor;
     private owner?;
-    /** Runs before the Owner may join each room; a failure stops here and the next pass retries it. */
+    /** Best-effort notification registration before the Owner joins each room. */
     private beforeOwner?;
     private coworkAdapter?;
     private readonly coworkFactory;
     constructor(file: string, cowork: CoworkAdapter | (() => CoworkAdapter), supervisor: LayoutSupervisor, owner?: LayoutOwner | undefined, 
-    /** Runs before the Owner may join each room; a failure stops here and the next pass retries it. */
+    /** Best-effort notification registration before the Owner joins each room. */
     beforeOwner?: ((roomCid: string) => Promise<void>) | undefined);
     private get cowork();
     snapshot(): RoomLayoutState;

package/dist/rooms-tasks/layout.js

@@ -43,7 +43,7 @@ export class RoomLayout {
     coworkAdapter;
     coworkFactory;
     constructor(file, cowork, supervisor, owner, 
-    /** Runs before the Owner may join each room; a failure stops here and the next pass retries it. */
+    /** Best-effort notification registration before the Owner joins each room. */
     beforeOwner) {
         this.file = file;
         this.supervisor = supervisor;
@@ -165,8 +165,14 @@ export class RoomLayout {
                 activation_requirements: !spec.members.length && s.owner ? [{ role: s.owner.role, count: 1 }]
                     : [...new Set(spec.members.map(roleFor))].map(role => ({ role, count: spec.members.filter(m => roleFor(m) === role).length })),
             }), native => { room.native = native; s.order.push(key); });
-        if (s.owner && !room.owner_ready && this.beforeOwner)
-            await this.beforeOwner(room.native.identity_cid);
+        if (s.owner && !room.owner_ready && this.beforeOwner) {
+            try {
+                await this.beforeOwner(room.native.identity_cid);
+            }
+            catch {
+                console.warn('Mission room notification registration failed; continuing room admission with ordinary notifications');
+            }
+        }
         if (s.owner && !room.owner_ready)
             await this.mutation(s, `owner:${key}`, async () => {
                 await this.cowork.acceptInvite(room.native.room_id, this.owner.invite, { role: s.owner.role, expected_cid: s.owner.cid });

package/dist/rooms-tasks/task-review.d.ts

@@ -1,5 +1,11 @@
 import type { TaskContributionAuthor, TaskProgressEntry, TaskRecord, TaskReview, TaskReviewArtifact } from './types.js';
-export declare const PROGRESS_TEXT_MAX = 4000;
+/**
+ * Maximum length of a new Progress entry, in Unicode code points of the exact
+ * submitted text (no normalization or trimming). A combining sequence or a
+ * joined emoji counts as each of its code points. Stored entries are not
+ * re-checked, so older, longer entries still read and display.
+ */
+export declare const PROGRESS_TEXT_MAX = 400;
 export declare const PROGRESS_MAX_ENTRIES = 200;
 export declare const REVIEW_MARKDOWN_MAX = 50000;
 export declare const REVIEW_MAX_ARTIFACTS = 20;
@@ -15,6 +21,8 @@ export declare function listTaskProgress(taskId: string): TaskProgressEntry[];
 export declare function taskProgressSnapshot(taskId: string): Array<Omit<TaskProgressEntry, 'request_key'> & {
     unread: boolean;
 }>;
+/** Progress length in Unicode code points: a character outside the BMP counts once, not as two UTF-16 units. */
+export declare function progressTextLength(text: string): number;
 /**
  * Append one milestone. Text is kept exactly as written; whitespace-only text is
  * rejected. A retry with the same author-scoped request_key returns the original
@@ -39,6 +47,25 @@ export declare function setTaskReviewMarkdown(taskId: string, input: {
     expectedMarkdown: string;
     author: TaskContributionAuthor;
 }): TaskReview;
+/**
+ * Clear the resolved To review request: Markdown and every attached file, in
+ * one change fenced by the whole package revision the writer last read. Any
+ * Markdown edit, attach or detach since then is a conflict and nothing is
+ * removed. Clearing an already empty package at the expected revision succeeds
+ * unchanged; after a successful clear, read the package again before retrying.
+ * Like any change, a clear gets the next revision, so read markers, unread and
+ * push behave as for any update. Only the files this change removed are
+ * deleted; a file attached after it stays. With `markdown`, the same change
+ * writes the next request, so no other writer can slip in between.
+ */
+export declare function clearTaskReview(taskId: string, input: {
+    expectedRevision: number;
+    author: TaskContributionAuthor;
+    markdown?: string;
+}): {
+    review: TaskReview | undefined;
+    removed: TaskReviewArtifact[];
+};
 export declare const reviewStoreRoot: () => string;
 export declare function reviewStoreDirectory(taskId: string): string;
 /** A file being read; `verify` fails when it changed since it was opened. */

package/dist/rooms-tasks/task-review.js

@@ -14,7 +14,13 @@ import { stateRoot } from '../paths.js';
 import { MAX_FILE_BYTES, openDirectory } from '../file-delivery/reader.js';
 import { contributionUnread, getTask, reviewRevision, TaskStateError, updateTaskContribution } from './task-state.js';
 import { assertWorkspacePresent } from './workspace.js';
-export const PROGRESS_TEXT_MAX = 4_000;
+/**
+ * Maximum length of a new Progress entry, in Unicode code points of the exact
+ * submitted text (no normalization or trimming). A combining sequence or a
+ * joined emoji counts as each of its code points. Stored entries are not
+ * re-checked, so older, longer entries still read and display.
+ */
+export const PROGRESS_TEXT_MAX = 400;
 export const PROGRESS_MAX_ENTRIES = 200;
 export const REVIEW_MARKDOWN_MAX = 50_000;
 export const REVIEW_MAX_ARTIFACTS = 20;
@@ -83,6 +89,13 @@ export function taskProgressSnapshot(taskId) {
         ...publicProgressEntry(entry), unread: !!reads && !seen.has(entry.id),
     }));
 }
+/** Progress length in Unicode code points: a character outside the BMP counts once, not as two UTF-16 units. */
+export function progressTextLength(text) {
+    let length = 0;
+    for (const _ of text)
+        length++;
+    return length;
+}
 /**
  * Append one milestone. Text is kept exactly as written; whitespace-only text is
  * rejected. A retry with the same author-scoped request_key returns the original
@@ -92,8 +105,10 @@ export function appendTaskProgress(taskId, input) {
     assertTaskId(taskId);
     if (typeof input.text !== 'string' || !input.text.trim())
         throw new TaskReviewError('invalid_request', 'progress text is required');
-    if (input.text.length > PROGRESS_TEXT_MAX)
-        throw new TaskReviewError('invalid_request', `progress text maximum is ${PROGRESS_TEXT_MAX} characters`);
+    const length = progressTextLength(input.text);
+    if (length > PROGRESS_TEXT_MAX)
+        throw new TaskReviewError('invalid_request', `progress text is ${length} Unicode characters (code points); the maximum is ${PROGRESS_TEXT_MAX}. `
+            + 'Nothing was saved. Keep one fact per entry and shorten it, or record distinct facts as separate entries.');
     checkRequestKey(input.requestKey);
     return updateTaskContribution(taskId, task => {
         const progress = task.progress ?? [];
@@ -149,6 +164,44 @@ export function setTaskReviewMarkdown(taskId, input) {
         return { value: task.review, changed: true };
     });
 }
+/**
+ * Clear the resolved To review request: Markdown and every attached file, in
+ * one change fenced by the whole package revision the writer last read. Any
+ * Markdown edit, attach or detach since then is a conflict and nothing is
+ * removed. Clearing an already empty package at the expected revision succeeds
+ * unchanged; after a successful clear, read the package again before retrying.
+ * Like any change, a clear gets the next revision, so read markers, unread and
+ * push behave as for any update. Only the files this change removed are
+ * deleted; a file attached after it stays. With `markdown`, the same change
+ * writes the next request, so no other writer can slip in between.
+ */
+export function clearTaskReview(taskId, input) {
+    const dir = reviewStoreDirectory(taskId);
+    if (!Number.isSafeInteger(input.expectedRevision) || input.expectedRevision < 0)
+        throw new TaskReviewError('invalid_request', 'expected revision must be a non-negative integer');
+    const markdown = input.markdown ?? '';
+    if (typeof markdown !== 'string')
+        throw new TaskReviewError('invalid_request', 'markdown must be a string');
+    if (markdown.length > REVIEW_MARKDOWN_MAX)
+        throw new TaskReviewError('invalid_request', `review markdown maximum is ${REVIEW_MARKDOWN_MAX} characters`);
+    const result = updateTaskContribution(taskId, task => {
+        if (reviewRevision(task.review) !== input.expectedRevision)
+            throw new TaskReviewError('conflict', 'The review package changed elsewhere. Read it again before clearing it.');
+        const empty = !task.review || (!task.review.markdown && !task.review.artifacts.length);
+        if (empty && !markdown)
+            return { value: { review: task.review, removed: [] }, changed: false };
+        const removed = task.review?.artifacts ?? [];
+        task.review = { revision: nextRevision(task.review), markdown, updated_at: new Date().toISOString(),
+            updated_by: input.author, artifacts: [] };
+        return { value: { review: task.review, removed }, changed: true };
+    });
+    for (const artifact of result.removed)
+        try {
+            removeStoredFile(dir, artifact.id);
+        }
+        catch { /* an unreferenced copy is swept later */ }
+    return result;
+}
 // ── Review artifact store ──────────────────────────────────────────────
 export const reviewStoreRoot = () => join(stateRoot(), 'task-review-artifacts');
 export function reviewStoreDirectory(taskId) {

package/dist/rooms-tasks/task-tools.d.ts

@@ -9,7 +9,7 @@ export interface TaskToolBinding {
     /** Launched as a task-owned temporary member (layout participant). */
     taskOwned: boolean;
 }
-export declare const TASK_TOOL_NAMES: readonly ["fleet_task_progress_list", "fleet_task_progress_append", "fleet_task_review_show", "fleet_task_review_set", "fleet_task_review_detach"];
+export declare const TASK_TOOL_NAMES: readonly ["fleet_task_progress_list", "fleet_task_progress_append", "fleet_task_review_show", "fleet_task_review_set", "fleet_task_review_clear", "fleet_task_review_detach"];
 export declare const PROGRESS_PAGE_MAX = 50;
 /** One chronological page of the log; `next_after` continues after the last returned entry. */
 export declare function progressPage(entries: TaskProgressEntry[], input: {

package/dist/rooms-tasks/task-tools.js

@@ -1,9 +1,9 @@
 import { z } from 'zod';
-import { appendTaskProgress, detachTaskReviewArtifact, getTaskReview, listTaskProgress, publicProgressEntry, publicReview, setTaskReviewMarkdown, TaskReviewError, PROGRESS_TEXT_MAX, REVIEW_MARKDOWN_MAX, } from './task-review.js';
+import { appendTaskProgress, detachTaskReviewArtifact, getTaskReview, listTaskProgress, publicProgressEntry, publicReview, setTaskReviewMarkdown, clearTaskReview, TaskReviewError, PROGRESS_TEXT_MAX, REVIEW_MARKDOWN_MAX, } from './task-review.js';
 import { getTask, TaskStateError } from './task-state.js';
 export const TASK_TOOL_NAMES = Object.freeze([
     'fleet_task_progress_list', 'fleet_task_progress_append',
-    'fleet_task_review_show', 'fleet_task_review_set', 'fleet_task_review_detach',
+    'fleet_task_review_show', 'fleet_task_review_set', 'fleet_task_review_clear', 'fleet_task_review_detach',
 ]);
 /** Compact JSON: a result is carried twice (text and structured) inside one bounded bridge frame. */
 function result(value) {
@@ -97,11 +97,13 @@ export function registerTaskTools(server, binding, admit) {
         },
     }, async (args) => run(bound => ({ task_id: bound.taskId, ...progressPage(listTaskProgress(bound.taskId), args) })));
     server.registerTool('fleet_task_progress_append', {
-        description: 'Append ONE significant, verified milestone to your task\'s Progress log (e.g. root cause found, PR opened with link, '
-            + 'measured result with its scope, final deliverable ready). Not for routine status, handoffs or review chatter. '
+        description: 'Append ONE significant, verified fact the Owner should know to your task\'s Progress log: delivered behavior, root cause, '
+            + 'measured result with a valid comparison, PR or publication, important blocker, changed scope, or a required Owner decision '
+            + '(e.g. "Owner review required: choose the deployment option in To review."). Lead with the result and name the actor; '
+            + 'one fact per entry, in the task\'s language. Not for routine status, handoffs or review chatter. '
             + 'Entries are permanent and shown to the Owner as written. Repeating a call with the same request_key and text returns the original entry.',
         inputSchema: {
-            text: z.string().describe(`Free-form milestone text, kept exactly as written (max ${PROGRESS_TEXT_MAX} characters).`),
+            text: z.string().describe(`Entry text, kept exactly as written: at most ${PROGRESS_TEXT_MAX} Unicode characters (code points); longer text is refused, not cut.`),
             request_key: z.string().optional().describe('Stable key for this milestone so a retried call cannot add it twice (e.g. "pr-opened-123").'),
         },
     }, async (args) => run((bound, author) => {
@@ -116,8 +118,9 @@ export function registerTaskTools(server, binding, admit) {
         return { task_id: bound.taskId, review: review ? publicReview(review) : null };
     }));
     server.registerTool('fleet_task_review_set', {
-        description: 'Replace the Markdown of your task\'s To review package: the self-contained material the Owner reviews without reading the room or task description '
-            + '(outcome, clickable PR/spec links, validation and CI, independent verdict, limits, decisions needed). '
+        description: 'Replace the Markdown of your task\'s To review package: the one current request the Owner reviews without reading the room or task description '
+            + '(final acceptance: outcome, clickable PR/spec links, validation and CI, independent verdict, limits; or one Owner decision with its options). '
+            + 'Not an archive: clear a resolved request with fleet_task_review_clear. Attached files are kept. '
             + 'Pass the Markdown you last read as expected_markdown ("" when empty); a concurrent change is refused instead of overwritten.',
         inputSchema: {
             markdown: z.string().describe(`Review Markdown (max ${REVIEW_MARKDOWN_MAX} characters). Links use the same safe rules as task descriptions.`),
@@ -127,6 +130,19 @@ export function registerTaskTools(server, binding, admit) {
         task_id: bound.taskId,
         review: publicReview(setTaskReviewMarkdown(bound.taskId, { markdown: args.markdown, expectedMarkdown: args.expected_markdown, author })),
     })));
+    server.registerTool('fleet_task_review_clear', {
+        description: 'Clear your task\'s resolved To review request after the Owner answered it in the room: removes the Markdown and every attached file in one change. '
+            + 'Pass the revision from your last fleet_task_review_show; if the package changed since, nothing is removed and you get a conflict. '
+            + 'Record the Owner\'s decision in Progress or the room first. Pass markdown to write the next request in the same fenced change.',
+        inputSchema: {
+            expected_revision: z.number().int().describe('review.revision as you last read it with fleet_task_review_show.'),
+            markdown: z.string().optional().describe(`Optional Markdown of the next request (max ${REVIEW_MARKDOWN_MAX} characters), written in the same change.`),
+        },
+    }, async (args) => run((bound, author) => {
+        const cleared = clearTaskReview(bound.taskId, { expectedRevision: args.expected_revision, author, markdown: args.markdown });
+        return { task_id: bound.taskId, review: cleared.review ? publicReview(cleared.review) : null,
+            removed: cleared.removed.map(({ request_key: _key, ...artifact }) => artifact) };
+    }));
     server.registerTool('fleet_task_review_detach', {
         description: 'Remove one file from your task\'s To review package by artifact_id (from fleet_task_review_show).',
         inputSchema: { artifact_id: z.string() },

package/dist/web/resource-views.js

@@ -417,6 +417,14 @@ export class FleetResourceViews {
             // None changes role membership/configuration. Keep these as full wakes.
             if (structural && parts.length === 2 && ['.session-events.jsonl', '.session-events.jsonl.1', '.subscription-usage.json', '.notify-cursor', '.monitor-state.json', '.monitor-status'].includes(parts[1]))
                 return false;
+            // A starting or running member also commits its supervisor/session status
+            // (restart ledger, exit, daemon recovery, control endpoint, monitor owner) and
+            // runner bookkeeping no projection reads. Neither changes membership; while
+            // members start, fencing on them left no stable directory capture.
+            if (structural && parts.length === 2 && ['.restart-ledger.json', '.exit-status', '.daemon-recovery.json', '.control-token', '.control.sock', '.monitor-owner', '.booted', '.supervisor-run.json', '.subscription-pin.json', '.session-ownership.json', '.managed-recovery.json', '.acp-session-id', '.self-reminders.json', 'supervisor.log', 'WORKLOG.md'].includes(parts[1]))
+                return false;
+            if (structural && parts.length >= 2 && ['.ours-bridge', '.task-supervisor'].includes(parts[1]))
+                return false;
             if (parts.length < 3 || parts[1] !== '.conversation')
                 continue;
             if (structural && (descriptor.resource === 'directory' || descriptor.resource === 'roles'))

package/docs/task-progress-review.md

@@ -8,18 +8,59 @@ before this feature, or that never use it, have neither and behave as before.
   browser response also includes `unread` per entry from the same task snapshot,
   based on persisted entry-ID acknowledgments. Legacy records without read state
   report all existing entries as read; retry keys remain private. It is
-  for significant verified milestones (root cause found, PR opened with its link,
-  a measured result with its honest scope, final deliverable ready), not for room
-  chat, routine status, handoffs or ordinary review rounds. Entries cannot be
-  edited or removed.
-- **To review** is the self-contained package the Owner reviews before deciding
-  on the task: Markdown plus retained files. It should let the Owner review
-  without reading the room or the task description: concise outcome, clickable PR
-  and specification links, attached documents, validation and required-CI results
+  for significant verified facts the Owner should know: delivered behavior, a
+  concrete root cause, a measured improvement with a valid comparison, a PR or
+  publication milestone, an important blocker, a changed scope or a required
+  Owner decision. It is not for room chat, routine status, handoffs or internal
+  review rounds. Each entry holds one fact in at most 400 characters (see
+  [Limits](#limits-retries-and-concurrency)), leads with the result or the
+  required action, names the actor and uses the task's language. Entries cannot
+  be edited or removed.
+- **To review** holds one *current* request for human review or decision: the
+  final acceptance package, or one specific Owner decision that blocks or steers
+  the work. It is not ongoing agent review, an evidence archive or a growing list
+  of materials. Markdown plus retained files gather everything needed for that
+  decision in one place. The final package lets the Owner review without reading
+  the room or the task description: concise outcome, clickable PR and
+  specification links, attached documents, validation and required-CI results
   for the exact heads, the independent verdict where one applies, material limits
   and any Owner decision. Research and document tasks attach their documents and
   need no PR.
 
+### Progress examples
+
+| Instead of | Write |
+| --- | --- |
+| "Started looking into the flaky test, will report back." | Nothing: routine status. |
+| "After a lot of investigation we think the cache might be the cause." | "Developer found the root cause: the cache key omits the workspace ID." |
+| "Critic reviewed PR #42 and asked for two changes, then approved." | "Critic approved PR #42 after the review rounds." (only the outcome) |
+| A 900-character summary of three results | Three entries, one result each. |
+| — | "Owner review required: choose the deployment option in To review." |
+
+### To review lifecycle
+
+1. **Request.** The responsible agent writes the request into To review
+   (`fleet_task_review_set`, attachments with the CLI) and appends a Progress
+   entry that sends the Owner there, for example "Owner review required: choose
+   the deployment option in To review." Final acceptance also uses the Review
+   lifecycle; an interim decision never marks unfinished work done.
+2. **Answer.** Opening To review marks it read but does not resolve it. The
+   Owner's answer in the room does.
+3. **Clear.** The agent that owns the request records the decision in Progress or
+   the room, reads the package `revision` with `fleet_task_review_show`, and
+   calls `fleet_task_review_clear` with that `expected_revision` (CLI:
+   `ours-fleet task review-package TASK --clear --expected-revision N`). The next
+   request replaces the cleared one, in the same change when `markdown` (CLI:
+   `--markdown-file`) is given; requests do not accumulate.
+
+A clear removes the Markdown and every attached file in one change and only when
+the package revision is still the one the writer read. Any Markdown edit, attach
+or detach since then, including an edit back to the same Markdown, makes it a
+conflict and nothing is removed. A file attached after the clear committed is
+kept. Clearing an empty package at its current revision changes nothing. Like
+every package change, a clear gets the next revision: readers see an updated
+package until they view it, and read markers stay valid.
+
 The web App shows both as compact **Progress** and **To review** buttons with
 counts on the task screen, each opening its own view. Review links use the same
 safe Markdown and link rules as the task description.
@@ -30,10 +71,10 @@ The packaged default roles divide the work so milestones are not duplicated:
 
 | Role | Progress | To review |
 | --- | --- | --- |
-| LocalCoordinator | Default writer: appends significant verified milestones during room turns it already takes. Its 15-minute continuity pass never writes Progress. | Makes sure members prepare the package before a Review handoff; hands it to the Fleet Coordinator. |
-| Developer, Engineer | Not by default. | Prepare and keep the package current before reporting completion or asking for Review. |
-| Critic | Not by default. | Check that the package matches what was verified; withhold sign-off while it is missing, stale or misleading. |
-| Coordinator (Fleet Coordinator) | Not by default. | Before `task review`, check that the package exists and attaches the original description; if not, ask the room to complete it instead of writing it. Then replace the description with only the PR links (or deliverable links when there are no PRs). Finish only when the Owner accepts or asks. |
+| LocalCoordinator | The only writer when present: extracts Owner-relevant facts from room discussion during turns it already takes. Its 15-minute continuity pass never writes Progress. | Makes sure members prepare the package before a Review handoff; hands it to the Fleet Coordinator. Directs the Owner to an interim decision request and clears it after the answer. |
+| Developer, Engineer | Writer only in a room without a LocalCoordinator; otherwise posts such facts in the room. | Prepare and keep the package current before reporting completion or asking for Review; clear a request they wrote once the Owner answered. |
+| Critic | Never; posts findings in the room. | Check that the package matches what was verified; withhold sign-off while it is missing, stale or misleading. Review rounds stay in the room. |
+| Coordinator (Fleet Coordinator) | Not by default. | Before `task review`, check that the package is one current acceptance request and attaches the original description; if not, ask the room to complete it instead of writing it. Then replace the description with only the PR links (or deliverable links when there are no PRs). Finish only when the Owner accepts or asks. |
 
 This is default instruction policy, not an access rule: any agent bound to the
 task, and the local operator, can use the surfaces below. Preparing a package
@@ -49,12 +90,13 @@ to review, including the original task description as an attached file. Package
 authors save and attach that file before the handoff, the Critic checks it, and
 the Coordinator replaces the description only once the package has it.
 
-Fresh installations get these instructions with preset revision 12. An existing
+Fresh installations get these instructions with preset revision 13. An existing
 configuration keeps its installed copies until you run
 `ours-fleet migrate-role-defaults -c FILE` (a zero-write plan) and then with
-`--write`: untouched revision-11 copies of the Developer, Critic, Engineer,
-LocalCoordinator and Coordinator roles and the LocalCoordinator Agent Template
-adopt the new text, and edited copies are preserved byte-for-byte. Running
+`--write`: untouched revision-11 and revision-12 copies of the Developer, Critic,
+Engineer, LocalCoordinator and Coordinator roles, and the revision-11
+LocalCoordinator Agent Template, adopt the new text, and edited copies are
+preserved byte-for-byte. Running
 agents keep the instructions they started with until they are restarted.
 
 ## Agent tools
@@ -69,7 +111,8 @@ agent that is a listed task member must match that member's identity CID.
 | `fleet_task_progress_list` | Read the log oldest first, in pages; pass `after` = the previous page's `next_after`. |
 | `fleet_task_progress_append` | Append one entry (`text`, optional `request_key`). |
 | `fleet_task_review_show` | Read the package Markdown and file list. |
-| `fleet_task_review_set` | Replace the Markdown; pass the Markdown you last read as `expected_markdown` (`""` when empty). |
+| `fleet_task_review_set` | Replace the Markdown; pass the Markdown you last read as `expected_markdown` (`""` when empty). Attached files are kept. |
+| `fleet_task_review_clear` | Clear the resolved request: Markdown and every file, only if `expected_revision` is still current. Optional `markdown` writes the next request in the same change. Returns the package and the removed files. |
 | `fleet_task_review_detach` | Remove one file by `artifact_id`. |
 
 Files are attached with the CLI below. It runs in the agent's own process, so the
@@ -85,6 +128,7 @@ ours-fleet task review-package TASK [--json]
 ours-fleet task review-package TASK --markdown-file review.md
 ours-fleet task review-package TASK --attach docs/spec.md [--request-key KEY]
 ours-fleet task review-package TASK --detach ARTIFACT_ID
+ours-fleet task review-package TASK --clear --expected-revision N [--markdown-file next.md]
 ```
 
 Run inside a managed agent, the supervisor-verified caller is recorded as the
@@ -92,7 +136,11 @@ author (with its identity CID); otherwise the author is the local operator.
 `--text`, `--text-file`, `--markdown`, `--markdown-file` and `--attach` values are
 redacted from the supervisor's command ledger. `--markdown-file` replaces the
 Markdown current at the time of the call; use `fleet_task_review_set` when a
-concurrent change must be refused.
+concurrent change must be refused. The text output shows the package revision.
+`--clear` is fenced by `--expected-revision`; with `--markdown` or
+`--markdown-file` the same locked change writes the next request, so no other
+writer can land in between. `--clear` cannot be combined with `--attach`: attach
+the next request's files afterwards.
 
 ## HTTP API
 
@@ -104,7 +152,7 @@ workspace-device bearer. `GET /api/v1/meta` reports API minor version 1.
 | `GET /tasks`, `GET /tasks/:id` and other task payloads | `progress_count` and `review: {has_markdown, artifact_count, revision, updated_at?}`; `revision` grows with every package change (0 without a package). Bodies are not inlined. |
 | `GET /tasks/:id/progress` | `{progress: [{id, at, author, text, unread}]}`, oldest first. |
 | `POST /tasks/:id/progress` | `{text, requestKey?}` (or an `Idempotency-Key` header): 201 new, 200 replay, 409 conflicting replay. |
-| `GET /tasks/:id/review` | `{review: {markdown, updated_at, updated_by, artifacts: [{id, name, mime, size, sha256, added_at, added_by}]}}` or `{review: null}`. |
+| `GET /tasks/:id/review` | `{review: {revision, markdown, updated_at, updated_by, artifacts: [{id, name, mime, size, sha256, added_at, added_by}]}}` or `{review: null}`. |
 | `PUT /tasks/:id/review` | `{markdown, expectedMarkdown}`; 409 when the Markdown changed meanwhile. |
 | `GET /tasks/:id/review/artifacts/:artifactId` | The retained bytes as `application/octet-stream` attachment with `Content-Security-Policy: default-src 'none'; sandbox`, `nosniff` and `no-store`. Another task's artifact ID is 404. |
 
@@ -112,8 +160,14 @@ The HTTP API has no upload route: the browser never submits a file path.
 
 ## Limits, retries and concurrency
 
-- Progress text: 1-4000 characters, kept exactly as written; whitespace-only text
-  is rejected. At most 200 entries per task.
+- Progress text: 1-400 characters, kept exactly as written; whitespace-only text
+  is rejected. Characters are Unicode code points of the exact submitted text,
+  without normalization or trimming: `😀` counts as 1 (although it is two UTF-16
+  units), while `é` written as `e` plus a combining accent counts as 2, and a
+  joined emoji such as `👩‍💻` counts as 3. Longer text is refused with
+  `invalid_request` on every surface (HTTP 400): nothing is saved, cut or split.
+  Entries written before this limit keep their text and still display. At most
+  200 entries per task.
 - Review Markdown: up to 50,000 characters. At most 20 files of 20 MiB each per
   task, and 200 MiB stored per task including unreferenced copies.
 - Every change is a read-modify-write under the task's cross-process lock, so

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "2.2.3",
+  "version": "2.2.5",
   "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",

package/presets/fleet/roles/Coordinator.yaml

@@ -54,8 +54,9 @@ persona: |
   `ours-fleet task start <task-id>` after addressing the reported blocker.
 
   When executors report completion, check that the task's To review package exists and is not empty
-  with `ours-fleet task review-package <task-id>`: it must let the Owner review without the room or
-  task description, and that it attaches the original task description. If either is missing, ask the
+  with `ours-fleet task review-package <task-id>`: it must be one current acceptance request, not an
+  archive of earlier requests, let the Owner review without the room or task description, and
+  attach the original task description. If either is missing, ask the
   room to complete it; do not write or judge it yourself. Then replace the task description with only
   the clickable Markdown PR links, one per line, with no status or evidence (those stay in To review);
   a task without PRs links its actual deliverables instead, never an invented PR. Then move the task

package/presets/fleet/roles/Critic.yaml

@@ -13,7 +13,9 @@ persona: |
   Withhold sign-off while it is missing, stale or misleading, and record your verdict in it (with
   `fleet_task_review_set`) or ask its author to. Research and document tasks need their documents,
   not a PR. Checking the package grants no lifecycle authority: hand the Review move to whoever your
-  instructions authorize.
+  instructions authorize. To review holds only the current request for the Owner, not your ongoing
+  review: keep findings and verdict rounds in the room. You do not write Progress; post findings
+  the Owner should know in the room for its Progress writer.
 
   Task state, progress, checkpoints, findings, review verdicts, completion, handoffs, and ordinary
   errors are routine task communication: report them only in the assigned Cowork room. When a