@ours.network/fleet 1.0.4 → 1.1.0-nightly.1

package/dist/rooms-tasks/cli.js

@@ -8,6 +8,7 @@ import { createRoomRecord, getRoomRecord, advanceSaga, setOwnerSeat, setSagaErro
 import { createCoworkAdapter, CoworkProtocolError } from './cowork-adapter.js';
 import { markdownCode, markdownProse, renderMarkdownFailure, renderMarkdownList, renderMarkdownResult, roomStatus, taskStatus, } from './markdown.js';
 import { TaskRoomApplicationError, TaskRoomApplicationService } from '../application/task-room-service.js';
+import { TaskListError } from './task-lists.js';
 class TaskRoomPublicError extends Error {
     code;
     fields;
@@ -128,6 +129,21 @@ function dieTaskRoom(e) {
         process.stderr.write(`${output}\n`);
         process.exit(1);
     }
+    if (e instanceof TaskListError) {
+        const notFound = e.code === 'list_not_found';
+        const conflict = ['duplicate_name', 'reserved_name', 'default_immutable',
+            'destination_required', 'same_destination'].includes(e.code);
+        const output = renderMarkdownFailure({
+            kind: notFound ? 'not_found' : conflict ? 'state' : 'usage',
+            subject: 'ours-fleet task list',
+            detail: e.message,
+            action: notFound ? 'Run ours-fleet task lists to find a valid list.'
+                : conflict ? 'Choose a different list name or an explicit valid destination.'
+                    : 'Use a valid NFC-normalized name of at most 64 Unicode code points.',
+        });
+        process.stderr.write(`${output}\n`);
+        process.exit(1);
+    }
     const taskMissing = e instanceof TaskStateError
         ? /^task not found: ([A-Za-z0-9_-]{1,128})$/u.exec(e.message) : null;
     const roomMissing = e instanceof RoomStateError
@@ -156,6 +172,7 @@ function dieTaskRoom(e) {
 const taskListMarkdown = (tasks, title = 'Tasks') => renderMarkdownList({
     icon: '📋', title, empty: 'No tasks found.',
     records: tasks.map(t => `${taskStatus(t.state)} ${markdownCode(t.task_id)} — ${markdownProse(t.title)}`
+        + ` — List ${markdownCode(t.list_name ?? 'default')}`
         + (t.blocked ? ` — 🚧 Blocked: ${markdownProse(t.blocked.reason)}` : '')),
 });
 const taskActionMarkdown = (title, task, fields = []) => renderMarkdownResult({
@@ -163,6 +180,7 @@ const taskActionMarkdown = (title, task, fields = []) => renderMarkdownResult({
     fields: [
         { label: 'ID', value: task.task_id, kind: 'code' },
         { label: 'Status', value: taskStatus(task.state), kind: 'markdown' },
+        { label: 'List', value: task.list_name ?? 'default', kind: 'code' },
         ...fields,
     ],
 });
@@ -435,6 +453,7 @@ export function registerTaskCommands(parent, cOpt) {
         .option('--backlog', 'create in backlog (do not start immediately)')
         .option('--no-room', 'create task without a room')
         .option('--idempotency-key <key>', 'idempotency key')
+        .option('--list <name>', 'task list (default: default)')
         .option('--json', 'JSON output')
         .action(async (opts) => {
         try {
@@ -443,6 +462,7 @@ export function registerTaskCommands(parent, cOpt) {
                 brief: opts.brief, briefFile: opts.briefFile, template: opts.template,
                 backlog: opts.backlog, noRoom: opts.room === false,
                 idempotencyKey: opts.idempotencyKey, origin: { type: 'cli' },
+                list: opts.list,
             });
             if (opts.json) {
                 console.log(JSON.stringify({ schema_version: 1, task: record }, null, 2));
@@ -464,6 +484,8 @@ export function registerTaskCommands(parent, cOpt) {
     cOpt(taskCmd.command('list'))
         .description('list tasks')
         .option('--state <state>', 'filter by state (backlog|active|provisioning|review|done|cancelled|failed|all)')
+        .option('--list <name>', 'filter by task list')
+        .option('--group-by-list', 'group deterministic results by list (JSON)')
         .option('--json', 'JSON output')
         .action((opts) => {
         try {
@@ -471,9 +493,13 @@ export function registerTaskCommands(parent, cOpt) {
             if (opts.state && opts.state !== 'all') {
                 stateFilter = opts.state;
             }
-            const tasks = taskRoomService(opts.configuration).listTasks(stateFilter ? { state: stateFilter } : undefined);
+            const service = taskRoomService(opts.configuration);
+            const filter = { ...(stateFilter ? { state: stateFilter } : {}), ...(opts.list ? { list: opts.list } : {}) };
+            const tasks = service.listTasks(filter);
             if (opts.json) {
-                console.log(JSON.stringify({ schema_version: 1, tasks }, null, 2));
+                console.log(JSON.stringify(opts.groupByList
+                    ? { schema_version: 1, groups: service.groupedTasks(filter) }
+                    : { schema_version: 1, tasks }, null, 2));
                 return;
             }
             console.log(taskListMarkdown(tasks));
@@ -484,6 +510,99 @@ export function registerTaskCommands(parent, cOpt) {
             dieTaskRoom(e);
         }
     });
+    taskCmd.command('lists')
+        .description('list named task lists')
+        .option('--json', 'JSON output')
+        .action((opts) => {
+        try {
+            const lists = taskRoomService().listTaskLists();
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, lists }, null, 2));
+                return;
+            }
+            console.log(renderMarkdownList({ icon: '📚', title: 'Task lists', empty: 'No task lists found.',
+                records: lists.map(list => `${markdownCode(list.name)}${list.built_in ? ' — built-in' : ''}`) }));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
+    taskCmd.command('list-create <name>')
+        .description('create a named task list')
+        .option('--json', 'JSON output')
+        .action(async (name, opts) => {
+        try {
+            const list = await taskRoomService().createTaskList({ actor: { kind: 'local_control', surface: 'cli' }, name });
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, list }, null, 2));
+                return;
+            }
+            console.log(renderMarkdownResult({ icon: '📚', title: 'Task list created', fields: [{ label: 'Name', value: list.name }] }));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
+    taskCmd.command('list-rename <name> <new-name>')
+        .description('rename a named task list')
+        .option('--json', 'JSON output')
+        .action(async (name, newName, opts) => {
+        try {
+            const list = await taskRoomService().renameTaskList({ actor: { kind: 'local_control', surface: 'cli' }, name, newName });
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, list }, null, 2));
+                return;
+            }
+            console.log(renderMarkdownResult({ icon: '📚', title: 'Task list renamed', fields: [{ label: 'Name', value: list.name }] }));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
+    taskCmd.command('list-delete <name>')
+        .description('delete a task list; non-empty lists require --move-to')
+        .option('--move-to <name>', 'destination for assigned tasks')
+        .option('--json', 'JSON output')
+        .action(async (name, opts) => {
+        try {
+            const result = await taskRoomService().deleteTaskList({ actor: { kind: 'local_control', surface: 'cli' }, name, destination: opts.moveTo });
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, ...result }, null, 2));
+                return;
+            }
+            console.log(renderMarkdownResult({ icon: '🗑️', title: 'Task list deleted', fields: [{ label: 'Name', value: result.deleted.name }, { label: 'Tasks moved', value: String(result.moved) }] }));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
+    taskCmd.command('move <id>')
+        .description('move a task to another list without changing its lifecycle')
+        .requiredOption('--list <name>', 'destination task list')
+        .option('--json', 'JSON output')
+        .action(async (id, opts) => {
+        try {
+            const task = await taskRoomService().moveTask({ actor: { kind: 'local_control', surface: 'cli' }, taskId: id, list: opts.list });
+            if (opts.json) {
+                console.log(JSON.stringify({ schema_version: 1, task }, null, 2));
+                return;
+            }
+            console.log(taskActionMarkdown('Task moved', task));
+        }
+        catch (e) {
+            if (opts.json)
+                die(e);
+            dieTaskRoom(e);
+        }
+    });
     taskCmd.command('show <id>')
         .description('show task details')
         .option('--json', 'JSON output')

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

@@ -0,0 +1,19 @@
+import type { TaskListRecord } from './types.js';
+export declare const DEFAULT_TASK_LIST_ID = "default";
+export declare const TASK_LIST_NAME_MAX_CODE_POINTS = 64;
+export declare class TaskListError extends Error {
+    readonly code: 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'list_not_found' | 'default_immutable' | 'destination_required' | 'same_destination';
+    constructor(code: 'invalid_name' | 'duplicate_name' | 'reserved_name' | 'list_not_found' | 'default_immutable' | 'destination_required' | 'same_destination', message: string);
+}
+export declare const taskListsPath: () => string;
+export declare const taskListsLockPath: () => string;
+export declare const withTaskListsLock: <T>(fn: () => T | Promise<T>) => Promise<T>;
+export declare function normalizeTaskListName(input: string): string;
+export declare function readTaskLists(): TaskListRecord[];
+export declare function resolveTaskList(name: string, lists?: TaskListRecord[]): TaskListRecord;
+/** Caller must hold withTaskListsLock. */
+export declare function createTaskListLocked(name: string): TaskListRecord;
+/** Caller must hold withTaskListsLock. */
+export declare function renameTaskListLocked(currentName: string, nextName: string): TaskListRecord;
+/** Caller must hold withTaskListsLock. */
+export declare function deleteTaskListRecordLocked(listId: string): void;

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

@@ -0,0 +1,96 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { replaceFileAtomically, withFileLock } from '../atomic-file.js';
+import { stateRoot } from '../paths.js';
+export const DEFAULT_TASK_LIST_ID = 'default';
+export const TASK_LIST_NAME_MAX_CODE_POINTS = 64;
+const CREATED_AT = '1970-01-01T00:00:00.000Z';
+export class TaskListError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = 'TaskListError';
+    }
+}
+export const taskListsPath = () => join(stateRoot(), 'task-lists.json');
+export const taskListsLockPath = () => join(stateRoot(), 'task-lists.lock');
+export const withTaskListsLock = (fn) => withFileLock(taskListsLockPath(), fn);
+const defaultList = () => ({
+    list_id: DEFAULT_TASK_LIST_ID, name: 'default', built_in: true, created_at: CREATED_AT,
+});
+const compareNames = (a, b) => {
+    if (a.list_id === DEFAULT_TASK_LIST_ID)
+        return b.list_id === DEFAULT_TASK_LIST_ID ? 0 : -1;
+    if (b.list_id === DEFAULT_TASK_LIST_ID)
+        return 1;
+    return a.name < b.name ? -1 : a.name > b.name ? 1 : a.list_id.localeCompare(b.list_id);
+};
+export function normalizeTaskListName(input) {
+    if (typeof input !== 'string')
+        throw new TaskListError('invalid_name', 'list name must be a string');
+    const normalized = input.normalize('NFC');
+    if (normalized.trim() !== normalized || normalized.length === 0)
+        throw new TaskListError('invalid_name', 'list name must be non-empty with no leading or trailing whitespace');
+    if ([...normalized].length > TASK_LIST_NAME_MAX_CODE_POINTS)
+        throw new TaskListError('invalid_name', `list name must be at most ${TASK_LIST_NAME_MAX_CODE_POINTS} Unicode code points`);
+    if (/[\p{Cc}\p{Cf}\/\\]/u.test(normalized))
+        throw new TaskListError('invalid_name', 'list name contains a forbidden control, format, or path character');
+    return normalized;
+}
+export function readTaskLists() {
+    const path = taskListsPath();
+    if (!existsSync(path))
+        return [defaultList()];
+    const parsed = JSON.parse(readFileSync(path, 'utf8'));
+    if (parsed.version !== 1 || !Array.isArray(parsed.lists))
+        throw new Error('invalid task list registry');
+    const custom = parsed.lists.filter(item => item.list_id !== DEFAULT_TASK_LIST_ID);
+    return [defaultList(), ...custom].sort(compareNames);
+}
+function writeTaskLists(lists) {
+    const custom = lists.filter(item => item.list_id !== DEFAULT_TASK_LIST_ID).sort(compareNames);
+    replaceFileAtomically(taskListsPath(), JSON.stringify({ version: 1, lists: custom }, null, 2) + '\n');
+}
+export function resolveTaskList(name, lists = readTaskLists()) {
+    const normalized = normalizeTaskListName(name);
+    const found = lists.find(item => item.name === normalized);
+    if (!found)
+        throw new TaskListError('list_not_found', `task list not found: ${normalized}`);
+    return found;
+}
+/** Caller must hold withTaskListsLock. */
+export function createTaskListLocked(name) {
+    const normalized = normalizeTaskListName(name);
+    if (normalized === 'default')
+        throw new TaskListError('reserved_name', "'default' is a reserved built-in list");
+    const lists = readTaskLists();
+    if (lists.some(item => item.name === normalized))
+        throw new TaskListError('duplicate_name', `task list already exists: ${normalized}`);
+    const record = {
+        list_id: `list_${randomUUID().replace(/-/g, '')}`, name: normalized,
+        built_in: false, created_at: new Date().toISOString(),
+    };
+    writeTaskLists([...lists, record]);
+    return record;
+}
+/** Caller must hold withTaskListsLock. */
+export function renameTaskListLocked(currentName, nextName) {
+    const lists = readTaskLists();
+    const current = resolveTaskList(currentName, lists);
+    if (current.built_in)
+        throw new TaskListError('default_immutable', "the 'default' list cannot be renamed");
+    const normalized = normalizeTaskListName(nextName);
+    if (normalized === 'default')
+        throw new TaskListError('reserved_name', "'default' is a reserved built-in list");
+    if (lists.some(item => item.list_id !== current.list_id && item.name === normalized))
+        throw new TaskListError('duplicate_name', `task list already exists: ${normalized}`);
+    const renamed = { ...current, name: normalized };
+    writeTaskLists(lists.map(item => item.list_id === current.list_id ? renamed : item));
+    return renamed;
+}
+/** Caller must hold withTaskListsLock. */
+export function deleteTaskListRecordLocked(listId) {
+    writeTaskLists(readTaskLists().filter(item => item.list_id !== listId));
+}

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

@@ -12,12 +12,15 @@ export interface CreateTaskInput {
     start?: boolean;
     no_room?: boolean;
     room_id?: string;
+    listId?: string;
 }
 export declare function createTask(input: CreateTaskInput): TaskRecord;
 export declare function getTask(id: string): TaskRecord;
 export declare function listTasks(filter?: {
     state?: TaskState | TaskState[];
+    listId?: string;
 }): TaskRecord[];
+export declare function moveTaskToList(id: string, listId: string): TaskRecord;
 export declare function findByIdempotencyKey(key: string): TaskRecord | undefined;
 export declare function startTask(id: string): TaskRecord;
 export declare function activateTask(id: string): TaskRecord;