@ours.network/fleet 1.0.4 → 1.0.5

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

@@ -24,7 +24,7 @@ export interface TaskMemberRole {
     cowork_role: string;
 }
 export interface TaskOrigin {
-    type: 'cli' | 'owner_channel';
+    type: 'cli' | 'owner_channel' | 'web';
     owner_cid?: string;
 }
 export interface TaskOutcome {
@@ -46,6 +46,10 @@ export interface TaskTerminalIntent {
 }
 export interface TaskRecord {
     task_id: string;
+    /** Stable organizational list identifier. Missing legacy values mean `default`. */
+    list_id: string;
+    /** Derived presentation field; repositories must never persist it. */
+    list_name: string;
     title: string;
     brief?: string;
     brief_file?: string;
@@ -64,6 +68,12 @@ export interface TaskRecord {
     outcome?: TaskOutcome;
     terminal_intent?: TaskTerminalIntent;
 }
+export interface TaskListRecord {
+    list_id: string;
+    name: string;
+    built_in: boolean;
+    created_at: string;
+}
 export type RoomOrchestrationState = 'provisioning' | 'active' | 'closing' | 'closed';
 export type SagaPhase = 'persist_intent' | 'create_room' | 'attach_owner' | 'create_members' | 'join_role_groups' | 'wait_seats' | 'launch_work' | 'activate' | 'completed' | 'failed';
 export interface SagaCursor {

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)

package/package.json

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