@ours.network/fleet 0.19.0-nightly.2 → 0.19.0-nightly.4

package/dist/build-info.json

@@ -1,9 +1,9 @@
 {
-  "version": "0.19.0-nightly.2",
-  "buildId": "13880d55bd06",
-  "commit": "ccf83082de238e6dc8ddb1bc557d2b7ffc7e816f",
+  "version": "0.19.0-nightly.4",
+  "buildId": "27ab2ac6d2c0",
+  "commit": "0213a2667a2d24e14297f7364f42880997451742",
   "dirty": true,
-  "builtAt": "2026-08-23T08:33:08.792Z",
+  "builtAt": "2026-08-23T12:52:41.918Z",
   "capabilities": [
     "monitor.interrupt.after_tool"
   ]

package/dist/config.d.ts

@@ -170,6 +170,12 @@ export interface FleetConfig {
     tasks?: import('./rooms-tasks/types.js').TasksConfig;
     /** SHA-256 fingerprint of the resolved owner invite (never the invite itself). */
     ownerInviteFingerprint?: string;
+    /**
+     * Resolved owner invite for immediate private-IPC use only. This property is
+     * deliberately non-enumerable so config dumps and JSON output cannot expose
+     * the bearer credential.
+     */
+    ownerInvite?: string;
 }
 export declare class ConfigError extends Error {
 }

package/dist/config.js

@@ -276,6 +276,7 @@ export function loadConfig(configPath, options = {}) {
     // top-level (room_templates merge by name, last writer wins).
     let rooms;
     let ownerInviteFingerprint;
+    let ownerInvite;
     let roomTemplates;
     let tasks;
     for (const { file, doc } of docs) {
@@ -284,6 +285,7 @@ export function loadConfig(configPath, options = {}) {
                 throw new ConfigError(`rooms: defined in multiple files; last: ${file}`);
             const validated = validateRoomsConfig(deepSub(doc.rooms, vars), vars, file);
             ownerInviteFingerprint = validated._invite?.fingerprint;
+            ownerInvite = validated._invite?.value;
             const { _invite: _, ...clean } = validated;
             rooms = clean;
         }
@@ -297,11 +299,20 @@ export function loadConfig(configPath, options = {}) {
             tasks = validateTasksConfig(deepSub(doc.tasks, vars), file);
         }
     }
-    return {
+    const result = {
         roles, vars, defaults, files, startStaggerMs, diagnostics, watchdogs,
         loops: resolvedLoops.loops,
         rooms, roomTemplates, tasks, ownerInviteFingerprint,
     };
+    if (ownerInvite !== undefined) {
+        Object.defineProperty(result, 'ownerInvite', {
+            value: ownerInvite,
+            enumerable: false,
+            writable: false,
+            configurable: false,
+        });
+    }
+    return result;
 }
 /**
  * Canonical form of a 64-hex container ID for authorization decisions. Hex

package/dist/doctor.js

@@ -106,6 +106,126 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
                 ok: true,
                 detail: `warning: ${diagnostic.message}`,
             });
+    // ── Rooms/tasks checks (§5.3) ────────────────────────────────────────
+    if (loaded.ok && loaded.rooms) {
+        const rooms = loaded.rooms;
+        // Cowork socket reachability
+        const coworkConfig = rooms.cowork?.config;
+        try {
+            const { createCoworkAdapter } = await import('./rooms-tasks/cowork-adapter.js');
+            const adapter = createCoworkAdapter({ configPath: coworkConfig });
+            const reachable = await adapter.available();
+            checks.push({
+                name: 'cowork', ok: reachable,
+                detail: reachable
+                    ? 'management socket reachable'
+                    : `management socket unreachable${coworkConfig ? ` (config: ${coworkConfig})` : ''}`,
+            });
+        }
+        catch (e) {
+            checks.push({
+                name: 'cowork', ok: false,
+                detail: `management socket error${coworkConfig ? ` (config: ${coworkConfig})` : ''}: ${e?.message ?? e}`,
+            });
+        }
+        // Owner CID shape
+        const cidOk = /^[0-9a-fA-F]{64}$/.test(rooms.owner.expected_cid);
+        checks.push({
+            name: 'rooms: owner CID', ok: cidOk,
+            detail: cidOk ? 'valid 64-hex CID' : `invalid CID shape: ${rooms.owner.expected_cid.slice(0, 16)}...`,
+        });
+        // Invite presence (never content)
+        checks.push({
+            name: 'rooms: owner invite',
+            ok: !!loaded.ownerInviteFingerprint,
+            detail: loaded.ownerInviteFingerprint
+                ? `present (fingerprint: ${loaded.ownerInviteFingerprint.slice(0, 12)}...)`
+                : 'not configured — room owner attachment will use waiting_owner_invite',
+        });
+        // Template validity and referenced role validity
+        const { listTemplates, resolveTemplate } = await import('./rooms-tasks/templates.js');
+        const customs = loaded.roomTemplates ?? {};
+        const templates = listTemplates(customs);
+        const roleNames = new Set(roles.map(r => r.name));
+        for (const t of templates) {
+            const badRefs = t.members
+                .filter(m => m.role_ref && !roleNames.has(m.role_ref))
+                .map(m => m.role_ref);
+            if (badRefs.length) {
+                checks.push({
+                    name: `template: ${t.name}@${t.version}`,
+                    ok: true,
+                    detail: `warning: role_ref(s) ${badRefs.join(', ')} not found in configured roles`,
+                });
+            }
+        }
+        // Default template validity
+        const defaultTemplate = loaded.rooms.defaults?.template
+            ?? loaded.tasks?.default_room_template;
+        if (defaultTemplate) {
+            const resolved = resolveTemplate(defaultTemplate, customs);
+            checks.push({
+                name: 'rooms: default template',
+                ok: !!resolved,
+                detail: resolved
+                    ? `${resolved.name}@${resolved.version}`
+                    : `template '${defaultTemplate}' not found`,
+            });
+        }
+        // Shared-daemon selection coherence
+        if (rooms.cowork?.config) {
+            const { existsSync: exists } = await import('node:fs');
+            const configOk = exists(rooms.cowork.config);
+            checks.push({
+                name: 'rooms: cowork config', ok: configOk,
+                detail: configOk
+                    ? `cowork config at ${rooms.cowork.config}`
+                    : `cowork config not found: ${rooms.cowork.config}`,
+            });
+        }
+        // Hard prerelease capability check
+        try {
+            const { createCoworkAdapter } = await import('./rooms-tasks/cowork-adapter.js');
+            const adapter = createCoworkAdapter({ configPath: coworkConfig });
+            const roomList = await adapter.listRooms();
+            checks.push({
+                name: 'rooms: capability', ok: true,
+                detail: `cowork room management operational (${roomList.length} room(s))`,
+            });
+        }
+        catch (e) {
+            const msg = e?.message ?? String(e);
+            const isProto = msg.includes('protocol') || msg.includes('invalid');
+            checks.push({
+                name: 'rooms: capability', ok: false,
+                detail: isProto
+                    ? `cowork does not support room management protocol — upgrade ours-cowork to prerelease`
+                    : `room management check failed: ${msg}`,
+            });
+        }
+        // Stale task/room warnings
+        try {
+            const { listTasks } = await import('./rooms-tasks/task-state.js');
+            const { listRoomRecords } = await import('./rooms-tasks/room-state.js');
+            const tasks = listTasks();
+            const roomRecords = listRoomRecords();
+            const roomIds = new Set(roomRecords.map(r => r.room_id));
+            const taskIds = new Set(tasks.map(t => t.task_id));
+            const orphanedTasks = tasks.filter(t => t.room_id && !roomIds.has(t.room_id));
+            const orphanedRooms = roomRecords.filter(r => r.task_id && !taskIds.has(r.task_id));
+            if (orphanedTasks.length)
+                checks.push({
+                    name: 'rooms: stale tasks', ok: true,
+                    detail: `warning: ${orphanedTasks.length} task(s) reference missing rooms: ${orphanedTasks.map(t => t.task_id).join(', ')}`,
+                });
+            if (orphanedRooms.length)
+                checks.push({
+                    name: 'rooms: stale rooms', ok: true,
+                    detail: `warning: ${orphanedRooms.length} room(s) reference missing tasks: ${orphanedRooms.map(r => r.room_id).join(', ')}`,
+                });
+        }
+        catch { /* state dir may not exist yet */ }
+    }
     if (roles.length === 0 || roles.some(role => (role.session ?? 'tmux') === 'tmux')) {
         const tmux = await exec('tmux', ['-V']);
         checks.push({
@@ -405,7 +525,11 @@ export async function doctor(opts = {}, exec = realExec, platform = process.plat
 function loadConfigResult(configPath, yamlMode) {
     try {
         const cfg = loadConfig(configPath, { yamlMode });
-        return { ok: true, roles: cfg.roles, files: cfg.files, diagnostics: cfg.diagnostics };
+        return {
+            ok: true, roles: cfg.roles, files: cfg.files, diagnostics: cfg.diagnostics,
+            rooms: cfg.rooms, roomTemplates: cfg.roomTemplates, tasks: cfg.tasks,
+            ownerInviteFingerprint: cfg.ownerInviteFingerprint,
+        };
     }
     catch (e) {
         return { ok: false, error: e instanceof Error ? e.message : String(e) };

package/dist/owner-channel/commands.js

@@ -159,14 +159,20 @@ export const ownerCommands = [
         },
     },
     {
-        name: 'task', usage: '/task <id>',
-        summary: 'show task details',
+        name: 'task',
+        usage: '/task <create|list|show|start|block|unblock|review|done|cancel|recover> ...',
+        summary: 'task lifecycle subcommands',
         execute: async (ctx, args) => {
             if (!args)
-                throw new OwnerCommandUsageError('usage: /task <id>');
-            const { getTask } = await import('../rooms-tasks/task-state.js');
-            try {
-                const t = getTask(args.trim());
+                throw new OwnerCommandUsageError('usage: /task <subcommand> <id>');
+            const argLines = args.trim().split('\n');
+            const firstLineTokens = argLines[0].trim().split(/\s+/);
+            const sub = firstLineTokens[0];
+            const rest = firstLineTokens.slice(1);
+            const trailingLines = argLines.slice(1).join('\n').trim() || undefined;
+            const showTask = async (id) => {
+                const { getTask } = await import('../rooms-tasks/task-state.js');
+                const t = getTask(id);
                 const lines = [
                     `📋 Task: ${t.task_id}`,
                     `Title: ${t.title}`,
@@ -177,8 +183,157 @@ export const ownerCommands = [
                     `Created: ${t.created_at}`,
                 ];
                 await ctx.reply(lines.join('\n'));
+            };
+            try {
+                switch (sub) {
+                    case 'create': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task create [--backlog] [--template=<name>|--no-room] <title>');
+                        const backlog = rest.includes('--backlog');
+                        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');
+                        if (!titleParts.length)
+                            throw new OwnerCommandUsageError('usage: /task create [--backlog] [--template=<name>|--no-room] <title>');
+                        const { createTask } = await import('../rooms-tasks/task-state.js');
+                        const t = createTask({
+                            title: titleParts.join(' '),
+                            origin: { type: 'owner_channel' },
+                            start: !backlog,
+                            ...(template ? { template: { name: template, version: 1, content_hash: '' } } : {}),
+                            ...(noRoom ? { no_room: true } : {}),
+                            ...(trailingLines ? { brief: trailingLines } : {}),
+                        });
+                        const lines = [`Task ${t.task_id} created · ${t.state}`];
+                        if (template)
+                            lines.push(`Template: ${template}`);
+                        if (noRoom)
+                            lines.push('No room requested');
+                        await ctx.reply(lines.join('\n'));
+                        break;
+                    }
+                    case 'list': {
+                        const { listTasks } = await import('../rooms-tasks/task-state.js');
+                        const filter = rest[0];
+                        const stateMap = {
+                            backlog: 'backlog', active: 'active', blocked: 'active',
+                            done: 'done', all: ['backlog', 'provisioning', 'active', 'review', 'done', 'cancelled', 'failed'],
+                        };
+                        const stateFilter = filter && stateMap[filter]
+                            ? { state: stateMap[filter] }
+                            : undefined;
+                        const tasks = listTasks(stateFilter);
+                        if (filter === 'blocked') {
+                            const blocked = tasks.filter(t => t.blocked);
+                            if (!blocked.length) {
+                                await ctx.reply('📋 No blocked tasks.');
+                                break;
+                            }
+                            const lines = blocked.map(t => `${t.task_id}  ${t.state}  ${t.title}  [BLOCKED: ${t.blocked.reason}]`);
+                            await ctx.reply(tail(`📋 Blocked tasks:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+                            break;
+                        }
+                        if (!tasks.length) {
+                            await ctx.reply('📋 No tasks.');
+                            break;
+                        }
+                        const lines = tasks.map(t => `${t.task_id}  ${t.state}  ${t.title}${t.blocked ? ` [BLOCKED]` : ''}`);
+                        await ctx.reply(tail(`📋 Tasks:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+                        break;
+                    }
+                    case 'show': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task show <id>');
+                        await showTask(rest[0]);
+                        break;
+                    }
+                    case 'start': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task start <id>');
+                        const { startTask } = await import('../rooms-tasks/task-state.js');
+                        const t = startTask(rest[0]);
+                        await ctx.reply(`✅ Task ${t.task_id} → provisioning`);
+                        break;
+                    }
+                    case 'block': {
+                        if (!rest[0] || !rest[1])
+                            throw new OwnerCommandUsageError('usage: /task block <id> <reason>');
+                        const { blockTask } = await import('../rooms-tasks/task-state.js');
+                        const reason = rest.slice(1).join(' ');
+                        const t = blockTask(rest[0], reason);
+                        await ctx.reply(`🚧 Task ${t.task_id} blocked: ${reason}`);
+                        break;
+                    }
+                    case 'unblock': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task unblock <id>');
+                        const { unblockTask } = await import('../rooms-tasks/task-state.js');
+                        const t = unblockTask(rest[0]);
+                        await ctx.reply(`✅ Task ${t.task_id} unblocked`);
+                        break;
+                    }
+                    case 'review': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task review <id>');
+                        const { reviewTask } = await import('../rooms-tasks/task-state.js');
+                        const t = reviewTask(rest[0]);
+                        await ctx.reply(`📝 Task ${t.task_id} → review`);
+                        break;
+                    }
+                    case 'done': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task done <id> [summary]');
+                        const { completeTask } = await import('../rooms-tasks/task-state.js');
+                        const summary = rest.slice(1).join(' ') || undefined;
+                        const t = completeTask(rest[0], summary ? { summary } : undefined);
+                        await ctx.reply(`✅ Task ${t.task_id} → done`);
+                        break;
+                    }
+                    case 'cancel': {
+                        if (rest.length < 2 || rest[0] !== rest[1])
+                            throw new OwnerCommandUsageError('destructive: /task cancel <id> <id> — provide the task ID twice');
+                        const { cancelTask } = await import('../rooms-tasks/task-state.js');
+                        const t = cancelTask(rest[0]);
+                        await ctx.reply(`🗑️ Task ${t.task_id} → cancelled`);
+                        break;
+                    }
+                    case 'recover': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /task recover <id>');
+                        const { getTask } = await import('../rooms-tasks/task-state.js');
+                        const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
+                        const t = getTask(rest[0]);
+                        const room = t.room_id ? getRoomRecord(t.room_id) : undefined;
+                        const hints = [];
+                        if (t.state === 'provisioning' && room) {
+                            if (room.provisioning_detail === 'waiting_cowork')
+                                hints.push('Cowork socket unreachable');
+                            if (room.provisioning_detail === 'waiting_owner_invite')
+                                hints.push('Owner invite missing or invalid');
+                            if (room.provisioning_detail === 'owner_cid_mismatch')
+                                hints.push('Owner CID mismatch');
+                            if (room.provisioning_detail === 'member_failed')
+                                hints.push(`Member failed at step ${room.saga.step_index}`);
+                        }
+                        const lines = [`Task ${t.task_id} · ${t.state}`];
+                        if (room)
+                            lines.push(`Room ${room.room_id} · ${room.state} · saga: ${room.saga.phase}`);
+                        if (hints.length)
+                            lines.push(`Hints: ${hints.join('; ')}`);
+                        else
+                            lines.push('No automated recovery actions available.');
+                        await ctx.reply(lines.join('\n'));
+                        break;
+                    }
+                    default:
+                        // bare /task <id> → show
+                        await showTask(sub);
+                }
             }
             catch (e) {
+                if (e instanceof OwnerCommandUsageError)
+                    throw e;
                 await ctx.reply(`⚠️ ${e instanceof Error ? e.message : String(e)}`);
             }
         },
@@ -195,30 +350,125 @@ export const ownerCommands = [
         }),
     },
     {
-        name: 'room', usage: '/room <id>',
-        summary: 'show room details',
+        name: 'room',
+        usage: '/room <create|list|show|close|recover> ...',
+        summary: 'room lifecycle subcommands',
         execute: async (ctx, args) => {
             if (!args)
-                throw new OwnerCommandUsageError('usage: /room <id>');
-            const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
-            const r = getRoomRecord(args.trim());
-            if (!r)
-                return ctx.reply(`⚠️ room not found: ${args.trim()}`);
-            const lines = [
-                `🏠 Room: ${r.room_id}`,
-                `Name: ${r.room_name}`,
-                `State: ${r.state}`,
-                `Saga: ${r.saga.phase} (step ${r.saga.step_index})`,
-                ...(r.task_id ? [`Task: ${r.task_id}`] : []),
-                ...(r.provisioning_detail ? [`Detail: ${r.provisioning_detail}`] : []),
-                ...(r.saga.error ? [`Error: ${r.saga.error}`] : []),
-                `Created: ${r.created_at}`,
-            ];
-            await ctx.reply(lines.join('\n'));
+                throw new OwnerCommandUsageError('usage: /room <subcommand> <id>');
+            const argLines = args.trim().split('\n');
+            const firstLineTokens = argLines[0].trim().split(/\s+/);
+            const sub = firstLineTokens[0];
+            const rest = firstLineTokens.slice(1);
+            const roomTrailingLines = argLines.slice(1).join('\n').trim() || undefined;
+            const showRoom = async (id) => {
+                const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
+                const r = getRoomRecord(id);
+                if (!r)
+                    return ctx.reply(`⚠️ room not found: ${id}`);
+                const lines = [
+                    `🏠 Room: ${r.room_id}`,
+                    `Name: ${r.room_name}`,
+                    `State: ${r.state}`,
+                    `Saga: ${r.saga.phase} (step ${r.saga.step_index})`,
+                    ...(r.task_id ? [`Task: ${r.task_id}`] : []),
+                    ...(r.provisioning_detail ? [`Detail: ${r.provisioning_detail}`] : []),
+                    ...(r.saga.error ? [`Error: ${r.saga.error}`] : []),
+                    `Created: ${r.created_at}`,
+                ];
+                await ctx.reply(lines.join('\n'));
+            };
+            try {
+                switch (sub) {
+                    case 'create': {
+                        const tplFlag = rest.find(r => r.startsWith('--template='));
+                        const templateName = tplFlag?.slice('--template='.length);
+                        const nameParts = rest.filter(r => !r.startsWith('--'));
+                        if (!nameParts.length)
+                            throw new OwnerCommandUsageError('usage: /room create --template=<name> <room name>');
+                        const { randomUUID } = await import('node:crypto');
+                        const { createRoomRecord } = await import('../rooms-tasks/room-state.js');
+                        const { resolveTemplate, snapshotTemplate } = await import('../rooms-tasks/templates.js');
+                        let templateSnapshot;
+                        if (templateName) {
+                            const tpl = resolveTemplate(templateName, {});
+                            if (!tpl)
+                                throw new OwnerCommandUsageError(`unknown template: ${templateName}`);
+                            templateSnapshot = snapshotTemplate(tpl);
+                        }
+                        const r = createRoomRecord({
+                            room_id: randomUUID().replace(/-/g, '').slice(0, 16),
+                            room_name: nameParts.join(' '),
+                            ...(templateSnapshot ? { template_snapshot: templateSnapshot } : {}),
+                            ...(roomTrailingLines ? { goal: roomTrailingLines } : {}),
+                        });
+                        const lines = [`🏠 Room ${r.room_id} created · ${r.state}`];
+                        if (templateName)
+                            lines.push(`Template: ${templateName}`);
+                        await ctx.reply(lines.join('\n'));
+                        break;
+                    }
+                    case 'list': {
+                        const { listRoomRecords } = await import('../rooms-tasks/room-state.js');
+                        const filter = rest[0];
+                        let rooms = listRoomRecords();
+                        if (filter === 'active')
+                            rooms = rooms.filter(r => r.state === 'active');
+                        if (!rooms.length) {
+                            await ctx.reply('🏠 No rooms.');
+                            break;
+                        }
+                        const lines = rooms.map(r => `${r.room_id}  ${r.state}  ${r.room_name}${r.task_id ? ` (task: ${r.task_id})` : ''}`);
+                        await ctx.reply(tail(`🏠 Rooms:\n${lines.join('\n')}`, REPLY_MAX_CHARS));
+                        break;
+                    }
+                    case 'show': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /room show <id>');
+                        await showRoom(rest[0]);
+                        break;
+                    }
+                    case 'close': {
+                        if (rest.length < 2 || rest[0] !== rest[1])
+                            throw new OwnerCommandUsageError('destructive: /room close <id> <id> — provide the room ID twice');
+                        const { closeRoom } = await import('../rooms-tasks/room-state.js');
+                        const r = closeRoom(rest[0]);
+                        await ctx.reply(`🔒 Room ${r.room_id} → closed`);
+                        break;
+                    }
+                    case 'recover': {
+                        if (!rest[0])
+                            throw new OwnerCommandUsageError('usage: /room recover <id>');
+                        const { getRoomRecord } = await import('../rooms-tasks/room-state.js');
+                        const r = getRoomRecord(rest[0]);
+                        if (!r) {
+                            await ctx.reply(`⚠️ room not found: ${rest[0]}`);
+                            break;
+                        }
+                        const lines = [`🏠 Room ${r.room_id} · ${r.state} · saga: ${r.saga.phase}`];
+                        if (r.saga.error)
+                            lines.push(`Error: ${r.saga.error}`);
+                        if (r.provisioning_detail)
+                            lines.push(`Detail: ${r.provisioning_detail}`);
+                        lines.push(r.saga.error ? 'Run `ours-fleet room recover` from CLI for full recovery.' : 'No recovery needed.');
+                        await ctx.reply(lines.join('\n'));
+                        break;
+                    }
+                    default:
+                        // bare /room <id> → show
+                        await showRoom(sub);
+                }
+            }
+            catch (e) {
+                if (e instanceof OwnerCommandUsageError)
+                    throw e;
+                await ctx.reply(`⚠️ ${e instanceof Error ? e.message : String(e)}`);
+            }
         },
     },
     {
-        name: 'templates', summary: 'list available room templates',
+        name: 'templates', aliases: ['template-list'],
+        summary: 'list available room templates',
         execute: noArgs('/templates', async (ctx) => {
             const { listTemplates } = await import('../rooms-tasks/templates.js');
             const templates = listTemplates({});
@@ -231,6 +481,55 @@ export const ownerCommands = [
             await ctx.reply(`📐 Templates:\n${lines.join('\n')}`);
         }),
     },
+    {
+        name: 'template',
+        usage: '/template <show|list> <name[@version]>',
+        summary: 'template subcommands (show, list)',
+        execute: async (ctx, args) => {
+            if (!args)
+                throw new OwnerCommandUsageError('usage: /template show <name[@version]>');
+            const parts = args.trim().split(/\s+/);
+            const sub = parts[0];
+            const showTemplate = async (nameStr) => {
+                const { resolveTemplate } = await import('../rooms-tasks/templates.js');
+                const t = resolveTemplate(nameStr, {});
+                if (!t)
+                    return ctx.reply(`⚠️ template not found: ${nameStr}`);
+                const lines = [
+                    `📐 Template: ${t.name}@${t.version}`,
+                    `Description: ${t.description}`,
+                    ...(t.builtin ? ['Source: built-in'] : []),
+                    ...(t.contract ? [`Contract: ${t.contract}`] : []),
+                    'Members:',
+                    ...t.members.map(m => `  ${m.slot} (${m.role}) ×${m.count} → role_ref: ${m.role_ref}`),
+                ];
+                await ctx.reply(lines.join('\n'));
+            };
+            switch (sub) {
+                case 'show': {
+                    if (!parts[1])
+                        throw new OwnerCommandUsageError('usage: /template show <name[@version]>');
+                    await showTemplate(parts[1]);
+                    break;
+                }
+                case 'list': {
+                    const { listTemplates } = await import('../rooms-tasks/templates.js');
+                    const templates = listTemplates({});
+                    if (!templates.length)
+                        return ctx.reply('📐 No templates.');
+                    const lines = templates.map(t => {
+                        const tag = t.builtin ? ' (built-in)' : '';
+                        return `${t.name}@${t.version}${tag}  ${t.description}`;
+                    });
+                    await ctx.reply(`📐 Templates:\n${lines.join('\n')}`);
+                    break;
+                }
+                default:
+                    // bare /template <name> → show
+                    await showTemplate(sub);
+            }
+        },
+    },
 ];
 /** Trimmed slash-prefixed text is a command attempt and is never forwarded. */
 export const isOwnerCommandText = (text) => text.trim().startsWith('/');