@ours.network/fleet 0.19.0-nightly.8 → 1.0.0

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

@@ -0,0 +1,35 @@
+import { withFileLock } from '../atomic-file.js';
+import type { CoworkAdapter } from './cowork-adapter.js';
+import type { RoomMemberSeat, RoomOrchestrationRecord } from './types.js';
+export interface RoomCloseDeps {
+    inspectMember?(seat: RoomMemberSeat): Promise<{
+        launchId: string;
+    }>;
+    requestStop?(role: string): Promise<void>;
+    waitForLivenessAbsent?(role: string, launchId: string): Promise<void>;
+    secureArchive?(role: string, launchId: string): Promise<string>;
+    removeIdentity?(seat: RoomMemberSeat): Promise<void>;
+    lock?: typeof withFileLock;
+}
+/** One forward-only room close saga shared by every Fleet entry point. */
+export declare function acceptManagedRoomClose(roomId: string): Promise<RoomOrchestrationRecord>;
+export declare function recordManagedRoomCloseError(roomId: string, error: string, recoveryHint: string): Promise<RoomOrchestrationRecord>;
+export declare function closeManagedRoom(input: {
+    roomId: string;
+    cowork: Pick<CoworkAdapter, 'closeRoom'>;
+    deps?: RoomCloseDeps;
+}): Promise<RoomOrchestrationRecord>;
+export interface ManagedRoomDeleteResult {
+    room_id: string;
+    deleted: true;
+}
+/** Remove retained state written by prerelease builds that stopped at `closed`. */
+export declare function deleteLegacyClosedRooms(input: {
+    cowork: Pick<CoworkAdapter, 'deleteRoom'>;
+}): Promise<string[]>;
+/** Retire live resources through the existing cursor, then delete retained state. */
+export declare function deleteManagedRoom(input: {
+    roomId: string;
+    cowork: Pick<CoworkAdapter, 'closeRoom' | 'deleteRoom'>;
+    deps?: RoomCloseDeps;
+}): Promise<ManagedRoomDeleteResult>;

package/dist/rooms-tasks/close.js

@@ -0,0 +1,182 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { attachOursClient } from '@ours.network/sdk/client';
+import { withFileLock } from '../atomic-file.js';
+import { agentDir, stateRoot } from '../paths.js';
+import { readTempSupervisor, secureStoppedTempArchive, stopTempSupervisor, tempSupervisorLiveness, } from '../temp-lifecycle.js';
+import { advanceMemberRetirement, advanceRoomClose, beginRoomClose, closeRoom, deleteRoomRecord, getRoomRecord, listRoomRecords, setRoomCloseError, } from './room-state.js';
+const CLOSE_LOCK_STALE_MS = 5 * 60_000;
+const STOP_POLLS = 50;
+const STOP_POLL_MS = 100;
+function roomCloseLockPath(roomId) {
+    return join(stateRoot(), 'locks', 'room-close', encodeURIComponent(roomId));
+}
+function errorText(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function exactMemberIdentity(seat) {
+    const dir = agentDir(seat.role_name, true);
+    const identityPath = join(dir, '.identity');
+    if (!existsSync(dir) || !existsSync(identityPath)) {
+        throw new Error(`room member '${seat.role_name}' has no live Fleet temp-state identity proof; refusing retirement`);
+    }
+    const identity = readFileSync(identityPath, 'utf8').trim();
+    if (identity !== seat.role_name) {
+        throw new Error(`room member '${seat.role_name}' temp state binds identity '${identity}'; refusing mismatched retirement`);
+    }
+}
+async function inspectMember(seat) {
+    exactMemberIdentity(seat);
+    const supervisor = readTempSupervisor(agentDir(seat.role_name, true));
+    if (!supervisor || supervisor.role !== seat.role_name) {
+        throw new Error(`room member '${seat.role_name}' has no exact Fleet supervisor ownership proof`);
+    }
+    return { launchId: supervisor.launchId };
+}
+async function waitForLivenessAbsent(role, launchId, lifecycleDeps = {}) {
+    const dir = agentDir(role, true);
+    const sleep = lifecycleDeps.sleep ?? ((ms) => new Promise(resolve => setTimeout(resolve, ms)));
+    for (let attempt = 0; attempt < STOP_POLLS; attempt++) {
+        if (!existsSync(dir))
+            return; // secureStoppedTempArchive proves the exact archive next.
+        const supervisor = readTempSupervisor(dir);
+        if (!supervisor || supervisor.role !== role || supervisor.launchId !== launchId) {
+            throw new Error(`temporary role '${role}' changed while waiting for launch ${launchId} to stop`);
+        }
+        const state = await tempSupervisorLiveness(dir, lifecycleDeps);
+        if (state === 'stopped')
+            return;
+        if (attempt < STOP_POLLS - 1)
+            await sleep(STOP_POLL_MS);
+    }
+    throw new Error(`temporary role '${role}' did not reach proven stopped liveness`);
+}
+async function withIdentityClient(work) {
+    const client = await attachOursClient({
+        env: process.env,
+        leaseToken: `ours-fleet-room-close-${process.pid}-${randomUUID()}`,
+        clientPid: process.pid,
+    });
+    try {
+        return await work(client);
+    }
+    finally {
+        await client.releaseLease().catch(() => { });
+    }
+}
+function listedIdentity(rows, name) {
+    return rows.find(row => row.name === name);
+}
+async function removeExactMemberIdentity(seat) {
+    await withIdentityClient(async (client) => {
+        const before = listedIdentity(await client.listIdentities(), seat.role_name);
+        if (!before)
+            return;
+        if (before.cid?.toLowerCase() !== seat.identity_cid.toLowerCase()) {
+            throw new Error(`room member '${seat.role_name}' identity CID mismatch: recorded ${seat.identity_cid}, found ${before.cid ?? 'none'}`);
+        }
+        try {
+            await client.removeIdentity({ name: seat.role_name });
+        }
+        catch (error) {
+            const code = error instanceof Error && error.name === 'OursError'
+                ? error.code
+                : undefined;
+            if (code !== 'NO_SUCH_IDENTITY')
+                throw error;
+            const after = listedIdentity(await client.listIdentities(), seat.role_name);
+            if (after)
+                throw error;
+        }
+        const after = listedIdentity(await client.listIdentities(), seat.role_name);
+        if (after) {
+            throw new Error(`room member '${seat.role_name}' identity still exists after remove_identity`);
+        }
+    });
+}
+async function retireMember(roomId, seat, deps) {
+    let room = getRoomRecord(roomId);
+    let current = room.member_seats.find(candidate => candidate.role_name === seat.role_name);
+    let retirement = current.retirement;
+    if (!retirement) {
+        const ownership = await (deps.inspectMember ?? inspectMember)(current);
+        room = advanceMemberRetirement(roomId, current.role_name, 'stop_requested', ownership.launchId);
+        current = room.member_seats.find(candidate => candidate.role_name === seat.role_name);
+        retirement = current.retirement;
+    }
+    if (retirement.phase === 'stop_requested') {
+        await (deps.requestStop ?? (async (role) => { await stopTempSupervisor(role); }))(current.role_name);
+        await (deps.waitForLivenessAbsent ?? waitForLivenessAbsent)(current.role_name, retirement.launch_id);
+        room = advanceMemberRetirement(roomId, current.role_name, 'liveness_absent', retirement.launch_id);
+        current = room.member_seats.find(candidate => candidate.role_name === seat.role_name);
+        retirement = current.retirement;
+    }
+    if (retirement.phase === 'liveness_absent') {
+        const archivePath = await (deps.secureArchive ?? secureStoppedTempArchive)(current.role_name, retirement.launch_id);
+        room = advanceMemberRetirement(roomId, current.role_name, 'archive_secured', retirement.launch_id, archivePath);
+        current = room.member_seats.find(candidate => candidate.role_name === seat.role_name);
+        retirement = current.retirement;
+    }
+    if (retirement.phase === 'archive_secured') {
+        await (deps.removeIdentity ?? removeExactMemberIdentity)(current);
+        advanceMemberRetirement(roomId, current.role_name, 'identity_absent', retirement.launch_id, retirement.archive_path);
+    }
+}
+/** One forward-only room close saga shared by every Fleet entry point. */
+export function acceptManagedRoomClose(roomId) {
+    return withFileLock(roomCloseLockPath(roomId), () => beginRoomClose(roomId), {}, CLOSE_LOCK_STALE_MS);
+}
+export function recordManagedRoomCloseError(roomId, error, recoveryHint) {
+    return withFileLock(roomCloseLockPath(roomId), () => setRoomCloseError(roomId, error, recoveryHint), {}, CLOSE_LOCK_STALE_MS);
+}
+export async function closeManagedRoom(input) {
+    const deps = input.deps ?? {};
+    const lock = deps.lock ?? withFileLock;
+    return lock(roomCloseLockPath(input.roomId), async () => {
+        let room = beginRoomClose(input.roomId);
+        if (room.state === 'closed')
+            return room;
+        try {
+            if (room.close?.phase === 'retire_members') {
+                for (const seat of room.member_seats) {
+                    if (seat.retirement?.phase === 'identity_absent')
+                        continue;
+                    await retireMember(input.roomId, seat, deps);
+                }
+                room = advanceRoomClose(input.roomId, 'close_cowork');
+            }
+            if (room.close?.phase === 'close_cowork') {
+                await input.cowork.closeRoom(input.roomId);
+            }
+            return closeRoom(input.roomId);
+        }
+        catch (error) {
+            setRoomCloseError(input.roomId, errorText(error), `Retry 'ours-fleet room delete ${input.roomId} ${input.roomId}' or run room recover.`);
+            throw error;
+        }
+    }, {}, CLOSE_LOCK_STALE_MS);
+}
+/** Remove retained state written by prerelease builds that stopped at `closed`. */
+export async function deleteLegacyClosedRooms(input) {
+    const deleted = [];
+    for (const room of listRoomRecords({ state: 'closed' })) {
+        await input.cowork.deleteRoom(room.room_id);
+        deleteRoomRecord(room.room_id);
+        deleted.push(room.room_id);
+    }
+    return deleted;
+}
+/** Retire live resources through the existing cursor, then delete retained state. */
+export async function deleteManagedRoom(input) {
+    await closeManagedRoom(input);
+    try {
+        await input.cowork.deleteRoom(input.roomId);
+    }
+    catch (error) {
+        setRoomCloseError(input.roomId, errorText(error), `Retry 'ours-fleet room delete ${input.roomId} ${input.roomId}' or run room recover.`);
+        throw error;
+    }
+    deleteRoomRecord(input.roomId);
+    return { room_id: input.roomId, deleted: true };
+}

package/dist/rooms-tasks/config.js

@@ -43,10 +43,13 @@ function resolveInvite(owner, vars, path) {
 export function validateRoomsConfig(raw, vars, path) {
     if (!isPlainObject(raw))
         throw new RoomsTasksConfigError(path, 'rooms: must be a mapping');
-    rejectUnknown(raw, RK, path, 'rooms');
-    const provider = raw.provider ?? 'cowork';
-    if (provider !== 'cowork')
-        throw new RoomsTasksConfigError(path, `rooms.provider: unsupported '${provider}'; allowed: cowork`);
+    // Migration-only input: provider selection was exposed before rooms shipped,
+    // even though cowork was the sole implementation. Accept the one historical
+    // value without carrying it into the current schema or resolved config.
+    if (Object.hasOwn(raw, 'provider') && raw.provider !== 'cowork')
+        throw new RoomsTasksConfigError(path, 'rooms.provider: only the legacy value \'cowork\' can be migrated; remove this field because ours-cowork is always used');
+    const { provider: _legacyProvider, ...current } = raw;
+    rejectUnknown(current, RK, path, 'rooms');
     let cowork;
     if (raw.cowork !== undefined) {
         if (!isPlainObject(raw.cowork))
@@ -83,7 +86,7 @@ export function validateRoomsConfig(raw, vars, path) {
             close_when_task_done: raw.defaults.close_when_task_done,
         };
     }
-    return { provider, cowork, owner, defaults, _invite: invite };
+    return { cowork, owner, defaults, _invite: invite };
 }
 export function validateTasksConfig(raw, path) {
     if (!isPlainObject(raw))

package/dist/rooms-tasks/cowork-adapter.d.ts

@@ -5,6 +5,7 @@
  * by Cowork's Unix socket and projects the response into orchestration data.
  */
 import type { Socket } from 'node:net';
+import type { RoomHistoryEvidence } from './types.js';
 export interface CoworkRoomCreateResult {
     room_id: string;
     identity_name: string;
@@ -32,6 +33,18 @@ export interface CoworkRoomInfo {
     seats: CoworkSeatInfo[];
     goal?: string;
     briefing?: string;
+    role_briefings: Record<string, CoworkRoleBriefingInfo>;
+}
+export interface CoworkRoleBriefingInfo {
+    role: string;
+    text: string;
+    version: number;
+    updated_at: string;
+}
+export interface CoworkHistoryPage {
+    records: RoomHistoryEvidence[];
+    raw_count: number;
+    next_after: number;
 }
 export interface CoworkAdapter {
     available(): Promise<boolean>;
@@ -50,9 +63,18 @@ export interface CoworkAdapter {
         role: string;
         min_accepts: number;
     }): Promise<CoworkInviteResult>;
+    setRoleBriefing(roomId: string, opts: {
+        role: string;
+        text: string;
+    }): Promise<CoworkRoleBriefingInfo>;
+    getHistory(roomId: string, opts?: {
+        after?: number;
+        limit?: number;
+    }): Promise<CoworkHistoryPage>;
     getRoom(roomId: string): Promise<CoworkRoomInfo | undefined>;
     listRooms(): Promise<CoworkRoomInfo[]>;
     closeRoom(roomId: string): Promise<void>;
+    deleteRoom(roomId: string): Promise<void>;
     getSeats(roomId: string): Promise<CoworkSeatInfo[]>;
     recoverRoom(roomId: string): Promise<CoworkRoomInfo>;
 }

package/dist/rooms-tasks/cowork-adapter.js

@@ -65,6 +65,17 @@ function projectRoom(value, operation) {
     if (!Array.isArray(room.seats))
         throw new CoworkProtocolError(operation, 'room.seats must be an array');
     const mission = room.mission === undefined ? undefined : object(room.mission, operation, 'room.mission');
+    const roleBriefings = room.role_briefings === undefined ? {} : object(room.role_briefings, operation, 'room.role_briefings');
+    const projectedBriefings = {};
+    for (const [role, value] of Object.entries(roleBriefings)) {
+        const briefing = object(value, operation, `room.role_briefings.${role}`);
+        projectedBriefings[role] = {
+            role,
+            text: text(briefing.text, operation, `room.role_briefings.${role}.text`),
+            version: positiveInteger(briefing.version, operation, `room.role_briefings.${role}.version`),
+            updated_at: string(briefing.updated_at, operation, `room.role_briefings.${role}.updated_at`),
+        };
+    }
     return {
         room_id: string(room.room_id, operation, 'room.room_id'),
         identity_name: string(room.identity_name, operation, 'room.identity_name'),
@@ -74,10 +85,82 @@ function projectRoom(value, operation) {
         room_name: string(room.room_name, operation, 'room.room_name'),
         state: roomState(room.state, operation),
         seats: room.seats.map((seat) => projectSeat(seat, operation)),
+        role_briefings: projectedBriefings,
         ...(typeof mission?.goal === 'string' ? { goal: mission.goal } : {}),
         ...(typeof mission?.briefing === 'string' ? { briefing: mission.briefing } : {}),
     };
 }
+function positiveInteger(value, operation, label) {
+    if (!Number.isSafeInteger(value) || value < 1)
+        throw new CoworkProtocolError(operation, `${label} must be a positive safe integer`);
+    return value;
+}
+function stringArray(value, operation, label) {
+    if (!Array.isArray(value))
+        throw new CoworkProtocolError(operation, `${label} must be an array`);
+    return value.map((entry, index) => string(entry, operation, `${label}[${index}]`));
+}
+function projectHistoryRecord(value) {
+    const operation = 'room.history';
+    const record = object(value, operation, 'record');
+    const kind = string(record.kind, operation, 'record.kind');
+    const common = {
+        seq: positiveInteger(record.seq, operation, 'record.seq'),
+        record_id: string(record.record_id, operation, 'record.record_id'),
+        at: string(record.at, operation, 'record.at'),
+    };
+    if (kind === 'message') {
+        if (record.category !== 'role_briefing' && record.category !== 'chat')
+            return undefined;
+        const author = object(record.author, operation, 'record.author');
+        return {
+            kind, ...common,
+            message_id: string(record.message_id, operation, 'record.message_id'),
+            category: record.category,
+            author: {
+                identity: string(author.identity, operation, 'record.author.identity'),
+                display_name: string(author.display_name, operation, 'record.author.display_name'),
+                role: string(author.role, operation, 'record.author.role'),
+            },
+            text: text(record.text, operation, 'record.text'),
+            recipient_identities: stringArray(record.recipient_identities, operation, 'record.recipient_identities'),
+            ...(record.briefing_role === undefined ? {} : {
+                briefing_role: string(record.briefing_role, operation, 'record.briefing_role'),
+            }),
+            ...(record.briefing_version === undefined ? {} : {
+                briefing_version: positiveInteger(record.briefing_version, operation, 'record.briefing_version'),
+            }),
+        };
+    }
+    if (kind === 'relay_intent') {
+        if (record.message_id === undefined)
+            return undefined;
+        return {
+            kind, ...common,
+            message_id: string(record.message_id, operation, 'record.message_id'),
+            recipient_identity: string(record.recipient_identity, operation, 'record.recipient_identity'),
+        };
+    }
+    if (kind === 'relay_result') {
+        if (record.message_id === undefined)
+            return undefined;
+        if (record.status !== 'queued' && record.status !== 'send_failed'
+            && record.status !== 'skipped_removed') {
+            throw new CoworkProtocolError(operation, 'record.status is invalid');
+        }
+        return {
+            kind, ...common,
+            intent_record_id: string(record.intent_record_id, operation, 'record.intent_record_id'),
+            message_id: string(record.message_id, operation, 'record.message_id'),
+            recipient_identity: string(record.recipient_identity, operation, 'record.recipient_identity'),
+            status: record.status,
+            ...(record.wire_id === undefined ? {} : {
+                wire_id: string(record.wire_id, operation, 'record.wire_id'),
+            }),
+        };
+    }
+    return undefined;
+}
 /** Resolve the same config/state inputs as ours-cowork and return its Unix socket. */
 export function resolveCoworkSocketPath(options = {}) {
     if (options.socketPath)
@@ -239,6 +322,36 @@ export function createCoworkAdapter(options = {}) {
                     ? invite.min_accepts : opts.min_accepts,
             };
         },
+        async setRoleBriefing(roomId, opts) {
+            const result = object(await call('room.briefing.role.set', {
+                room_id: roomId, role: opts.role, text: opts.text,
+            }), 'room.briefing.role.set', 'room');
+            const briefings = object(result.role_briefings, 'room.briefing.role.set', 'room.role_briefings');
+            const briefing = object(briefings[opts.role], 'room.briefing.role.set', `room.role_briefings.${opts.role}`);
+            return {
+                role: opts.role,
+                text: text(briefing.text, 'room.briefing.role.set', 'briefing.text'),
+                version: positiveInteger(briefing.version, 'room.briefing.role.set', 'briefing.version'),
+                updated_at: string(briefing.updated_at, 'room.briefing.role.set', 'briefing.updated_at'),
+            };
+        },
+        async getHistory(roomId, opts = {}) {
+            const result = await call('room.history', {
+                room_id: roomId,
+                ...(opts.after === undefined ? {} : { after: opts.after }),
+                ...(opts.limit === undefined ? {} : { limit: opts.limit }),
+                view: 'operator',
+            });
+            if (!Array.isArray(result))
+                throw new CoworkProtocolError('room.history', 'result must be an array');
+            const raw = result.map(record => object(record, 'room.history', 'record'));
+            const records = raw.flatMap(record => {
+                const projected = projectHistoryRecord(record);
+                return projected ? [projected] : [];
+            });
+            const next_after = raw.length === 0 ? (opts.after ?? 0) : Math.max(...raw.map(record => positiveInteger(record.seq, 'room.history', 'record.seq')));
+            return { records, raw_count: raw.length, next_after };
+        },
         async getRoom(roomId) {
             try {
                 return projectRoom(await call('room.show', { room_id: roomId }), 'room.show');
@@ -256,6 +369,9 @@ export function createCoworkAdapter(options = {}) {
             return result.map((room) => projectRoom(room, 'room.list'));
         },
         async closeRoom(roomId) { await call('room.close', { room_id: roomId }); },
+        async deleteRoom(roomId) {
+            await call('room.delete', { room_id: roomId, confirm: true });
+        },
         async getSeats(roomId) {
             const result = await call('room.participants', { room_id: roomId });
             if (!Array.isArray(result))

package/dist/rooms-tasks/external-worker.d.ts

@@ -0,0 +1,2 @@
+/** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
+export declare function launchFleetWorker(args: string[], operation: string, configPath?: string): Promise<void>;

package/dist/rooms-tasks/external-worker.js

@@ -0,0 +1,40 @@
+import { execFile, spawn } from 'node:child_process';
+import { randomUUID } from 'node:crypto';
+/** Launch a Fleet CLI operation outside the caller's supervisor/session lifecycle. */
+export function launchFleetWorker(args, operation, configPath) {
+    const cli = [process.argv[1], ...args, ...(configPath ? ['-c', configPath] : [])];
+    const inheritedKeys = [
+        'HOME', 'PATH', 'XDG_RUNTIME_DIR', 'OURS_FLEET_HOME', 'OURS_CONFIG',
+        'OURS_PORT', 'OURS_STATE_DIR', 'OURS_API_TOKEN', 'OURS_COWORK_CONFIG',
+    ];
+    const inherited = inheritedKeys
+        .flatMap(key => process.env[key] === undefined ? [] : [`${key}=${process.env[key]}`]);
+    const suffix = randomUUID().slice(0, 8);
+    const safeOperation = operation.replace(/[^A-Za-z0-9_.-]/g, '-');
+    return new Promise((resolve, reject) => {
+        if (process.env.OURS_FLEET_SUPERVISOR !== 'none' && process.platform === 'linux') {
+            execFile('systemd-run', [
+                '--user', '--quiet', '--collect',
+                `--unit=ours-fleet-${safeOperation}-${suffix}`,
+                '--property=Type=exec', '--property=KillMode=control-group',
+                ...inherited.map(value => `--setenv=${value}`),
+                process.execPath, ...cli,
+            ], { timeout: 15_000 }, error => error ? reject(error) : resolve());
+            return;
+        }
+        if (process.env.OURS_FLEET_SUPERVISOR !== 'none' && process.platform === 'darwin') {
+            execFile('launchctl', [
+                'submit', '-l', `network.ours.fleet.${safeOperation}.${suffix}`, '--',
+                '/usr/bin/env', ...inherited, process.execPath, ...cli,
+            ], { timeout: 15_000 }, error => error ? reject(error) : resolve());
+            return;
+        }
+        const env = Object.fromEntries(inherited.map(value => {
+            const split = value.indexOf('=');
+            return [value.slice(0, split), value.slice(split + 1)];
+        }));
+        const child = spawn(process.execPath, cli, { detached: true, stdio: 'ignore', env });
+        child.once('error', reject);
+        child.once('spawn', () => { child.unref(); resolve(); });
+    });
+}

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

@@ -5,4 +5,6 @@ export * from './task-state.js';
 export * from './room-state.js';
 export * from './cowork-adapter.js';
 export { provisionMembers, cleanupMembers } from './provision.js';
+export { acceptManagedRoomClose, closeManagedRoom, deleteLegacyClosedRooms, deleteManagedRoom, recordManagedRoomCloseError, } from './close.js';
+export { acceptTaskTerminalIntent, recordTaskTerminalIntentError, settleTaskTerminalIntent, } from './terminal.js';
 export { registerTemplateCommands, registerTaskCommands, registerRoomCommands } from './cli.js';

package/dist/rooms-tasks/index.js

@@ -5,4 +5,6 @@ export * from './task-state.js';
 export * from './room-state.js';
 export * from './cowork-adapter.js';
 export { provisionMembers, cleanupMembers } from './provision.js';
+export { acceptManagedRoomClose, closeManagedRoom, deleteLegacyClosedRooms, deleteManagedRoom, recordManagedRoomCloseError, } from './close.js';
+export { acceptTaskTerminalIntent, recordTaskTerminalIntentError, settleTaskTerminalIntent, } from './terminal.js';
 export { registerTemplateCommands, registerTaskCommands, registerRoomCommands } from './cli.js';

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

@@ -0,0 +1,49 @@
+import type { RoomOrchestrationState, TaskState } from './types.js';
+export declare const MARKDOWN_MAX_CODE_POINTS = 3500;
+export declare const MARKDOWN_MAX_BYTES = 12000;
+export interface StatusPresentation {
+    icon: string;
+    word: string;
+}
+export type MarkdownField = {
+    label: string;
+    value: unknown;
+    kind?: 'prose' | 'code' | 'markdown';
+    multiline?: boolean;
+};
+export type MarkdownSection = {
+    heading?: string;
+    items?: unknown[];
+    markdownItems?: string[];
+    prose?: unknown;
+};
+export declare function withinMarkdownBounds(value: string): boolean;
+/** Escaped single-line prose suitable for a field or list item. */
+export declare function markdownProse(value: unknown): string;
+/** Escaped heading text. Newlines and heading/list syntax cannot escape the heading. */
+export declare function markdownHeading(value: unknown): string;
+/** Escaped multiline prose. Intended line breaks remain line breaks. */
+export declare function markdownMultiline(value: unknown): string;
+/** CommonMark code span with a delimiter longer than every run in the value. */
+export declare function markdownCode(value: unknown): string;
+export declare function taskStatus(value: TaskState | string): string;
+export declare function roomStatus(value: RoomOrchestrationState | string): string;
+export declare function renderMarkdownResult(input: {
+    icon: string;
+    title: string;
+    fields?: MarkdownField[];
+    sections?: MarkdownSection[];
+}): string;
+export declare function renderMarkdownList(input: {
+    icon: string;
+    title: string;
+    empty: string;
+    records: string[];
+}): string;
+export type FailureKind = 'usage' | 'not_found' | 'conflict' | 'state' | 'pending' | 'unexpected';
+export declare function renderMarkdownFailure(input: {
+    kind: FailureKind;
+    subject: string;
+    detail?: unknown;
+    action: string;
+}): string;