@ours.network/fleet 1.0.4 → 1.0.5

package/dist/docs.js

@@ -361,6 +361,25 @@ Messenger-bound results are capped at 3,500 Unicode code points and 12,000 UTF-8
 bytes with structural omission notices. \`--json\` bypasses this presentation layer
 and retains the versioned machine schema and serialization order.
 
+Every task belongs to a named list. The built-in \`default\` list always exists,
+and legacy tasks or create calls without \`--list\` resolve to it. Use \`task lists\`,
+\`task list-create <name>\`, \`task list-rename <name> <new-name>\`, and
+\`task list-delete <name> [--move-to <destination>]\` to manage lists. A non-empty
+list cannot be deleted without an explicit, different destination; Fleet moves
+the assignments and never deletes the tasks. \`task move <id> --list <name>\`
+changes only organizational metadata. \`task list --list <name>\` filters and
+\`--group-by-list --json\` returns deterministic groups.
+
+List names are NFC-normalized, case-sensitive, and limited to 64 Unicode code
+points. Leading/trailing whitespace, controls, format/path characters, normalized
+duplicates, and the reserved exact name \`default\` are rejected. The authenticated
+owner channel provides the matching \`/task\` subcommands, while authenticated web
+clients use \`/api/v1/task-lists\`, \`/api/v1/tasks\`, and
+\`/api/v1/tasks/:id/list\`; every adapter delegates to the same application service.
+Messenger's multiline command grammar treats surrounding whitespace on each
+value line as transport framing; the canonical value passed to the shared service
+is the trimmed line. CLI arguments and REST strings are passed verbatim.
+
 Older prerelease files with the exact legacy \`provider: cowork\` key under
 \`rooms:\` still load, but the key is ignored and omitted from resolved
 configuration. Remove it when editing the file. Any other legacy value is an
@@ -609,7 +628,6 @@ owner_channel:
     max_file_bytes: 10485760
     max_request_bytes: 20971520
     retention_ms: 86400000
-    allowed_mime: [application/pdf, text/plain, image/png, audio/ogg]
 \`\`\`
 
 Permanent role identities are also reconciled before launch. Fleet creates a
@@ -658,14 +676,18 @@ suppresses receipts, progress notices, or the final answer.
 
 Owner documents, images, and voice messages use the same authenticated sender
 and source-wire boundary. Fleet inspects body-free metadata first and rejects
-disabled, over-count, over-size, or disallowed-MIME requests before selective
+disabled, over-count, or over-size requests before selective
 retrieval. Unauthorized CIDs are never retrieved or answered. Reply-linked text
 and files from the same sender become one ordered request; a file-only wake also
 starts a turn. Retrieved bytes must match their structured size and SHA-256,
-their content signature must match the declared MIME, and symlinks or non-regular
-paths fail closed. Sanitized copies live only in a mode-0700 request directory as
+while MIME values, extensions, file categories, and declared-versus-detected mismatches
+remain report-only metadata. Symlinks or non-regular paths fail closed. Sanitized copies live only in a mode-0700 request directory as
 mode-0600 files and are removed after completion or bounded stale retention.
 
+The legacy \`attachments.allowed_mime\` key is accepted and ignored so existing
+configurations keep loading; it is omitted from resolved configuration and cannot
+affect admission.
+
 Voice prompts include a bounded transcript only when typed daemon metadata reports success.
 Failure or unavailability is explicit and preserves the private audio path as the
 input for direct review. Run \`ours config show --json\` and inspect \`sttConfigured\` without

package/dist/owner-channel/attachments.d.ts

@@ -55,13 +55,11 @@ export declare function parseRetrievedAttachments(raw: OursRetrievedFiles | unde
 export declare function validateAttachmentSelection(files: IncomingAttachment[], config: OwnerAttachmentConfig): string | undefined;
 /**
  * Managed-agent -> owner egress limits. This intentionally does not consult
- * `enabled` or `allowed_mime`: those are owner -> agent admission policy.
+ * `enabled`: that is owner -> agent admission policy.
  */
 export declare function validateAttachmentRelaySelection(files: IncomingAttachment[], config: OwnerAttachmentConfig): string | undefined;
 export declare function prepareAttachmentDirectory(root: string, requestId: string): Promise<string>;
-export declare function admitAttachments(files: RetrievedAttachment[], dir: string, config: OwnerAttachmentConfig, options?: {
-    mimePolicy?: 'strict' | 'report-only';
-}): Promise<AdmittedAttachment[]>;
+export declare function admitAttachments(files: RetrievedAttachment[], dir: string, config: OwnerAttachmentConfig): Promise<AdmittedAttachment[]>;
 /** Injectable short-write seam, so partial writes are provably handled. */
 export interface AttachmentWriteDeps {
     write?(handle: FileHandle, bytes: Uint8Array, offset: number): Promise<number>;

package/dist/owner-channel/attachments.js

@@ -94,16 +94,9 @@ function parseTranscription(value, wireId) {
             fileWireId: wireId,
         } };
 }
-// Voice notes ride "<base>; x-ours-kind=voice-message" verbatim end to end
-// (the recorder's real container varies: audio/webm Chrome/Android, audio/mp4
-// iOS Safari, audio/ogg fallback), so policy for voice messages applies to the
-// base container type. Ordinary files keep exact allowlist matching.
 function baseMime(mime) {
     return mime.split(';')[0].trim();
 }
-function policyMime(file) {
-    return file.kind === 'voice_message' ? baseMime(file.mime) : file.mime;
-}
 export function validateAttachmentSelection(files, config) {
     if (!config.enabled)
         return 'attachments are disabled for this owner channel';
@@ -111,11 +104,6 @@ export function validateAttachmentSelection(files, config) {
         return `the request exceeds the ${config.max_files_per_request}-file limit`;
     let total = 0;
     for (const file of files) {
-        const mime = policyMime(file);
-        if (file.kind === 'voice_message' && !mime.startsWith('audio/'))
-            return `voice-message MIME type ${file.mime || '(missing)'} is not an audio container`;
-        if (!config.allowed_mime.includes(mime))
-            return `MIME type ${file.mime || '(missing)'} is not allowed`;
         if (file.size > config.max_file_bytes)
             return `a file exceeds the ${config.max_file_bytes}-byte limit`;
         total += file.size;
@@ -126,7 +114,7 @@ export function validateAttachmentSelection(files, config) {
 }
 /**
  * Managed-agent -> owner egress limits. This intentionally does not consult
- * `enabled` or `allowed_mime`: those are owner -> agent admission policy.
+ * `enabled`: that is owner -> agent admission policy.
  */
 export function validateAttachmentRelaySelection(files, config) {
     if (files.length > config.max_files_per_request)
@@ -157,7 +145,7 @@ export async function prepareAttachmentDirectory(root, requestId) {
     await chmod(dir, 0o700);
     return dir;
 }
-export async function admitAttachments(files, dir, config, options = {}) {
+export async function admitAttachments(files, dir, config) {
     const admitted = [];
     let total = 0;
     for (let index = 0; index < files.length; index++) {
@@ -184,11 +172,8 @@ export async function admitAttachments(files, dir, config, options = {}) {
         total += bytes.length;
         if (total > config.max_request_bytes)
             throw new Error('retrieved attachments exceed the request size limit');
-        const declaredMime = policyMime(file);
-        const detectedMime = detectMime(bytes, declaredMime);
-        if ((options.mimePolicy ?? 'strict') === 'strict'
-            && !mimeCompatible(declaredMime, detectedMime))
-            throw new Error(`retrieved attachment content does not match declared MIME ${declaredMime}`);
+        const declaredMime = file.mime;
+        const detectedMime = detectMime(bytes, baseMime(declaredMime));
         const filename = sanitizeFilename(file.filename);
         const finalPath = join(dir, `${index + 1}-${file.wireId.slice(0, 12)}-${filename}`);
         const tmp = join(dir, `.${basename(finalPath)}.${randomUUID()}.tmp`);
@@ -417,6 +402,8 @@ export function sanitizeFilename(value) {
     return clean || 'attachment.bin';
 }
 function detectMime(bytes, declared) {
+    if (bytes.length === 0)
+        return 'application/octet-stream';
     if (bytes.subarray(0, 5).toString() === '%PDF-')
         return 'application/pdf';
     if (bytes.subarray(0, 8).equals(Buffer.from([137, 80, 78, 71, 13, 10, 26, 10])))
@@ -443,27 +430,7 @@ function detectMime(bytes, declared) {
         return 'application/x-cfb';
     const text = bytes.toString('utf8');
     if (!text.includes('\ufffd') && !/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/u.test(text)) {
-        if (declared === 'application/json') {
-            try {
-                JSON.parse(text);
-                return 'application/json';
-            }
-            catch { }
-        }
         return 'text/plain';
     }
     return 'application/octet-stream';
 }
-function mimeCompatible(declared, detected) {
-    if (declared === detected)
-        return true;
-    if (['audio/wav', 'audio/x-wav'].includes(declared) && detected === 'audio/wav')
-        return true;
-    if (detected === 'application/zip' && declared.startsWith('application/vnd.openxmlformats-officedocument.'))
-        return true;
-    if (detected === 'application/x-cfb' && [
-        'application/msword', 'application/vnd.ms-excel', 'application/vnd.ms-powerpoint',
-    ].includes(declared))
-        return true;
-    return false;
-}

package/dist/owner-channel/channel.js

@@ -2,7 +2,7 @@ import { createHash } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { mkdir, readFile, readdir, rm } from 'node:fs/promises';
 import { join } from 'node:path';
-import { DEFAULT_OWNER_ATTACHMENT_MIME, canonicalCid, } from '../config.js';
+import { canonicalCid } from '../config.js';
 import { replaceFileAtomically } from '../atomic-file.js';
 import { TaskRoomApplicationService } from '../application/task-room-service.js';
 import { RoleLifecycleService } from '../application/role-command-service.js';
@@ -109,7 +109,6 @@ export class OwnerChannel {
         this.attachmentConfig = options.config.attachments ?? {
             enabled: true, max_files_per_request: 4, max_file_bytes: 10 * 1024 * 1024,
             max_request_bytes: 20 * 1024 * 1024, retention_ms: 24 * 60 * 60 * 1_000,
-            allowed_mime: [...DEFAULT_OWNER_ATTACHMENT_MIME],
         };
         const integrity = this.authorizationIntegrity();
         if (!integrity.ok)
@@ -1018,6 +1017,20 @@ export class OwnerChannel {
                 actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId,
             }),
             listTasks: filter => new TaskRoomApplicationService(this.options.configPath).listTasks(filter),
+            groupedTasks: filter => new TaskRoomApplicationService(this.options.configPath).groupedTasks(filter),
+            listTaskLists: () => new TaskRoomApplicationService(this.options.configPath).listTaskLists(),
+            createTaskList: name => new TaskRoomApplicationService(this.options.configPath).createTaskList({
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, name,
+            }),
+            renameTaskList: (name, newName) => new TaskRoomApplicationService(this.options.configPath).renameTaskList({
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, name, newName,
+            }),
+            deleteTaskList: (name, destination) => new TaskRoomApplicationService(this.options.configPath).deleteTaskList({
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, name, destination,
+            }),
+            moveTask: (taskId, list) => new TaskRoomApplicationService(this.options.configPath).moveTask({
+                actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId, list,
+            }),
             getTask: taskId => new TaskRoomApplicationService(this.options.configPath).getTask(taskId),
             blockTask: (taskId, reason) => new TaskRoomApplicationService(this.options.configPath).blockTask({
                 actor: { kind: 'authenticated_owner', surface: 'messenger', cid: sender.id }, taskId, reason,
@@ -1349,7 +1362,7 @@ export class OwnerChannel {
             }
             const order = new Map(group.files.map((file, index) => [file.wireId, index]));
             retrieved.sort((a, b) => order.get(a.wireId) - order.get(b.wireId));
-            const admitted = await admitAttachments(retrieved, requestDir, this.attachmentConfig, { mimePolicy: 'report-only' });
+            const admitted = await admitAttachments(retrieved, requestDir, this.attachmentConfig);
             const digest = createHash('sha256').update(`managed-agent-attachment\0${handledWireIds.slice().sort().join('\0')}`).digest('hex');
             const sending = this.conversations.beginSend(route.contact, digest, Date.now(), 0, 'all');
             try {

package/dist/owner-channel/commands.d.ts

@@ -1,5 +1,5 @@
 import type { InterruptOutcome, SessionEvent, SessionSnapshot } from '../session/types.js';
-import type { RoomOrchestrationRecord, TaskOutcome, TaskRecord, TaskTerminalIntent } from '../rooms-tasks/types.js';
+import type { RoomOrchestrationRecord, TaskOutcome, TaskRecord, TaskTerminalIntent, TaskListRecord } from '../rooms-tasks/types.js';
 import { type OwnerCommentsState } from './notices.js';
 import type { CreateRoomRequest, CreateTaskRequest, TaskRoomApplicationService } from '../application/task-room-service.js';
 import type { TaskState } from '../rooms-tasks/types.js';
@@ -58,7 +58,24 @@ export interface OwnerCommandContext {
     startTask(taskId: string): Promise<TaskRecord>;
     listTasks(filter?: {
         state?: TaskState | TaskState[];
+        list?: string;
     }): TaskRecord[];
+    groupedTasks(filter?: {
+        state?: TaskState | TaskState[];
+        list?: string;
+    }): Array<{
+        list: TaskListRecord;
+        tasks: TaskRecord[];
+    }>;
+    listTaskLists(): TaskListRecord[];
+    createTaskList(name: string): Promise<TaskListRecord>;
+    renameTaskList(name: string, newName: string): Promise<TaskListRecord>;
+    deleteTaskList(name: string, destination?: string): Promise<{
+        deleted: TaskListRecord;
+        moved: number;
+        destination?: TaskListRecord;
+    }>;
+    moveTask(taskId: string, list: string): Promise<TaskRecord>;
     getTask(taskId: string): {
         task: TaskRecord;
         orchestration: RoomOrchestrationRecord | undefined;

package/dist/owner-channel/commands.js

@@ -5,12 +5,14 @@ import { TaskStateError } from '../rooms-tasks/task-state.js';
 import { markdownCode, markdownProse, renderMarkdownFailure, renderMarkdownList, renderMarkdownResult, roomStatus, taskStatus, } from '../rooms-tasks/markdown.js';
 import { OWNER_COMMENT_LABEL, ownerNotices } from './notices.js';
 import { TaskRoomApplicationError } from '../application/task-room-service.js';
+import { TaskListError } from '../rooms-tasks/task-lists.js';
 /** A malformed invocation; the dispatcher answers it with annotated help. */
 class OwnerCommandUsageError extends Error {
 }
 const MODEL_ID = /^[A-Za-z0-9][A-Za-z0-9._:-]{0,127}$/;
 const REPLY_MAX_CHARS = 3_500;
 const taskListRecord = (task) => `${taskStatus(task.state)} ${markdownCode(task.task_id)} — ${markdownProse(task.title)}`
+    + ` — List ${markdownCode(task.list_name ?? 'default')}`
     + (task.blocked ? ` — 🚧 Blocked: ${markdownProse(task.blocked.reason)}` : '');
 const roomListRecord = (room) => `${roomStatus(room.state)} ${markdownCode(room.room_id)} — ${markdownProse(room.room_name)}`
     + (room.task_id ? ` — Task ${markdownCode(room.task_id)}` : '');
@@ -35,6 +37,14 @@ function isKnownOwnerRoomState(message) {
     ].some(pattern => pattern.test(message));
 }
 function ownerTaskFailure(error) {
+    if (error instanceof TaskListError)
+        return {
+            kind: error.code === 'list_not_found' ? 'not_found'
+                : error.code === 'invalid_name' ? 'usage' : 'state',
+            detail: error.message,
+            action: error.code === 'list_not_found' ? 'Run /task lists to find a valid list.'
+                : 'Choose a valid list name or an explicit different destination.',
+        };
     if (error instanceof TaskStateError) {
         const missing = /^task not found: ([A-Za-z0-9_-]{1,128})$/u.exec(error.message);
         if (missing)
@@ -263,6 +273,7 @@ export const ownerCommands = [
                         { label: 'ID', value: t.task_id, kind: 'code' },
                         { label: 'Title', value: t.title },
                         { label: 'Status', value: taskStatus(t.state), kind: 'markdown' },
+                        { label: 'List', value: t.list_name ?? 'default', kind: 'code' },
                         ...(t.blocked ? [{ label: 'Blocked', value: t.blocked.reason }] : []),
                         ...(t.template ? [{ label: 'Template', value: `${t.template.name}@${t.template.version}`, kind: 'code' }] : []),
                         ...(t.room_id ? [{ label: 'Room', value: t.room_id, kind: 'code' }] : []),
@@ -280,12 +291,15 @@ export const ownerCommands = [
                         const tplFlag = rest.find(r => r.startsWith('--template='));
                         const template = tplFlag ? tplFlag.slice('--template='.length) : undefined;
                         const noRoom = rest.includes('--no-room');
-                        const titleParts = rest.filter(r => r !== '--backlog' && !r.startsWith('--template=') && r !== '--no-room');
+                        const listFlag = rest.find(r => r.startsWith('--list='));
+                        const list = listFlag?.slice('--list='.length);
+                        const titleParts = rest.filter(r => r !== '--backlog' && !r.startsWith('--template=')
+                            && !r.startsWith('--list=') && r !== '--no-room');
                         if (!titleParts.length)
                             throw new OwnerCommandUsageError('usage: /task create [--backlog] [--template=<name>|--no-room] <title>');
                         const t = await ctx.createTask({
                             title: titleParts.join(' '), origin: { type: 'owner_channel' },
-                            backlog, template, noRoom, brief: trailingLines,
+                            backlog, template, noRoom, brief: trailingLines, list,
                         });
                         await ctx.reply(taskAction('Task created', t, [
                             { label: 'Title', value: t.title },
@@ -295,7 +309,10 @@ export const ownerCommands = [
                         break;
                     }
                     case 'list': {
-                        const filter = rest[0];
+                        const listFlag = rest.find(r => r.startsWith('--list='));
+                        const list = trailingLines ?? listFlag?.slice('--list='.length);
+                        const grouped = rest.includes('--group-by-list');
+                        const filter = rest.find(r => !r.startsWith('--'));
                         const stateMap = {
                             backlog: 'backlog', active: 'active', blocked: 'active',
                             done: 'done', all: ['backlog', 'provisioning', 'active', 'review', 'done', 'cancelled', 'failed'],
@@ -303,7 +320,8 @@ export const ownerCommands = [
                         const stateFilter = filter && stateMap[filter]
                             ? { state: stateMap[filter] }
                             : undefined;
-                        const tasks = ctx.listTasks(stateFilter);
+                        const combined = { ...(stateFilter ?? {}), ...(list ? { list } : {}) };
+                        const tasks = ctx.listTasks(combined);
                         if (filter === 'blocked') {
                             const blocked = tasks.filter(t => t.blocked);
                             await ctx.reply(renderMarkdownList({
@@ -312,12 +330,63 @@ export const ownerCommands = [
                             }));
                             break;
                         }
+                        if (grouped) {
+                            const groups = ctx.groupedTasks(combined);
+                            await ctx.reply(groups.map(group => renderMarkdownList({
+                                icon: '📋', title: `Tasks — ${group.list.name}`, empty: 'No tasks found.',
+                                records: group.tasks.map(taskListRecord),
+                            })).join('\n\n'));
+                            break;
+                        }
                         await ctx.reply(renderMarkdownList({
                             icon: '📋', title: 'Tasks', empty: 'No tasks found.',
                             records: tasks.map(taskListRecord),
                         }));
                         break;
                     }
+                    case 'lists': {
+                        const lists = ctx.listTaskLists();
+                        await ctx.reply(renderMarkdownList({ icon: '📚', title: 'Task lists', empty: 'No task lists found.',
+                            records: lists.map(list => `${markdownCode(list.name)}${list.built_in ? ' — built-in' : ''}`) }));
+                        break;
+                    }
+                    case 'list-create': {
+                        const name = trailingLines ?? rest.join(' ');
+                        if (!name)
+                            throw new OwnerCommandUsageError('usage: /task list-create\n<name>');
+                        const list = await ctx.createTaskList(name);
+                        await ctx.reply(renderMarkdownResult({ icon: '📚', title: 'Task list created', fields: [{ label: 'Name', value: list.name }] }));
+                        break;
+                    }
+                    case 'list-rename': {
+                        const names = argLines.slice(1).map(line => line.trim()).filter(Boolean);
+                        const current = names.length === 2 ? names[0] : rest[0];
+                        const next = names.length === 2 ? names[1] : rest[1];
+                        if (!current || !next)
+                            throw new OwnerCommandUsageError('usage: /task list-rename\n<name>\n<new-name>');
+                        const list = await ctx.renameTaskList(current, next);
+                        await ctx.reply(renderMarkdownResult({ icon: '📚', title: 'Task list renamed', fields: [{ label: 'Name', value: list.name }] }));
+                        break;
+                    }
+                    case 'list-delete': {
+                        const names = argLines.slice(1).map(line => line.trim()).filter(Boolean);
+                        const name = names[0] ?? rest[0];
+                        const destination = names[1] ?? rest.find(r => r.startsWith('--move-to='))?.slice('--move-to='.length);
+                        if (!name)
+                            throw new OwnerCommandUsageError('usage: /task list-delete\n<name>\n[move-to-name]');
+                        const result = await ctx.deleteTaskList(name, destination);
+                        await ctx.reply(renderMarkdownResult({ icon: '🗑️', title: 'Task list deleted', fields: [
+                                { label: 'Name', value: result.deleted.name }, { label: 'Tasks moved', value: String(result.moved) },
+                            ] }));
+                        break;
+                    }
+                    case 'move': {
+                        const destination = trailingLines ?? rest.find(r => r.startsWith('--list='))?.slice('--list='.length);
+                        if (!rest[0] || !destination)
+                            throw new OwnerCommandUsageError('usage: /task move <id> --list=<name>');
+                        await showTask((await ctx.moveTask(rest[0], destination)).task_id);
+                        break;
+                    }
                     case 'show': {
                         if (!rest[0])
                             throw new OwnerCommandUsageError('usage: /task show <id>');

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;