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

package/dist/preset-migration.js

@@ -89,6 +89,16 @@ const PEER_WAIT_REMINDER_FINGERPRINTS = Object.freeze({
     'roles/Critic.yaml': ['998abdbc5159e8e1c26eb1ca09f9707b005ba1930bd5b7a4989c4d6893804c4a'],
     'roles/Engineer.yaml': ['a361453ad32cde08797cf90fff17a35bde1871ccea17389448b44398b45ccfa5'],
 });
+// The packaged revision-11 charters before task Progress and the self-contained To review handoff.
+// Untouched copies adopt the current text; edited ones stay.
+const REVIEW_PACKAGE_FINGERPRINTS = Object.freeze({
+    'roles/Developer.yaml': ['cd2da8c9fb4d56b08c618221e38b9c8a2568a59b7d7ee6e44d0f6f55f9dc42e9'],
+    'roles/Critic.yaml': ['b2576fe4b9501581e874daa40b77e0379220c855a76d0fd80945e9fc42e08131'],
+    'roles/Engineer.yaml': ['dc99a42f64c4bc2c5073917f4552a366a0ab95c24bdde9e13d66320d68edac1b'],
+    'roles/LocalCoordinator.yaml': ['1a4c7613de0c374ac49ede31b312fcfd3f4a08d31316cf8dda10e46f25844e03'],
+    'roles/Coordinator.yaml': ['1fa72470f37330a96debdfa6a64004280edcf318fafd5f6a5065a06ee7e87acc'],
+    'agent_templates/LocalCoordinator.yaml': ['931908da43df7c85dd2b106c99c765a3aeb4a97361fa00ce110e3ac93221ce32'],
+});
 const CURRENT_ROLE_DEFAULTS = new Set([
     'roles/Coordinator.yaml', 'roles/LocalCoordinator.yaml', 'roles/Developer.yaml', 'roles/Critic.yaml',
     'roles/Engineer.yaml',
@@ -221,6 +231,7 @@ export function migratePackagedRoleDefaults(configuration, options = {}, hooks =
             ...Object.keys(OWNER_CHANNEL_COORDINATOR_FINGERPRINTS),
             ...Object.keys(REREADING_CONTINUITY_LOOP_FINGERPRINTS),
             ...Object.keys(PEER_WAIT_REMINDER_FINGERPRINTS),
+            ...Object.keys(REVIEW_PACKAGE_FINGERPRINTS),
         ]);
         for (const relative of known) {
             const path = join(root, relative);
@@ -237,6 +248,7 @@ export function migratePackagedRoleDefaults(configuration, options = {}, hooks =
                 ...(OWNER_CHANNEL_COORDINATOR_FINGERPRINTS[relative] ?? []),
                 ...(REREADING_CONTINUITY_LOOP_FINGERPRINTS[relative] ?? []),
                 ...(PEER_WAIT_REMINDER_FINGERPRINTS[relative] ?? []),
+                ...(REVIEW_PACKAGE_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

@@ -45,6 +45,8 @@ 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 { verifiedFleetCaller } from '../fleet-command-audit.js';
 import { beginFleetAuditCollection, consumeFleetAuditCollection, recordFleetAuditFailure, recordFleetAuditPresentation, recordFleetAuditResource, } from '../fleet-command-audit.js';
 import { renderAgentConfiguration } from '../lifecycle-summary.js';
 import { withFileLock } from '../atomic-file.js';
@@ -135,6 +137,28 @@ function taskRoomPublicFailure(error) {
         };
     }
 }
+/** A supervisor-verified managed agent is attributed as itself; otherwise the local operator. */
+function cliContributionAuthor(taskId) {
+    const verified = verifiedFleetCaller();
+    if (!verified)
+        return { kind: 'local_control', surface: 'cli' };
+    // The same identity CID the agent's MCP tools use, so retries match across both surfaces.
+    const cid = getTask(taskId).member_roles.find(item => item.name === verified.caller)?.identity_cid ?? bridgeIdentityCid(verified.stateDir);
+    return { kind: 'agent', role: verified.caller, ...(cid ? { identity_cid: cid } : {}), surface: 'cli' };
+}
+/** The managed runtime CID its supervisor recorded for the agent's MCP bridge, when present. */
+function bridgeIdentityCid(stateDir) {
+    try {
+        const cid = JSON.parse(readFileSync(join(stateDir, '.ours-bridge', 'descriptor.json'), 'utf8')).cid;
+        return typeof cid === 'string' && /^[A-Fa-f0-9]{64}$/.test(cid) ? cid : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function contributionAuthorLabel(author) {
+    return author.kind === 'agent' ? `${author.role} (agent, ${author.surface})` : `local ${author.surface}`;
+}
 function die(e) {
     const msg = e instanceof TaskRoomPublicError
         ? taskRoomPublicFailure(e).legacy : e instanceof Error ? e.message : String(e);
@@ -201,6 +225,19 @@ function dieTaskRoom(e) {
         recordFleetAuditFailure({ class: 'validation', effect: 'not_started' });
         process.exit(1);
     }
+    if (e instanceof TaskReviewError) {
+        const output = renderMarkdownFailure({
+            kind: e.code === 'not_found' ? 'not_found' : e.code === 'conflict' || e.code === 'idempotency_conflict' ? 'state' : 'usage',
+            subject: 'ours-fleet task progress/review-package',
+            detail: e.message,
+            action: e.code === 'conflict' ? 'Show the current review package and retry against it.'
+                : e.code === 'idempotency_conflict' ? 'Use a new --request-key for different content.'
+                    : 'Correct the request and retry.',
+        });
+        process.stderr.write(`${output}\n`);
+        recordFleetAuditFailure({ class: 'validation', effect: 'not_started' });
+        process.exit(1);
+    }
     if (e instanceof TaskListError) {
         const notFound = e.code === 'list_not_found';
         const conflict = ['duplicate_name', 'reserved_name', 'default_immutable',
@@ -1028,6 +1065,86 @@ export function registerTaskCommands(parent, cOpt) {
             dieTaskRoom(e);
         }
     });
+    taskCmd.command('progress <id>')
+        .description('read the task Progress log, or append one significant milestone with --text')
+        .option('--text <text>', 'milestone text to append, kept exactly as written')
+        .option('--text-file <path>', 'milestone text to append, from a file')
+        .option('--request-key <key>', 'retry key: repeating the same key and text returns the original entry')
+        .option('--json', 'JSON output')
+        .action((id, opts) => {
+        try {
+            if (opts.text !== undefined && opts.textFile !== undefined)
+                throw new Error('use --text or --text-file, not both');
+            const text = opts.textFile !== undefined ? readFileSync(opts.textFile, 'utf8') : opts.text;
+            if (text === undefined) {
+                if (opts.requestKey !== undefined)
+                    throw new Error('--request-key applies only when appending');
+                const progress = listTaskProgress(id).map(publicProgressEntry);
+                if (opts.json) {
+                    console.log(JSON.stringify({ schema_version: 1, task_id: id, progress }, null, 2));
+                    return;
+                }
+                console.log(progress.length ? progress.map(entry => `- ${entry.at} — ${contributionAuthorLabel(entry.author)}\n\n${entry.text}\n`).join('\n')
+                    : `Task ${id} has no progress entries.`);
+                return;
+            }
+            const result = appendTaskProgress(id, { text, requestKey: opts.requestKey, author: cliContributionAuthor(id) });
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, task_id: id, entry: publicProgressEntry(result.entry), replayed: result.replayed }, null, 2));
+                return;
+            }
+            console.log(result.replayed ? `Progress entry ${result.entry.id} was already recorded.` : `Progress entry ${result.entry.id} added to task ${id}.`);
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
+    taskCmd.command('review-package <id>')
+        .description('show or prepare the task To review package (Markdown and retained files)')
+        .option('--markdown <text>', 'replace the review Markdown')
+        .option('--markdown-file <path>', 'replace the review Markdown from a file')
+        .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('--json', 'JSON output')
+        .action(async (id, opts) => {
+        try {
+            if (opts.markdown !== undefined && opts.markdownFile !== undefined)
+                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');
+            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 attached = [];
+            if (markdown !== undefined)
+                setTaskReviewMarkdown(id, { markdown, expectedMarkdown: getTaskReview(id)?.markdown ?? '', author: author });
+            for (const artifactId of opts.detach)
+                detachTaskReviewArtifact(id, artifactId, { author: author });
+            for (const path of opts.attach) {
+                const source = await openTaskWorkspaceFile(getTask(id), path);
+                attached.push(await attachTaskReviewArtifact(id, { name: source.name, source, author: author, requestKey: opts.requestKey }));
+            }
+            const review = getTaskReview(id);
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, task_id: id, review: review ? publicReview(review) : null }, null, 2));
+                return;
+            }
+            if (!review) {
+                console.log(`Task ${id} has no To review package yet.`);
+                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._'}`
+                + (attached.some(item => item.replayed) ? '\n\n(The attached file was already recorded.)' : ''));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
     cOpt(taskCmd.command('done <id>'))
         .description('complete a task')
         .option('--summary <text>', 'completion summary')

package/dist/rooms-tasks/deletion.js

@@ -15,6 +15,7 @@ import { deleteRoomRecord, getRoomRecord, listRoomRecords } from './room-state.j
 import { acquireLaunchSnapshotLock, releaseLaunchSnapshotForDeletingTask } from './launch-snapshot.js';
 import { TASK_OPERATION_LOCK_STALE_MS, taskOperationLockPath } from './terminal.js';
 import { advanceTaskDeletionMember, settleAbsentTaskDeletionMember, beginTaskDeletionIntent, completeTaskDeletionReceipt, ensureTaskDeletionReceipt, getDeletingTask, importTaskDeletionRetirementEvidence, setTaskDeletionError, TaskStateError, beginTaskArchiveCleanup, unlinkDeletedTask, upsertTaskDeletionMembersFromSeats, } from './task-state.js';
+import { deleteTaskReviewStore } from './task-review.js';
 export { DELETION_MEMBER_ABSENT_VERIFIED } from './task-state.js';
 import { DELETION_MEMBER_ABSENT_VERIFIED } from './task-state.js';
 /**
@@ -266,6 +267,8 @@ export async function settleTaskDeletion(input) {
                 collectWorkspaceArchives(task.workspace);
                 deleteWorkspace(task.workspace, 'task', taskId);
             }
+            // Retained To review files go with the task; the pending deletion already refuses new attachments.
+            deleteTaskReviewStore(taskId);
             unlinkDeletedTask(taskId);
         }
         catch (error) {

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

@@ -0,0 +1,113 @@
+import type { TaskContributionAuthor, TaskProgressEntry, TaskRecord, TaskReview, TaskReviewArtifact } from './types.js';
+export declare const PROGRESS_TEXT_MAX = 4000;
+export declare const PROGRESS_MAX_ENTRIES = 200;
+export declare const REVIEW_MARKDOWN_MAX = 50000;
+export declare const REVIEW_MAX_ARTIFACTS = 20;
+export declare const REVIEW_ARTIFACT_MAX_BYTES: number;
+export declare class TaskReviewError extends Error {
+    readonly code: 'invalid_request' | 'idempotency_conflict' | 'limit_exceeded' | 'conflict' | 'not_found';
+    constructor(code: 'invalid_request' | 'idempotency_conflict' | 'limit_exceeded' | 'conflict' | 'not_found', message: string);
+}
+export declare function reviewArtifactMime(name: string): string;
+export declare function checkArtifactName(name: string): string;
+export declare function listTaskProgress(taskId: string): TaskProgressEntry[];
+/**
+ * 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
+ * entry; the same key with different text is a conflict.
+ */
+export declare function appendTaskProgress(taskId: string, input: {
+    text: string;
+    author: TaskContributionAuthor;
+    requestKey?: string;
+}): {
+    entry: TaskProgressEntry;
+    replayed: boolean;
+};
+export declare function getTaskReview(taskId: string): TaskReview | undefined;
+/**
+ * Replace the review Markdown. `expectedMarkdown` is what the writer last read
+ * ('' when none); a different current value is a stale edit. Re-sending the
+ * value already stored succeeds, so retries are safe.
+ */
+export declare function setTaskReviewMarkdown(taskId: string, input: {
+    markdown: string;
+    expectedMarkdown: string;
+    author: TaskContributionAuthor;
+}): TaskReview;
+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. */
+export type Source = {
+    size: number;
+    body: ReadableStream<Uint8Array>;
+    close(): Promise<void>;
+    verify?(): Promise<void>;
+};
+type Stored = {
+    id: string;
+    size: number;
+    sha256: string;
+};
+/**
+ * Attach one file to the review package: reserve under the task lock, copy
+ * into the private store, then commit metadata under the lock again; any
+ * failure removes the copy. A retry with the same author-scoped request_key
+ * is compared by content without storing another copy: identical content
+ * returns the original artifact, different content is a conflict. Without a
+ * key an interrupted call may or may not have attached: read the package
+ * before retrying.
+ */
+export declare function attachTaskReviewArtifact(taskId: string, input: {
+    name: string;
+    source: Source;
+    author: TaskContributionAuthor;
+    requestKey?: string;
+    signal?: AbortSignal;
+    /** Test seam: runs after the bytes are durable, before the record references them. */
+    beforeCommit?(stored: Stored): void;
+    /** Test seam: runs after a keyed retry was read, before it is confirmed under the lock. */
+    beforeReplay?(): void;
+}): Promise<{
+    artifact: TaskReviewArtifact;
+    replayed: boolean;
+}>;
+/** Remove a file from the package; repeating it after success reports not found. */
+export declare function detachTaskReviewArtifact(taskId: string, artifactId: string, input: {
+    author: TaskContributionAuthor;
+}): TaskReviewArtifact;
+/** Bytes of a referenced artifact, integrity-checked; only the owning task can name it. */
+export declare function readTaskReviewArtifact(taskId: string, artifactId: string): Promise<{
+    artifact: TaskReviewArtifact;
+    bytes: Buffer;
+}>;
+/** Task deletion: remove every retained review file of the task. */
+export declare function deleteTaskReviewStore(taskId: string): void;
+/** True when `path` names an entry strictly inside `root`, compared by path components. */
+export declare function insideDirectory(root: string, path: string): boolean;
+/** The task's owned workspace, validated against its ownership marker. */
+export declare function taskWorkspaceRoot(task: TaskRecord): string;
+/**
+ * Open a file inside the task workspace in this process's own OS context (the
+ * CLI). Every component below the pinned workspace is opened without
+ * following symlinks; the file must be one regular, singly-linked file.
+ */
+export declare function openTaskWorkspaceFile(task: TaskRecord, input: string, cwd?: string): Promise<Source & {
+    name: string;
+}>;
+/** Size of the store, for diagnostics and tests. */
+export declare function reviewStoreFiles(taskId: string): string[];
+/** Wire shapes: retry keys stay internal. */
+export declare function publicProgressEntry(entry: TaskProgressEntry): Omit<TaskProgressEntry, 'request_key'>;
+export declare function publicReview(review: TaskReview): TaskReview;
+/** Compact summary for list and detail payloads; bodies are fetched separately. */
+export declare function taskContributionSummary(task: TaskRecord): {
+    progress_count: number;
+    review: {
+        has_markdown: boolean;
+        artifact_count: number;
+        revision: number;
+        updated_at?: string;
+    };
+};
+export {};