@ours.network/fleet 1.0.5 → 1.1.0-nightly.10

package/dist/reports/tasks.js

@@ -0,0 +1,177 @@
+import { FleetReportService, ReportRegistry } from './service.js';
+import { createHash } from 'node:crypto';
+export const TASK_REPORT_MAX_RECORDS = 200;
+export const TASK_REPORT_MAX_TEXT = 2_000;
+const TASK_REPORT_BRIEF_PREVIEW = 240;
+const STATUS_LABEL = {
+    backlog: 'Backlog', provisioning: 'Provisioning', active: 'Active', review: 'Review',
+    done: 'Done', cancelled: 'Cancelled', failed: 'Failed',
+};
+const STATUS_TONE = {
+    backlog: 'neutral', provisioning: 'warning', active: 'good', review: 'warning',
+    done: 'good', cancelled: 'neutral', failed: 'bad',
+};
+const bounded = (value, limit = TASK_REPORT_MAX_TEXT) => {
+    if (value === undefined)
+        return null;
+    const points = [...value];
+    return points.length <= limit ? value
+        : `${points.slice(0, Math.max(0, limit - 34)).join('')}… [truncated from ${points.length} chars]`;
+};
+const briefPreview = (value) => {
+    const first = value?.split(/\r?\n/u).map(line => line.trim()).find(Boolean);
+    return bounded(first, TASK_REPORT_BRIEF_PREVIEW) ?? 'No brief supplied.';
+};
+const field = (label, value, tone, multiline = false) => ({
+    label, value, ...(tone ? { tone } : {}), ...(multiline ? { multiline: true } : {}),
+});
+const allowlistList = (list) => ({
+    list_id: list.list_id, name: bounded(list.name) ?? 'Unnamed list', built_in: list.built_in,
+});
+const allowlistTask = (task) => ({
+    task_id: task.task_id, list_id: task.list_id, list_name: bounded(task.list_name) ?? 'default',
+    title: bounded(task.title) ?? 'Untitled task', ...(task.brief === undefined ? {} : { brief: bounded(task.brief) ?? '' }),
+    state: task.state, ...(task.blocked ? { blocked: { reason: bounded(task.blocked.reason) ?? 'Blocked' } } : {}),
+    ...(task.room_id ? { room_id: bounded(task.room_id) ?? undefined } : {}),
+    ...(task.template ? { template: { name: bounded(task.template.name) ?? 'Unknown', version: task.template.version } } : {}),
+    member_roles: task.member_roles.map(member => ({ name: bounded(member.name) ?? 'Unknown', slot: bounded(member.slot) ?? 'Unknown', cowork_role: bounded(member.cowork_role) ?? 'Unknown' })),
+    origin: { type: task.origin.type }, created_at: task.created_at,
+    ...(task.started_at ? { started_at: task.started_at } : {}), ...(task.ended_at ? { ended_at: task.ended_at } : {}),
+    ...(task.outcome ? { outcome: { summary: bounded(task.outcome.summary) ?? undefined } } : {}),
+});
+function safeTask(task) {
+    const status = STATUS_LABEL[task.state];
+    const title = bounded(task.title) ?? 'Untitled task';
+    const brief = briefPreview(task.brief);
+    const groups = [
+        { title: '1. Identity and lifecycle', values: [
+                field('Task ID', task.task_id), field('Title', title),
+                field('Lifecycle status', status, STATUS_TONE[task.state]), field('List', task.list_name),
+                field('Blocked indicator', task.blocked ? bounded(task.blocked.reason) : 'No — unblocked', task.blocked ? 'warning' : undefined),
+            ] },
+        { title: '2. Task content', values: [
+                field('Brief', brief, undefined, true),
+                field('Detailed description', bounded(task.brief), undefined, true),
+            ] },
+        { title: '3. Work context', values: [
+                field('Room', task.room_id ?? null),
+                field('Template', task.template ? `${task.template.name}@${task.template.version}` : null),
+                field('Members and roles', task.member_roles.length
+                    ? bounded(task.member_roles.map(member => `${member.name} — ${member.slot} — ${member.cowork_role}`).join('\n')) : null, undefined, true),
+                field('Origin', task.origin.type),
+            ] },
+        { title: '4. Timeline and outcome', values: [
+                field('Created', task.created_at), field('Started', task.started_at ?? null), field('Ended', task.ended_at ?? null),
+                field('Terminal outcome', bounded(task.outcome?.summary), undefined, true),
+            ] },
+    ];
+    return {
+        id: task.task_id, title, brief, status,
+        ...(task.blocked ? { blocked: bounded(task.blocked.reason) ?? 'Blocked' } : {}), updated: task.ended_at ?? task.started_at ?? task.created_at,
+        groups,
+    };
+}
+function presentTasksReport(input) {
+    const maxRecords = input.maxRecords ?? TASK_REPORT_MAX_RECORDS;
+    const includedLists = input.selectedList
+        ? input.lists.filter(list => list.name === input.selectedList) : input.lists;
+    let remaining = maxRecords;
+    const panels = includedLists.map(list => {
+        const all = input.tasks.filter(task => task.list_id === list.list_id);
+        const total = input.totalsByList?.[list.list_id] ?? all.length;
+        const shown = all.slice(0, remaining);
+        remaining -= shown.length;
+        return {
+            id: list.list_id, name: list.name, total, shown: shown.length,
+            description: shown.length === total ? `All ${total} tasks are included in source order.`
+                : `${shown.length} of ${total} tasks are included by the report bound; source order is preserved.`,
+            tasks: shown.map(safeTask),
+        };
+    });
+    const defaultList = includedLists.find(list => list.name === input.selectedList)?.list_id
+        ?? includedLists.find(list => list.built_in)?.list_id ?? includedLists[0]?.list_id ?? 'default';
+    const section = {
+        kind: 'task-navigator', id: 'task-lists', title: 'Fleet task lists',
+        description: 'One read-only task report shared by task and list commands.',
+        lists: panels.map(panel => ({ id: panel.id, name: panel.name, count: panel.total,
+            blocked: panel.tasks.filter(task => task.blocked).length })), defaultList, panels,
+    };
+    return {
+        schemaVersion: 1, reportKind: 'tasks', title: 'Fleet task lists',
+        description: section.description, generatedAt: input.generatedAt,
+        source: input.source ?? { name: 'ours-fleet', version: '1' },
+        filters: { ...(input.selectedList ? { list: input.selectedList } : {}), ...(input.state ? { state: input.state } : {}) },
+        observedAt: input.observedAt ? { tasks: input.observedAt } : {}, unavailable: [], sections: [section],
+    };
+}
+export function buildTasksReport(input) {
+    return presentTasksReport({ ...input, lists: input.lists.map(allowlistList), tasks: input.tasks.map(allowlistTask) });
+}
+export async function createTasksReport(input) {
+    const request = {
+        kind: 'tasks', viewer: input.viewer,
+        ...(input.state ? { state: input.state } : {}),
+        ...(input.selectedList ? { list: input.selectedList } : {}),
+    };
+    const registry = new ReportRegistry().register({
+        kind: 'tasks', maxRecords: TASK_REPORT_MAX_RECORDS,
+        validate: (candidate) => candidate.kind === 'tasks',
+        resourceId: () => undefined,
+        present: (candidate, snapshot, generatedAt) => presentTasksReport({
+            ...snapshot.data, generatedAt, observedAt: snapshot.observedAt.tasks, source: input.source,
+            selectedList: candidate.list, state: candidate.state,
+            maxRecords: TASK_REPORT_MAX_RECORDS,
+        }),
+    });
+    const provider = {
+        surface: input.viewer.surface,
+        collect: async (_request, limits) => {
+            const data = await input.collect(limits);
+            const observedAt = new Date().toISOString();
+            const total = data.tasks.length;
+            const tasks = data.tasks.slice(0, limits.maxRecords).map(allowlistTask);
+            const totalsByList = data.tasks.reduce((totals, task) => {
+                totals[task.list_id] = (totals[task.list_id] ?? 0) + 1;
+                return totals;
+            }, {});
+            return { data: { lists: data.lists.map(allowlistList), tasks, totalsByList }, observedAt: { tasks: observedAt }, unavailable: [], stale: [],
+                bounds: { shown: tasks.length, total, truncated: total > tasks.length } };
+        },
+    };
+    return new FleetReportService(registry, input.maxBytes)
+        .create(request, { provider, generatedAt: input.generatedAt ?? new Date().toISOString() });
+}
+export async function createTaskReport(input) {
+    const request = { kind: 'task', viewer: input.viewer, taskId: input.taskId };
+    const resourceSlug = input.taskId.toLowerCase().replace(/[^a-z0-9_-]+/gu, '-').replace(/^-+|-+$/gu, '').slice(0, 68) || 'task';
+    const resourceName = `${resourceSlug}-${createHash('sha256').update(input.taskId).digest('hex').slice(0, 10)}`;
+    const registry = new ReportRegistry().register({
+        kind: 'task', maxRecords: 1,
+        validate: (candidate) => candidate.kind === 'task'
+            && typeof candidate.taskId === 'string' && candidate.taskId.length > 0 && candidate.taskId.length <= 200,
+        resourceId: () => resourceName,
+        present: (candidate, snapshot, generatedAt) => {
+            const task = snapshot.data;
+            const model = presentTasksReport({
+                lists: [{ list_id: task.list_id, name: task.list_name, built_in: task.list_id === 'default' }],
+                tasks: [task], generatedAt, observedAt: snapshot.observedAt.tasks, source: input.source,
+                selectedList: task.list_name, maxRecords: 1,
+            });
+            return { ...model, reportKind: 'task', title: `Task — ${task.title}`,
+                description: `Focused read-only task report for ${candidate.taskId}.`, filters: { task: candidate.taskId } };
+        },
+    });
+    const provider = {
+        surface: input.viewer.surface,
+        collect: async () => {
+            const collected = await input.collect();
+            if (collected.task_id !== input.taskId)
+                throw new Error('authorized task provider returned a mismatched resource');
+            const task = allowlistTask(collected);
+            return { data: task, observedAt: { tasks: new Date().toISOString() }, unavailable: [], stale: [],
+                bounds: { shown: 1, total: 1, truncated: false } };
+        },
+    };
+    return new FleetReportService(registry, input.maxBytes)
+        .create(request, { provider, generatedAt: input.generatedAt ?? new Date().toISOString() });
+}

package/dist/reports/types.d.ts

@@ -0,0 +1,315 @@
+export declare const REPORT_KINDS: readonly ["overview", "tasks", "task-lists", "task", "rooms", "room", "room-members", "agents", "agent-status", "templates", "template", "template-validation", "loops", "loop-status", "loop-validation", "watchdog", "watchdog-runs", "version", "config", "doctor", "manual"];
+export type ReportKind = typeof REPORT_KINDS[number];
+export type ReportTone = 'neutral' | 'good' | 'warning' | 'bad' | 'unknown';
+export interface ReportValue {
+    label: string;
+    value: string | number | boolean | null;
+    tone?: ReportTone;
+    /** Internal artifact link only; the renderer derives the fragment. */
+    target?: {
+        section: string;
+        id?: string;
+    };
+    multiline?: boolean;
+}
+export type ReportViewer = {
+    surface: 'cli';
+    authority: 'local-owner';
+} | {
+    surface: 'rest';
+    sessionId: string;
+    roomCids: string[];
+} | {
+    surface: 'messenger';
+    authenticatedCid: string;
+    roomCids: string[];
+};
+export type ReportRequest = {
+    kind: 'overview';
+    viewer: ReportViewer;
+} | {
+    kind: 'tasks';
+    viewer: ReportViewer;
+    state?: string;
+    list?: string;
+    groupByList?: boolean;
+} | {
+    kind: 'task-lists';
+    viewer: ReportViewer;
+} | {
+    kind: 'task';
+    viewer: ReportViewer;
+    taskId: string;
+} | {
+    kind: 'rooms';
+    viewer: ReportViewer;
+    state?: string;
+} | {
+    kind: 'room';
+    viewer: ReportViewer;
+    roomId: string;
+} | {
+    kind: 'room-members';
+    viewer: ReportViewer;
+    roomId: string;
+} | {
+    kind: 'agents';
+    viewer: ReportViewer;
+} | {
+    kind: 'agent-status';
+    viewer: ReportViewer;
+    role: string;
+} | {
+    kind: 'templates' | 'template-validation';
+    viewer: ReportViewer;
+} | {
+    kind: 'template';
+    viewer: ReportViewer;
+    name: string;
+} | {
+    kind: 'loops' | 'loop-validation';
+    viewer: ReportViewer;
+    role?: string;
+} | {
+    kind: 'loop-status';
+    viewer: ReportViewer;
+    role?: string;
+    loop?: string;
+} | {
+    kind: 'watchdog';
+    viewer: ReportViewer;
+    watchdog: string;
+    runId?: string;
+} | {
+    kind: 'watchdog-runs';
+    viewer: ReportViewer;
+    watchdog: string;
+} | {
+    kind: 'version' | 'config' | 'doctor' | 'manual';
+    viewer: ReportViewer;
+};
+export interface ReportTable {
+    kind: 'table';
+    id: string;
+    title: string;
+    description?: string;
+    columns: string[];
+    rows: Array<{
+        id?: string;
+        cells: ReportValue[];
+    }>;
+    empty?: string;
+    truncated?: {
+        shown: number;
+        total: number;
+    };
+}
+export interface ReportDetails {
+    kind: 'details';
+    id: string;
+    title: string;
+    description?: string;
+    values: ReportValue[];
+    paragraphs?: string[];
+}
+export interface ReportNotice {
+    kind: 'notice';
+    id: string;
+    title: string;
+    tone: ReportTone;
+    text: string;
+}
+export interface ReportCards {
+    kind: 'cards';
+    id: string;
+    title: string;
+    description?: string;
+    items: Array<{
+        id: string;
+        title: string;
+        subtitle?: string;
+        tone?: ReportTone;
+        values: ReportValue[];
+        paragraphs?: string[];
+        open?: boolean;
+    }>;
+    empty?: string;
+    truncated?: {
+        shown: number;
+        total: number;
+    };
+}
+export interface ReportRecords {
+    kind: 'records';
+    id: string;
+    title: string;
+    description?: string;
+    items: Array<{
+        id: string;
+        title: string;
+        subtitle: string;
+        tone?: ReportTone;
+        open?: boolean;
+        groups: Array<{
+            title: string;
+            values: ReportValue[];
+        }>;
+    }>;
+    empty?: string;
+    truncated?: {
+        shown: number;
+        total: number;
+    };
+}
+export interface ReportListBoard {
+    kind: 'list-board';
+    id: string;
+    title: string;
+    description?: string;
+    items: Array<{
+        id: string;
+        name: string;
+        builtIn: boolean;
+        createdAt: string | null;
+        counts: {
+            total: number;
+            active: number;
+            blocked: number;
+            terminal: number;
+        };
+        taskTarget: {
+            section: string;
+        };
+        recent: ReportValue[];
+        recentTotal: number;
+    }>;
+    truncated?: {
+        shown: number;
+        total: number;
+    };
+}
+export interface ReportInbox {
+    kind: 'inbox';
+    id: string;
+    title: string;
+    description: string;
+    lists: Array<{
+        id: string;
+        name: string;
+        count: number;
+        blocked: number;
+        selected: boolean;
+    }>;
+    selected: {
+        name: string;
+        total: number;
+        shown: number;
+    };
+    attention: Array<{
+        id: string;
+        title: string;
+        brief: string;
+        status: string;
+        blocker: string;
+        updated: string;
+        groups: Array<{
+            title: string;
+            values: ReportValue[];
+        }>;
+    }>;
+    active: Array<{
+        id: string;
+        title: string;
+        brief: string;
+        status: string;
+        updated: string;
+        groups: Array<{
+            title: string;
+            values: ReportValue[];
+        }>;
+    }>;
+    terminal: Array<{
+        id: string;
+        title: string;
+        brief: string;
+        status: string;
+        updated: string;
+        outcome: string;
+    }>;
+}
+export interface ReportTaskNavigator {
+    kind: 'task-navigator';
+    id: string;
+    title: string;
+    description: string;
+    lists: Array<{
+        id: string;
+        name: string;
+        count: number;
+        blocked: number;
+    }>;
+    defaultList: string;
+    panels: Array<{
+        id: string;
+        name: string;
+        total: number;
+        shown: number;
+        description: string;
+        tasks: Array<{
+            id: string;
+            title: string;
+            brief: string;
+            status: string;
+            blocked?: string;
+            updated: string;
+            groups: Array<{
+                title: string;
+                values: ReportValue[];
+            }>;
+        }>;
+    }>;
+}
+export type ReportSection = ReportTable | ReportDetails | ReportNotice | ReportCards | ReportRecords | ReportListBoard | ReportInbox | ReportTaskNavigator;
+export interface ReportViewModel {
+    schemaVersion: 1;
+    reportKind: ReportKind;
+    title: string;
+    description?: string;
+    generatedAt: string;
+    source: {
+        name: string;
+        version: string;
+        buildId?: string;
+    };
+    filters?: Record<string, string>;
+    observedAt?: Record<string, string>;
+    summary?: ReportValue[];
+    sections: ReportSection[];
+    unavailable?: string[];
+}
+export interface ReportArtifactMetadata {
+    schemaVersion: 1;
+    reportKind: ReportKind;
+    filename: string;
+    mediaType: 'text/html; charset=utf-8';
+    byteSize: number;
+    source: {
+        name: string;
+        version: string;
+        buildId?: string;
+    };
+    generatedAt: string;
+    filters: Record<string, string>;
+    truncated: boolean;
+    unavailable: string[];
+    observedAt: Record<string, string>;
+    truncation: Array<{
+        section: string;
+        shown: number;
+        total: number;
+    }>;
+}
+export interface ReportArtifact {
+    metadata: ReportArtifactMetadata;
+    html: string;
+}

package/dist/reports/types.js

@@ -0,0 +1,6 @@
+export const REPORT_KINDS = [
+    'overview', 'tasks', 'task-lists', 'task', 'rooms', 'room', 'room-members',
+    'agents', 'agent-status', 'templates', 'template', 'template-validation',
+    'loops', 'loop-status', 'loop-validation', 'watchdog', 'watchdog-runs',
+    'version', 'config', 'doctor', 'manual',
+];

package/dist/resolved-plan.d.ts

@@ -1,5 +1,6 @@
 import type { FleetConfig, ResolvedRole } from './config.js';
-export declare const RESOLVED_PLAN_SCHEMA_VERSION = 1;
+export declare const RESOLVED_PLAN_SCHEMA_VERSION = 2;
+export declare const redactSensitive: (value: unknown, key?: string) => unknown;
 /** Stable, secret-safe machine contract consumed by config JSON and spawn dry-run. */
 export declare function resolvedPlan(cfg: FleetConfig): Record<string, unknown>;
-export declare function resolvedRolePlan(role: ResolvedRole): Record<string, unknown>;
+export declare function resolvedRolePlan(role: ResolvedRole, manifestDir?: string): Record<string, unknown>;

package/dist/resolved-plan.js

@@ -1,8 +1,10 @@
 import { analyzeRolePermissions } from './permissions.js';
-export const RESOLVED_PLAN_SCHEMA_VERSION = 1;
+import { dirname, relative } from 'node:path';
+import { isSensitiveConfigKey } from './sensitive-config.js';
+export const RESOLVED_PLAN_SCHEMA_VERSION = 2;
 const sortedObject = (value) => Object.fromEntries(Object.entries(value).sort(([a], [b]) => a.localeCompare(b)));
-const redactSensitive = (value, key = '') => {
-    if (/(?:secret|token|password|authorization|api[_-]?key)/i.test(key))
+export const redactSensitive = (value, key = '') => {
+    if (isSensitiveConfigKey(key))
         return '<redacted>';
     if (Array.isArray(value))
         return value.map(item => redactSensitive(item));
@@ -14,12 +16,17 @@ const redactSensitive = (value, key = '') => {
 };
 /** Stable, secret-safe machine contract consumed by config JSON and spawn dry-run. */
 export function resolvedPlan(cfg) {
+    const manifestDir = dirname(cfg.files[0] ?? '.');
     return {
         schemaVersion: RESOLVED_PLAN_SCHEMA_VERSION,
+        configMode: cfg.configMode ?? 'split-v2',
         sourceFiles: [...cfg.files],
+        sourceDocuments: (cfg.sourceDocuments ?? []).map(document => ({
+            ...document, path: relative(manifestDir, document.path) || document.path,
+        })),
         startStaggerMs: cfg.startStaggerMs,
         diagnostics: cfg.diagnostics.map(diagnostic => ({ ...diagnostic })),
-        roles: cfg.roles.map(resolvedRolePlan),
+        roles: cfg.roles.map(role => resolvedRolePlan(role, manifestDir)),
         loops: cfg.loops.map(loop => sortedObject({
             name: loop.name, selectors: [...loop.selectors], roles: [...loop.roleNames],
             intervalMs: loop.intervalMs, initialDelayMs: loop.initialDelayMs, jitterMs: loop.jitterMs,
@@ -36,16 +43,25 @@ export function resolvedPlan(cfg) {
         })),
     };
 }
-export function resolvedRolePlan(role) {
+export function resolvedRolePlan(role, manifestDir = dirname(role.sourceFile)) {
     const analysis = analyzeRolePermissions(role);
     return {
         name: role.name,
         sourceFile: role.sourceFile,
+        references: Object.values(role.provenance ?? {}).flatMap(item => item.viaReference ? [item.viaReference] : [])
+            .filter((item, index, all) => all.findIndex(other => JSON.stringify(other) === JSON.stringify(item)) === index)
+            .sort((a, b) => a.kind.localeCompare(b.kind) || a.id.localeCompare(b.id)
+            || a.sourcePointer.localeCompare(b.sourcePointer)),
+        provenance: sortedObject(Object.fromEntries(Object.entries(role.provenance ?? {}).map(([field, item]) => [
+            field, { ...item, sourceFile: item.sourceKind === 'built-in'
+                    ? item.sourceFile : relative(manifestDir, item.sourceFile) || item.sourceFile },
+        ]))),
         identity: role.identity,
         harness: role.harness,
         session: role.session,
         sessionOptions: role.session_options ?? null,
         model: role.model ?? null,
+        effort: role.effort ?? null,
         modelChain: role.model_chain ?? null,
         cwd: role.cwd ?? null,
         coordinator: role.coordinator ?? null,