@ours.network/fleet 1.0.3 → 1.0.5

package/dist/session/control.js

@@ -2,13 +2,26 @@ import { randomBytes, randomUUID, timingSafeEqual } from 'node:crypto';
 import { chmodSync, existsSync, readFileSync, rmSync, writeFileSync } from 'node:fs';
 import { createConnection, createServer } from 'node:net';
 import { join } from 'node:path';
-import { SessionControlError, interruptOutcome } from './types.js';
+import { SessionControlError } from './types.js';
+import { interruptSession, queueSessionPrompt, respondSessionPermission, respondSessionPermissionV2, } from '../application/session-mutations.js';
 const MAX_LINE_BYTES = 64 * 1024;
 /** Commands that require protocol version 3. */
 const V3_COMMANDS = new Set([
     'conversation_page', 'conversation_follow', 'submit_prompt_v2', 'interrupt_v2',
     'respond_permission_v2',
 ]);
+/** The one retained-range projection shared by polling and live-follow admission. */
+export function retainedEventPage(session, since) {
+    const events = session.eventsSince(since);
+    const all = session.eventsSince(0);
+    return {
+        events,
+        snapshot: session.snapshot(),
+        firstSeq: all[0]?.seq ?? 0,
+        lastSeq: all.at(-1)?.seq ?? 0,
+        truncated: Boolean(all[0] && since > 0 && since < all[0].seq - 1),
+    };
+}
 /**
  * One line saying what a control failure does — and does not — prove about the
  * agent. Only `offline` is evidence that it is gone; every other kind used to
@@ -230,7 +243,7 @@ export class RoleControlServer {
                     // Answer on QUEUE ACCEPTANCE, not on turn completion. A turn can run
                     // for minutes; blocking here made every `send` into a busy agent time
                     // out, and the timeout was then reported as a dead agent.
-                    const queued = await this.session.queuePrompt(request.text, {
+                    const queued = await queueSessionPrompt(this.session, request.text, {
                         origin: { kind: 'local-console' },
                     });
                     this.write(socket, {
@@ -244,7 +257,7 @@ export class RoleControlServer {
                 case 'respond_permission': {
                     if (!request.permissionId || !request.optionId)
                         throw new SessionControlError('rejected', 'permissionId and optionId are required');
-                    const accepted = this.session.respondPermission(request.permissionId, request.optionId);
+                    const accepted = respondSessionPermission(this.session, request.permissionId, request.optionId);
                     this.write(socket, {
                         version: 1, id: request.id, ok: accepted,
                         result: { accepted },
@@ -256,7 +269,7 @@ export class RoleControlServer {
                 case 'interrupt': {
                     // Forced recovery cancelled the turn just as surely as a cooperative
                     // stop did. Report HOW, never as a failed operation.
-                    const outcome = interruptOutcome(await this.session.interrupt('local-console'));
+                    const outcome = await interruptSession(this.session, 'local-console');
                     this.write(socket, { version: 1, id: request.id, ok: true, result: outcome });
                     return;
                 }
@@ -309,29 +322,17 @@ export class RoleControlServer {
                 }
                 case 'events_since': {
                     const since = Number.isFinite(request.since) ? Number(request.since) : 0;
-                    const events = this.session.eventsSince(since);
-                    const all = this.session.eventsSince(0);
                     this.write(socket, {
                         version: 1, id: request.id, ok: true,
-                        result: {
-                            events, snapshot: this.session.snapshot(),
-                            firstSeq: all[0]?.seq ?? 0, lastSeq: all.at(-1)?.seq ?? 0,
-                            truncated: Boolean(all[0] && since > 0 && since < all[0].seq - 1),
-                        },
+                        result: retainedEventPage(this.session, since),
                     });
                     return;
                 }
                 case 'follow': {
                     const since = Number.isFinite(request.since) ? Number(request.since) : 0;
-                    const events = this.session.eventsSince(since);
-                    const all = this.session.eventsSince(0);
                     this.write(socket, {
                         version: 1, id: request.id, ok: true,
-                        result: {
-                            events, snapshot: this.session.snapshot(),
-                            firstSeq: all[0]?.seq ?? 0, lastSeq: all.at(-1)?.seq ?? 0,
-                            truncated: Boolean(all[0] && since > 0 && since < all[0].seq - 1),
-                        },
+                        result: retainedEventPage(this.session, since),
                     });
                     const controller = request.controller !== false;
                     if (controller)
@@ -399,7 +400,7 @@ export class RoleControlServer {
                         this.write(socket, { version: 1, id: request.id, ok: true, result: existing });
                         return;
                     }
-                    const outcome = interruptOutcome(await this.session.interrupt('local-console'));
+                    const outcome = await interruptSession(this.session, 'local-console');
                     const receipt = {
                         accepted: true, commandId: request.commandId, at: new Date().toISOString(),
                         ...outcome,
@@ -417,9 +418,9 @@ export class RoleControlServer {
                     if (!request.commandId?.trim() || !request.permissionId?.trim()
                         || !request.optionId?.trim() || !request.sessionGeneration?.trim())
                         throw new SessionControlError('rejected', 'commandId, permissionId, optionId and sessionGeneration are required');
-                    if (!this.session.respondPermissionV2)
+                    const result = respondSessionPermissionV2(this.session, request.permissionId, request.optionId, request.sessionGeneration);
+                    if (result === 'unavailable')
                         throw new SessionControlError('rejected', 'generation-bound permission responses are unavailable for this role');
-                    const result = this.session.respondPermissionV2(request.permissionId, request.optionId, request.sessionGeneration);
                     if (result === 'stale')
                         throw new SessionControlError('rejected', 'stale_state: permission is settled, expired, invalid, or belongs to another session generation');
                     this.write(socket, {

package/dist/watchdog/query.d.ts

@@ -6,6 +6,8 @@ export interface WatchdogRoleFinding {
     status: WatchdogRoleStatus;
     reason: string;
 }
+/** Shared configured-or-surviving-history addressability rule. */
+export declare function watchdogAddressable(name: string, configured: readonly string[], historyExists?: (validName: string) => boolean): boolean;
 /**
  * Needs-attention integration: worst current finding per role across
  * every configured watchdog, for FleetQueryService.status() to fold into a

package/dist/watchdog/query.js

@@ -6,6 +6,12 @@ import { watchdogsRoot } from '../paths.js';
 import { WATCHDOG_STATUS_RANK } from './alerts.js';
 import { readSchedulerState } from './scheduler.js';
 import { listRuns, readReport } from './store.js';
+/** Shared configured-or-surviving-history addressability rule. */
+export function watchdogAddressable(name, configured, historyExists = validName => existsSync(join(watchdogsRoot(), validName))) {
+    if (configured.includes(name))
+        return true;
+    return ROLE_NAME_RE.test(name) && historyExists(name);
+}
 /**
  * Needs-attention integration: worst current finding per role across
  * every configured watchdog, for FleetQueryService.status() to fold into a
@@ -115,9 +121,7 @@ export class WatchdogQueryService {
      */
     requireKnown(name) {
         const cfg = this.cfgProvider();
-        if (cfg.watchdogs.some(wd => wd.name === name))
-            return;
-        if (ROLE_NAME_RE.test(name) && existsSync(join(watchdogsRoot(), name)))
+        if (watchdogAddressable(name, cfg.watchdogs.map(wd => wd.name)))
             return;
         throw new FleetError('role_not_found', `no such watchdog '${name}'`);
     }

package/dist/web/runtime.js

@@ -31,6 +31,7 @@ import { startWebControlServer } from './control.js';
 import { WebAccessStore, validatePublicOrigin } from './access.js';
 import { buildWatchdogFindings, cachedWatchdogFindingsProvider, WatchdogQueryService } from '../watchdog/query.js';
 import { latestReport } from '../watchdog/store.js';
+import { TaskRoomApplicationService } from '../application/task-room-service.js';
 const CONFIG_CACHE_TTL_MS = 5_000;
 /**
  * loadConfig re-parses YAML from disk on every call; the watchdog list/reports
@@ -159,6 +160,7 @@ export async function startWebConsole(options) {
     try {
         server = await buildWebServer({
             query, repository, logs, commands, creation, removal, audit, events, watchdogs, configuration,
+            taskRooms: new TaskRoomApplicationService(options.configPath),
             topology: readTopology, topologyDrafts, topologyPromote,
             terminalUpgrade: terminalAvailable
                 ? async (socket, _request, roleId, _ticket, hello) => terminals.connect(socket, roleId, hello)

package/dist/web/server.d.ts

@@ -15,6 +15,7 @@ import type { MergedTopology } from './topology-model.js';
 import type { TopologyDraftStore } from './topology-draft-store.js';
 import type { TopologyPromoteService } from './topology-promote.js';
 import type { RoleRemovalService } from '../application/role-removal-service.js';
+import type { TaskRoomApplicationService } from '../application/task-room-service.js';
 export interface WebServices {
     query: FleetQueryService;
     repository: RoleRepository;
@@ -30,6 +31,7 @@ export interface WebServices {
     topologyDrafts?: TopologyDraftStore;
     topologyPromote?: TopologyPromoteService;
     removal?: RoleRemovalService;
+    taskRooms?: TaskRoomApplicationService;
     terminalUpgrade?: (socket: WebSocket, request: FastifyRequest, roleId: string, ticket: string, hello: Record<string, unknown>) => Promise<void>;
 }
 export interface WebServer {

package/dist/web/server.js

@@ -11,8 +11,10 @@ import { AuditSink } from './audit.js';
 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 { TaskStateError } from '../rooms-tasks/task-state.js';
 const statusFor = (code) => ({
-    role_not_found: 404, unauthorized: 401, forbidden: 403, conflict: 409,
+    role_not_found: 404, resource_not_found: 404, unauthorized: 401, forbidden: 403, conflict: 409,
     idempotency_conflict: 409, stale_state: 409, rate_limited: 429,
     invalid_request: 400, capability_unavailable: 409, prerequisite_unavailable: 503,
 }[code] ?? 500);
@@ -128,6 +130,89 @@ export async function buildWebServer(services, boundary, options = {}) {
         auth.authenticate(request);
         return { roles: await services.query.list() };
     });
+    const taskApi = async (fn) => {
+        try {
+            return await fn();
+        }
+        catch (error) {
+            if (error instanceof TaskListError) {
+                const code = error.code === 'list_not_found' ? 'resource_not_found'
+                    : ['duplicate_name', 'destination_required', 'same_destination', 'default_immutable'].includes(error.code)
+                        ? 'conflict' : 'invalid_request';
+                throw new FleetError(code, error.message);
+            }
+            if (error instanceof TaskStateError) {
+                throw new FleetError(error.message.startsWith('task not found:') ? 'resource_not_found' : 'conflict', error.message);
+            }
+            throw error;
+        }
+    };
+    const requireTaskRooms = () => {
+        if (!services.taskRooms)
+            throw new FleetError('capability_unavailable', 'task operations are unavailable');
+        return services.taskRooms;
+    };
+    app.get('/api/v1/task-lists', async (request) => {
+        auth.authenticate(request);
+        return { lists: requireTaskRooms().listTaskLists() };
+    });
+    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 }));
+        reply.code(201);
+        return { list };
+    });
+    app.patch('/api/v1/task-lists/:name', async (request) => {
+        auth.authenticate(request, true);
+        const name = request.params.name;
+        const newName = String(request.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) => {
+        auth.authenticate(request, true);
+        const name = request.params.name;
+        const destination = request.query.destination;
+        return taskApi(() => requireTaskRooms().deleteTaskList({ actor: { kind: 'local_control', surface: 'web' }, name, destination }));
+    });
+    app.get('/api/v1/tasks', async (request) => {
+        auth.authenticate(request);
+        const query = request.query;
+        const states = ['backlog', 'provisioning', 'active', 'review', 'done', 'cancelled', 'failed'];
+        if (query.state && query.state !== 'all' && !states.includes(query.state))
+            throw new FleetError('invalid_request', 'invalid task state filter');
+        if (query.groupByList !== undefined && !['true', 'false'].includes(query.groupByList))
+            throw new FleetError('invalid_request', 'groupByList must be true or false');
+        const state = query.state && query.state !== 'all' ? query.state : undefined;
+        const filter = { ...(state ? { state } : {}), ...(query.list ? { list: query.list } : {}) };
+        return taskApi(() => query.groupByList === 'true'
+            ? { groups: requireTaskRooms().groupedTasks(filter) }
+            : { tasks: requireTaskRooms().listTasks(filter) });
+    });
+    app.post('/api/v1/tasks', async (request, reply) => {
+        auth.authenticate(request, true);
+        const body = request.body;
+        if (typeof body?.title !== 'string' || !body.title)
+            throw new FleetError('invalid_request', 'title is required');
+        const task = await taskApi(() => requireTaskRooms().createTask({
+            actor: { kind: 'local_control', surface: 'web' }, title: body.title,
+            brief: typeof body.brief === 'string' ? body.brief : undefined,
+            template: typeof body.template === 'string' ? body.template : undefined,
+            backlog: body.backlog === true, noRoom: body.noRoom === true,
+            list: typeof body.list === 'string' ? body.list : undefined,
+            idempotencyKey: typeof request.headers['idempotency-key'] === 'string'
+                ? request.headers['idempotency-key'] : undefined,
+            origin: { type: 'web' },
+        }));
+        reply.code(201);
+        return { task };
+    });
+    app.patch('/api/v1/tasks/:id/list', async (request) => {
+        auth.authenticate(request, true);
+        const taskId = request.params.id;
+        const list = String(request.body?.list ?? '');
+        return { task: await taskApi(() => requireTaskRooms().moveTask({ actor: { kind: 'local_control', surface: 'web' }, taskId, list })) };
+    });
     app.get('/api/v1/configuration', async (request) => {
         auth.authenticate(request);
         if (!services.configuration)
@@ -209,7 +294,7 @@ export async function buildWebServer(services, boundary, options = {}) {
             throw new FleetError('invalid_request', 'invalid role name');
         if (!services.removal)
             throw new FleetError('capability_unavailable', 'role removal is unavailable');
-        return services.removal.preview(request.params.id);
+        return services.removal.previewWeb(request.params.id);
     });
     app.post('/api/v1/roles/:id/remove', async (request) => {
         const session = auth.authenticate(request, true);
@@ -218,7 +303,7 @@ export async function buildWebServer(services, boundary, options = {}) {
         if (!services.removal)
             throw new FleetError('capability_unavailable', 'role removal is unavailable');
         const body = request.body;
-        const result = await services.removal.remove({ role: request.params.id, ...body });
+        const result = await services.removal.removeWeb({ role: request.params.id, ...body });
         events.publish('role.removed', { role: result.role }, result.role);
         await audit.record({ requestId: request.id, browser: session.id, roleId: result.role, action: 'role.remove', result: 'succeeded' });
         return result;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ours.network/fleet",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Harness-agnostic fleet of persistent, identity-bound AI agents. Declarative fleet.yaml, tmux or ACP sessions, supervision, and ours.network messaging.",
   "type": "module",
   "license": "FSL-1.1-Apache-2.0",