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

package/dist/monitor.js

@@ -1,7 +1,6 @@
 import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
-import { classifyFailureText } from './model-recovery.js';
 // Code constants rather than user configuration.
 const DEFAULT_PORT = 3050;
 // The daemon normally holds for 25s, but that value is operator-configurable
@@ -522,7 +521,11 @@ export class Monitor {
     }
     async deliver(pid, batch) {
         const line = formatNotificationLine(batch);
-        if (this.deps.delivery) {
+        if (!this.deps.delivery) {
+            this.degrade('delivery', 'structured agent-session delivery is unavailable');
+            return false;
+        }
+        {
             const result = await this.deps.delivery.submit(line, { interrupt: this.cfg.interrupt });
             if (!result.succeeded) {
                 // Name the reason: "refused" and "cancelled" are the agent's answer,
@@ -540,101 +543,6 @@ export class Monitor {
                 this.recordTurn('completed');
             return true;
         }
-        // Tmux exposes no authenticated tool lifecycle. `after_tool` therefore
-        // degrades to the existing non-cancelling injection path; never guess a
-        // boundary from pane text and never send C-c for this mode.
-        if (this.cfg.interrupt === true)
-            await this.deps.tmux.sendKey(this.name, 'C-c');
-        if (this.cfg.interrupt === 'after_tool')
-            this.degrade('safe-boundary', 'after_tool unsupported by tmux; using non-cancelling delivery');
-        const state = await this.awaitInjectable(pid);
-        if (state !== 'ready') {
-            if (state === 'offline')
-                this.degrade('offline', 'offline during delivery');
-            else if (state === 'modal')
-                this.degrade('modal', `modal wedge — pane held a dialog for ` +
-                    `${MODAL_GIVE_UP_MS / 1000}s, wake not injected`);
-            return false;
-        }
-        await this.clearComposer(); // start from an empty composer
-        await this.deps.tmux.sendText(this.name, line); // send-keys -l + Enter
-        let delivered = false;
-        // Verify submission for THIS line even if stop() arrives mid-flight: the text
-        // is already in the composer and we want it submitted (at-least-once). A truly
-        // dead pane makes safeCapture return '' ⇒ not-in-composer ⇒ breaks, no wasted Enter.
-        for (let i = 0; i < MAX_ENTER_RETRIES;) {
-            await this.deps.sleep(POST_VERIFY_MS);
-            const capture = await safeCapture(this.deps.tmux, this.name);
-            if (!capture.ok) {
-                this.degrade('delivery', 'capture failed during injection verification');
-                return false;
-            }
-            // A dialog can appear after the initial send. Never let a verification
-            // retry confirm it. Wait under the same bounded modal policy as initial
-            // injection, then re-capture immediately before considering Enter.
-            if (looksModal(capture.pane)) {
-                const state = await this.awaitInjectable(pid);
-                if (state === 'ready')
-                    continue;
-                if (state === 'offline')
-                    this.degrade('offline', 'offline during injection verification');
-                else if (state === 'modal')
-                    this.degrade('modal', `modal wedge during injection verification — ` +
-                        `no Enter sent for ${MODAL_GIVE_UP_MS / 1000}s`);
-                return false;
-            }
-            if (!stillInComposer(capture.pane, line)) {
-                delivered = true;
-                break;
-            }
-            await this.deps.tmux.sendKey(this.name, 'Enter');
-            i++;
-        }
-        if (!delivered) {
-            this.degrade('delivery', 'injection unverified');
-            return false;
-        }
-        this.recover('delivery', 'modal');
-        // The wake landed and a turn started; observe how that turn terminates so a
-        // refusal-wedge (every turn dies with `API Error:` while delivery stays green)
-        // becomes visible in `.monitor-status` instead of masquerading as armed (#19).
-        const recoveryTriggered = await this.observeTurnOutcome(pid);
-        return !recoveryTriggered;
-    }
-    /**
-     * Watch the pane until the just-triggered turn settles, then fold its outcome
-     * into the API-error streak and republish `.monitor-status`. A completed turn
-     * (or an inconclusive give-up) resets/keeps the streak; an `API Error:` tail
-     * grows it. Once the streak reaches the threshold the status degrades; a later
-     * completed turn flips it back to armed. Detection only — no remediation (#19).
-     */
-    async observeTurnOutcome(pid) {
-        for (let i = 0; i < TURN_OBSERVE_POLLS; i++) {
-            if (this.stopped)
-                return false; // shutting down — leave status
-            if (!this.deps.isAlive(pid) || !(await this.deps.tmux.has(this.name)))
-                return false; // loop marks offline
-            const capture = await safeCapture(this.deps.tmux, this.name);
-            if (!capture.ok) {
-                this.degrade('delivery', 'capture failed during turn observation');
-                return false;
-            }
-            if (looksApiError(capture.pane)) {
-                const evidence = classifyFailureText(capture.pane);
-                const recoveryTriggered = evidence
-                    ? this.deps.onFailureEvidence?.(evidence) === true
-                    : false;
-                this.recordTurn('api-error');
-                return recoveryTriggered;
-            }
-            if (!looksRunning(capture.pane)) {
-                this.recordTurn('completed');
-                return false;
-            }
-            await this.deps.sleep(TURN_OBSERVE_INTERVAL_MS);
-        }
-        this.recordTurn('inconclusive'); // still running at give-up: hold the streak, don't re-arm
-        return false;
     }
     /** Update the consecutive-API-error streak and derive `.monitor-status` from it. */
     recordTurn(outcome) {
@@ -658,41 +566,6 @@ export class Monitor {
      * the composer is cleared by hand. Best-effort: a dead pane just makes the keys
      * no-ops (delivery is still verified downstream).
      */
-    async clearComposer() {
-        for (const key of COMPOSER_CLEAR_KEYS)
-            await this.deps.tmux.sendKey(this.name, key);
-    }
-    /**
-     * Block until the console can accept input; classify offline/stopped/ready, or
-     * `modal` when the pane still looks modal after `MODAL_GIVE_UP_MS`. The bound is
-     * what keeps a modal from wedging delivery silently: we still never `Enter` into
-     * the dialog, but the give-up is reported instead of retried forever.
-     */
-    async awaitInjectable(pid) {
-        let modalWaits = 0;
-        for (;;) {
-            if (this.stopped)
-                return 'stopped';
-            if (!this.deps.isAlive(pid) || !(await this.deps.tmux.has(this.name)))
-                return 'offline';
-            const now = this.deps.now();
-            if (now < this.bootDeadline) {
-                await this.deps.sleep(this.bootDeadline - now);
-                continue;
-            }
-            const capture = await safeCapture(this.deps.tmux, this.name);
-            if (!capture.ok) {
-                this.degrade('delivery', 'capture failed while checking session readiness');
-                await this.deps.sleep(MODAL_RETRY_MS);
-                continue;
-            }
-            if (!looksModal(capture.pane))
-                return 'ready';
-            if (modalWaits++ >= MAX_MODAL_WAITS)
-                return 'modal';
-            await this.deps.sleep(MODAL_RETRY_MS);
-        }
-    }
     async doFetch(since, timeoutMs, timeoutKind) {
         const ctrl = new AbortController();
         this.currentAbort = ctrl;
@@ -820,12 +693,4 @@ export class Monitor {
 export function createMonitor(o) {
     return new Monitor(o);
 }
-async function safeCapture(tmux, name) {
-    try {
-        return { ok: true, pane: await tmux.capture(name) };
-    }
-    catch {
-        return { ok: false, pane: '' };
-    }
-}
 const msg = (e) => e?.message ?? String(e);

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.d.ts

@@ -1,5 +1,5 @@
 import { type OwnerChannelConfig } from '../config.js';
-import { type SessionHandle } from '../session/types.js';
+import { type AgentSession } from '../session/types.js';
 import { type OwnerFleetOps } from './commands.js';
 import type { ManagedFleetSpawnResult } from '../fleet-proxy.js';
 import { type OursOps } from './ours-client.js';
@@ -12,7 +12,7 @@ export interface OwnerChannelOptions {
     /** Harness id of the role (e.g. 'claude-code', 'codex'); gates which slash commands may be forwarded. */
     harness: string;
     config: OwnerChannelConfig;
-    session: SessionHandle;
+    session: AgentSession;
     stateDir: string;
     env?: Record<string, string>;
     log(line: string): void;

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>');