@ours.network/fleet 2.3.2 → 2.3.4

package/dist/spawn.js

@@ -2,6 +2,7 @@ import { taskSupervisorMayRun } from './task-supervision.js';
 import { randomUUID } from 'node:crypto';
 import { storeRoomSecret, storeTemporaryLaunch, preparePermanentAssignment } from './agent-ours/service.js';
 import { ensureWorkspace } from './rooms-tasks/workspace.js';
+import { assertCwdNotInRemovedTaskFolder } from './rooms-tasks/workspace-removal.js';
 import { spawn as spawnChild } from 'node:child_process';
 import { closeSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { join } from 'node:path';
@@ -324,6 +325,7 @@ export async function spawnTemp(o, binPath, launch = independentSupervisor, crea
     if (o.isolationFile)
         readIsolationFile(o.isolationFile); // fail before reserving
     const prepared = resolvedSpawn(o); // canonical validation before mutation
+    assertCwdNotInRemovedTaskFolder(prepared.role.cwd);
     if ((o.taskOwner || o.roomMemberStartup?.task_id) && !getAdapter(prepared.role.harness).supportsResume)
         throw Error('TASK_HARNESS_RESUME_UNSUPPORTED: task agents require a resumable harness');
     if (o.roomMemberStartup?.workspace) {

package/dist/web/server.js

@@ -23,8 +23,10 @@ import { AuditSink } from './audit.js';
 import { WebAuth } from './auth.js';
 import { FleetEventBus } from './events.js';
 import { ROLE_NAME_RE } from '../config.js';
+import { workingFilesSummary } from '../rooms-tasks/workspace-removal.js';
 import { TaskListError } from '../rooms-tasks/task-lists.js';
 import { acknowledgeTaskProgress, acknowledgeTaskReview, contributionUnread, resolveTaskRef, TaskStateError } from '../rooms-tasks/task-state.js';
+import { CONTRIBUTION_CUTOFF_MAX, CONTRIBUTION_PAGE_MAX, listTaskContributions, readTaskContributions } from '../rooms-tasks/task-contributions.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';
@@ -389,7 +391,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, member_naming: _naming, ...rest } = task;
-        return { ...rest, ...taskContributionSummary(task) };
+        return { ...rest, ...taskContributionSummary(task), working_files: workingFilesSummary(task) };
     };
     const wireTaskResult = (result) => {
         const value = result;
@@ -624,6 +626,14 @@ export async function buildWebServer(services, boundary, options = {}) {
             recovery: `Repeat DELETE /api/v1/tasks/${submitted}?confirm=${submitted}.`,
         };
     });
+    // Removes only the Done task's own working folder; the task, Progress, To review files and chat history stay.
+    app.post('/api/v1/tasks/:id/working-files/remove', async (request) => {
+        auth.authenticate(request, true);
+        const result = await taskApi(() => requireTaskRooms().removeTaskWorkingFiles({
+            actor: { kind: 'local_control', surface: 'web' }, taskId: taskRef(request),
+        }));
+        return { task: wireTask(result.task), result: result.result, mentions: result.mentions };
+    });
     app.post('/api/v1/tasks', async (request, reply) => {
         auth.authenticate(request, true);
         const body = request.body;
@@ -686,6 +696,39 @@ export async function buildWebServer(services, boundary, options = {}) {
             reply.code(201);
         return { entry: publicProgressEntry(result.entry), replayed: result.replayed };
     });
+    /**
+     * Progress and To review of every task, newest first, for the notification list. The first page
+     * (no `before`) also carries the cutoff a bulk read may acknowledge up to: each task with unread
+     * items as it was read, one task at a time (per task, not one atomic instant across tasks).
+     */
+    app.get('/api/v1/contributions', async (request) => {
+        auth.authenticate(request);
+        const query = request.query;
+        if (query.unread !== undefined && !['true', 'false'].includes(query.unread))
+            throw new FleetError('invalid_request', 'unread must be true or false');
+        if (query.limit !== undefined && !/^\d{1,3}$/.test(query.limit))
+            throw new FleetError('invalid_request', `limit must be 1-${CONTRIBUTION_PAGE_MAX}`);
+        const page = await reviewApi(() => listTaskContributions({
+            ...(query.before !== undefined ? { before: query.before } : {}),
+            ...(query.limit !== undefined ? { limit: Number(query.limit) } : {}),
+            unread: query.unread === 'true',
+        }));
+        const { cutoff, ...rest } = page;
+        return query.before === undefined ? page : rest;
+    });
+    /** Bulk read up to a captured cutoff, at most `CONTRIBUTION_CUTOFF_MAX` tasks per request, with a result per task. */
+    app.post('/api/v1/contributions/read', async (request) => {
+        auth.authenticate(request, true);
+        const cutoff = request.body?.cutoff;
+        const valid = (item) => !!item && typeof item === 'object' && Object.keys(item).length === 4
+            && typeof item.task_id === 'string' && /^[0-9a-z]{9}[0-9a-f]{8}$/.test(item.task_id) && Number.isSafeInteger(item.progress) && item.progress >= 0
+            && (item.progress_last === null || (typeof item.progress_last === 'string' && item.progress_last.length <= 64))
+            && Number.isSafeInteger(item.review) && item.review >= 0;
+        if (!Array.isArray(cutoff) || cutoff.length > CONTRIBUTION_CUTOFF_MAX || !cutoff.every(valid)
+            || new Set(cutoff.map(item => item.task_id)).size !== cutoff.length)
+            throw new FleetError('invalid_request', `cutoff must list at most ${CONTRIBUTION_CUTOFF_MAX} distinct tasks as captured`);
+        return { results: await reviewApi(() => readTaskContributions(cutoff)) };
+    });
     /** Acknowledge Progress entries the browser actually showed; returns the task's remaining unread. */
     app.post('/api/v1/tasks/:id/progress/read', async (request) => {
         auth.authenticate(request, true);

package/docs/task-progress-review.md

@@ -155,6 +155,8 @@ workspace-device bearer. `GET /api/v1/meta` reports API minor version 1.
 | `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. |
+| `GET /contributions?limit=1-100&before=&unread=true` | Every task's Progress entries and current To review revision for the notification list, newest first: `{items: [{id, kind, task_id, mission_key?, task_title, task_state, at, excerpt, unread, entry_id? \| revision?}], next_cursor, unread_total, unavailable}`. The cursor is a position, valid after its item is read or deleted. Tasks pending deletion are left out; `unavailable` counts unreadable task records. The first page also has `cutoff: [{task_id, progress, progress_last, review}]` for every task with unread items, each captured from that task's own read (per task, not one instant across tasks). |
+| `POST /contributions/read` | `{cutoff}` with at most 200 distinct tasks from a first page: reads each task's first `progress` entries and review revision `review`, never later ones, one task change each. `{results: [{task_id, status}]}` in request order, `status` `read` (with `read`: items that were unread and are read now), `changed` (the task no longer matches its cutoff; nothing written), `gone`, `deleting` or `failed`. |
 
 The HTTP API has no upload route: the browser never submits a file path.
 

package/docs/task-workspaces.md

@@ -30,6 +30,7 @@ complete internal worktree registries, including dirty and stale owned entries.
 | Operation | Workspace and execution artifacts | Member runtime evidence |
 | --- | --- | --- |
 | Complete, fail, cancel | Retained while Task is recorded | Retained in Fleet recovery archives |
+| Explicit working-files removal (Done Task only) | Task workspace removed; Task, Progress and To review files retained | Retained in Fleet recovery archives |
 | Linked Room retirement or deletion | Task workspace retained | Retained |
 | Internal standalone Room retirement | Room workspace retained | Retained |
 | Explicit Task deletion | Removed after member retirement, with the task's retained To review files | All proven owned retired launches removed |
@@ -39,7 +40,8 @@ Internal room close means retirement, not destructive Task deletion.
 The existing CLI `room close ID ID` remains a deprecated alias for explicit
 `room delete ID ID`: it deletes standalone room-owned artifacts, but always
 retains a linked Task workspace. Its repeated-ID confirmation is unchanged. To remove a Task's
-artifacts, explicitly delete the Task. Cancellation is not deletion. Automatic
+artifacts, explicitly delete the Task, or, for a Done Task, remove only its working files
+(`task remove-files ID`, below). Cancellation is not deletion. Automatic
 compatibility cleanup of legacy closed Rooms skips records with owned workspaces.
 These choices reconcile close/remove wording with the requirement that completed,
 recorded Tasks retain all artifacts.
@@ -223,3 +225,51 @@ requires a supported Home Screen installation and granted device/browser permiss
 reopen the workspace to reconcile an expired subscription and explicitly re-enable
 permission if it was revoked. Every received push must display a notification to
 honor Safari's user-visible push requirement.
+
+## Removing a Done Task's working files
+
+`ours-fleet task remove-files ID` (API `POST /api/v1/tasks/ID/working-files/remove`)
+frees disk space without deleting the Task. It removes only the recorded owned
+workspace through the same guarded deletion as Task deletion (marker, Git
+registration, symlink and mount checks, token tombstone). It never collects or
+erases recovery archives, member artifacts or the To review store, and never
+closes rooms or stops agents. It runs under the task operation lock and refuses
+with the reason unless all of these hold:
+
+- the Task is Done with its completion settled, and is not being deleted;
+- no room record names the Task or its workspace, and every room record is readable;
+- a layout run exists, is closed, is not uncertain, and has retired every owned participant;
+- no supervisor registration belongs to the Task;
+- no unarchived temporary agent state belongs to the Task or works in the
+  folder (cwd or startup workspace, literally or through symlinks), and all
+  such state is readable;
+- no permanent agent's recorded `.cwd` or configured cwd is in the folder.
+
+The intent is recorded before a final in-use scan. Agent state that names a
+task folder is created under that folder's use lock and refuses a folder
+whose removal began, so a concurrent launch is either seen by the scan or
+refused. After the folder is renamed to its tombstone and before anything
+is removed, every process's cwd, root and open files are checked (Linux
+`/proc`). A process that entered the folder earlier restores the folder and
+refuses the removal. Platforms without this check refuse the removal.
+A same-user process whose cwd and descriptors are unreadable (for example
+non-dumpable, or in a container) refuses the removal unless it is a zombie.
+Nothing readable proves such a process holds nothing in the folder: a
+retained cwd or descriptor survives namespace and chroot changes, and a user
+service manager may keep descriptors in its store. The refusal names each
+such process by pid and kernel name (never its command line), with
+read-only context such as "own mount namespace without the folder".
+Another user's unreadable process is skipped when a private ancestor closes
+the folder to it. Superuser processes are outside the check. On hosts that
+run rootless containers or a user service manager, this strict check can
+make removal unavailable while those processes run. Only a folder
+that this run renamed intact is restored. A partly removed tombstone from an
+earlier run stays in place with the refusal recorded, so a later retry can
+finish it.
+
+The Task records `workspace_removal` (started, completed, error), shown as
+`working_files` in API payloads. A retry resumes an unfinished tombstone, and
+repeating a finished removal changes nothing. A folder already missing on the
+first run is recorded as such. A create replay never recreates the folder, and
+To review files can no longer be attached from it. Explicit Task deletion
+still works and first finishes an interrupted removal.

package/package.json

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