@ours.network/fleet 2.3.1 → 2.4.0-nightly.1

package/dist/channels/service.js

@@ -0,0 +1,88 @@
+import { FleetError } from '../application/errors.js';
+import { IdentityReadError } from './identity-reads.js';
+/**
+ * Owner-facing Channels queries over the durable projection. Served only
+ * behind the Fleet web Owner session; agents get no route to it.
+ */
+export class ChannelsService {
+    deps;
+    constructor(deps) {
+        this.deps = deps;
+    }
+    status() {
+        return { ready: this.deps.ready(), sources: this.deps.store.sourcesSummary() };
+    }
+    view(row) {
+        const root = this.deps.ownerRoot();
+        return { ...row, claimsOwnerRoot: !!root && row.claimedRoot?.rootCid === root };
+    }
+    list(options) {
+        let page;
+        try {
+            page = this.deps.store.list(options);
+        }
+        catch (error) {
+            throw new FleetError('invalid_request', error.message);
+        }
+        return { ...page, channels: page.channels.map(row => this.view(row)) };
+    }
+    /** The SSE snapshot: the first Recent page. */
+    snapshot() {
+        const page = this.deps.store.list({ limit: 50 });
+        return { ready: this.deps.ready(), channels: page.channels.map(row => this.view(row)), nextCursor: page.nextCursor };
+    }
+    get(cid) {
+        const found = this.deps.store.get(cid);
+        if (!found)
+            throw new FleetError('resource_not_found', 'no such channel');
+        return { channel: this.view(found.channel), perspectives: found.perspectives };
+    }
+    /**
+     * One perspective's own history with this contact; never a merged view, never consuming.
+     * Pinned to the source's CID and last observed daemon source generation; a response is
+     * released only while that same perspective is still current.
+     */
+    async history(contactCid, sourceCid, page) {
+        const contact = contactCid.toUpperCase(), source = sourceCid.toUpperCase();
+        const perspective = this.deps.store.hasPerspective(contact, source);
+        if (!perspective)
+            throw new FleetError('resource_not_found', 'that identity is not a perspective of this channel');
+        if (perspective.ended)
+            throw new FleetError('capability_unavailable', 'this perspective has ended; its history is no longer available');
+        let result;
+        try {
+            result = await this.deps.reader.history({
+                identity: perspective.name, expectedCid: source, peer_cid: contact,
+                ...(perspective.generation ? { expectedProducerGeneration: perspective.generation } : {}),
+                ...(page.before_seq !== undefined ? { before_seq: page.before_seq } : {}),
+                ...(page.limit !== undefined ? { limit: page.limit } : {}),
+            });
+        }
+        catch (error) {
+            if (error instanceof IdentityReadError) {
+                if (error.code === 'identity_not_found' || error.code === 'identity_mismatch') {
+                    void this.deps.indexer.sync();
+                    throw new FleetError('resource_not_found', 'this perspective is no longer available');
+                }
+                if (error.code === 'source_generation_changed') {
+                    // The daemon restarted under this perspective: re-observe it before paging again.
+                    this.deps.indexer.invalidate(source);
+                    throw new FleetError('conflict', 'the identity source changed; reload this history', { retryable: true });
+                }
+                if (error.code === 'source_changed')
+                    throw new FleetError('conflict', 'the identity changed during the read; retry', { retryable: true });
+                throw new FleetError('capability_unavailable', error.message);
+            }
+            throw error;
+        }
+        // The perspective may have ended, left or been replaced while the read was in flight.
+        const current = this.deps.store.hasPerspective(contact, source);
+        if (!current)
+            throw new FleetError('resource_not_found', 'this perspective is no longer available');
+        if (current.ended)
+            throw new FleetError('capability_unavailable', 'this perspective has ended; its history is no longer available');
+        if (current.name !== perspective.name || current.generation !== perspective.generation)
+            throw new FleetError('conflict', 'this perspective changed during the read; retry', { retryable: true });
+        return { ...result, perspective: { sourceCid: source, kind: current.kind, ...(current.roleId ? { roleId: current.roleId } : {}) } };
+    }
+}

package/dist/channels/sources.d.ts

@@ -0,0 +1,46 @@
+/**
+ * Who Channels reads (perspective sources) and which CIDs are never channels
+ * (the internal-exclusion set). Both come from local records only: a peer's
+ * claimed root never makes it internal, because root claims are not proven.
+ */
+export interface PerspectiveSource {
+    kind: 'owner' | 'agent';
+    /** Daemon identity name. */
+    name: string;
+    cid: string;
+    /** Fleet role id for agent sources (the "Open chat with agent" target). */
+    roleId?: string;
+    /** Released/retired/removed: kept as metadata only, never read again. */
+    ended: boolean;
+}
+export interface ChannelSources {
+    ownerCid: string;
+    rootCid?: string;
+    sources: PerspectiveSource[];
+    internal: Set<string>;
+}
+export interface DaemonIdentityRow {
+    name: string;
+    cid?: string;
+    kind?: string;
+}
+export interface AgentRecord {
+    name: string;
+    cid: string;
+    phase: string;
+}
+export declare const norm: (cid: string) => string;
+/**
+ * Retained supervisor journals (`private-ours/<binder>/state.json` and archived
+ * `retired-<instance>/state.json`). They exist for stopped agents too, so a
+ * stopped agent stays a perspective source; retired generations mark ended.
+ */
+export declare function readAgentRecords(privateRoot: string): AgentRecord[];
+export declare function resolveSources(input: {
+    ownerCid: string;
+    identities: DaemonIdentityRow[];
+    agents: AgentRecord[];
+    /** Fleet role id by daemon identity name, for roles this workspace defines. */
+    roleByIdentity: Map<string, string>;
+    roomCids: string[];
+}): ChannelSources;

package/dist/channels/sources.js

@@ -0,0 +1,68 @@
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { join } from 'node:path';
+const CID = /^[0-9a-f]{64}$/i;
+const ENDED_PHASES = new Set(['TERMINAL_INTENT', 'CLEANUP_PENDING', 'RELEASED', 'FAILED']);
+export const norm = (cid) => cid.toUpperCase();
+/**
+ * Retained supervisor journals (`private-ours/<binder>/state.json` and archived
+ * `retired-<instance>/state.json`). They exist for stopped agents too, so a
+ * stopped agent stays a perspective source; retired generations mark ended.
+ */
+export function readAgentRecords(privateRoot) {
+    if (!existsSync(privateRoot))
+        return [];
+    const records = [];
+    const read = (path, retired) => {
+        try {
+            const value = JSON.parse(readFileSync(path, 'utf8'));
+            if (typeof value.name !== 'string' || typeof value.cid !== 'string' || !CID.test(value.cid))
+                return;
+            records.push({ name: value.name, cid: norm(value.cid), phase: retired ? 'RELEASED' : String(value.phase ?? '') });
+        }
+        catch { /* missing or corrupt journal: not a source */ }
+    };
+    for (const entry of readdirSync(privateRoot, { withFileTypes: true })) {
+        if (!entry.isDirectory())
+            continue;
+        const dir = join(privateRoot, entry.name);
+        read(join(dir, 'state.json'), false);
+        for (const child of readdirSync(dir, { withFileTypes: true })) {
+            if (child.isDirectory() && child.name.startsWith('retired-'))
+                read(join(dir, child.name, 'state.json'), true);
+        }
+    }
+    return records;
+}
+export function resolveSources(input) {
+    const ownerCid = norm(input.ownerCid);
+    const live = new Map(input.identities.filter(row => row.cid && CID.test(row.cid)).map(row => [norm(row.cid), row]));
+    const rootRow = input.identities.find(row => row.kind === 'root' && row.cid && CID.test(row.cid));
+    const rootCid = rootRow ? norm(rootRow.cid) : undefined;
+    const internal = new Set([ownerCid]);
+    if (rootCid)
+        internal.add(rootCid);
+    for (const cid of input.roomCids)
+        if (CID.test(cid))
+            internal.add(norm(cid));
+    const sources = [];
+    const ownerRow = live.get(ownerCid);
+    if (ownerRow)
+        sources.push({ kind: 'owner', name: ownerRow.name, cid: ownerCid, ended: false });
+    // One source per agent CID: a live journal wins over retired generations.
+    const byCid = new Map();
+    for (const record of input.agents) {
+        internal.add(record.cid);
+        const prior = byCid.get(record.cid);
+        if (!prior || (ENDED_PHASES.has(prior.phase) && !ENDED_PHASES.has(record.phase)))
+            byCid.set(record.cid, record);
+    }
+    for (const record of byCid.values()) {
+        const roleId = input.roleByIdentity.get(record.name);
+        if (roleId === undefined || record.cid === ownerCid)
+            continue; // not a workspace role: excluded, not a perspective
+        const row = live.get(record.cid);
+        sources.push({ kind: 'agent', name: record.name, cid: record.cid, roleId,
+            ended: ENDED_PHASES.has(record.phase) || !row || row.name !== record.name });
+    }
+    return { ownerCid, ...(rootCid ? { rootCid } : {}), sources, internal };
+}

package/dist/channels/store.d.ts

@@ -0,0 +1,103 @@
+import type { PerspectiveSource } from './sources.js';
+/** One local identity's view of one external contact. Metadata only, never bodies. */
+export interface ChannelEdge {
+    contactCid: string;
+    contactName: string;
+    lastActivity: string;
+    rootCid?: string;
+    rootName?: string;
+    roleId?: string;
+}
+export interface ChannelPerspective {
+    sourceCid: string;
+    sourceName: string;
+    kind: 'owner' | 'agent';
+    roleId?: string;
+    ended: boolean;
+    stale: boolean;
+    contactName: string;
+    lastActivity: string;
+    claimedRoot?: {
+        rootCid: string;
+        rootName: string;
+        roleId: string;
+    };
+}
+export interface ChannelRow {
+    cid: string;
+    name: string;
+    lastActivity: string;
+    /** Present only when every perspective with a claim agrees. Signed claim, not verified. */
+    claimedRoot?: {
+        rootCid: string;
+        rootName: string;
+    };
+    conflictingRootClaims: boolean;
+    perspectives: number;
+    ownerConnected: boolean;
+}
+export interface ChannelPage {
+    channels: ChannelRow[];
+    nextCursor: string | null;
+}
+/** Rows whose perspectives have all ended drop out of Recent after this long. */
+export declare const ENDED_RETENTION_MS: number;
+export declare const CHANNELS_DB = "channels.db";
+/**
+ * Durable Channels projection. Edges are keyed (source, contact) and replaced
+ * per source in one transaction; the per-contact row is recomputed from its
+ * edges, so the same external contact known to several identities is one row
+ * with several perspectives, and two contacts sharing a root stay two rows.
+ */
+export declare class ChannelsStore {
+    private readonly now;
+    private readonly db;
+    readonly path: string;
+    constructor(dir: string, now?: () => number);
+    close(): void;
+    private transaction;
+    /** Reconcile the source set: unknown sources and their edges are removed, ended ones keep metadata. */
+    setSources(sources: PerspectiveSource[]): void;
+    /** Replace one source's edges from a fresh observation at the given daemon source position. */
+    replaceEdges(sourceCid: string, edges: ChannelEdge[], observed?: {
+        producerGeneration: string;
+        position: number;
+    }): void;
+    /**
+     * Drop every edge to a now-internal identity, from every source including ended ones,
+     * whose cached edges are never re-observed. Local SQL only.
+     */
+    excludeContacts(internal: Set<string>): void;
+    markStale(sourceCid: string): void;
+    private recompute;
+    /**
+     * Keyset-paginated channel rows, newest activity first. `root` narrows to rows
+     * claiming that root; `q` matches contact name, root name or CID prefix.
+     */
+    list(options?: {
+        cursor?: string;
+        limit?: number;
+        q?: string;
+        root?: string;
+    }): ChannelPage;
+    /** One channel with every perspective; null when unknown. */
+    get(cid: string): {
+        channel: ChannelRow;
+        perspectives: ChannelPerspective[];
+    } | null;
+    /** Whether `sourceCid` is a recorded perspective of `contactCid`. */
+    hasPerspective(contactCid: string, sourceCid: string): {
+        name: string;
+        kind: string;
+        roleId?: string;
+        ended: boolean;
+        generation?: string;
+    } | null;
+    sourcesSummary(): Array<{
+        cid: string;
+        name: string;
+        kind: string;
+        ended: boolean;
+        stale: boolean;
+    }>;
+}

package/dist/channels/store.js

@@ -0,0 +1,204 @@
+import { createRequire } from 'node:module';
+import { chmodSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+/** Rows whose perspectives have all ended drop out of Recent after this long. */
+export const ENDED_RETENTION_MS = 30 * 86_400_000;
+export const CHANNELS_DB = 'channels.db';
+/**
+ * Durable Channels projection. Edges are keyed (source, contact) and replaced
+ * per source in one transaction; the per-contact row is recomputed from its
+ * edges, so the same external contact known to several identities is one row
+ * with several perspectives, and two contacts sharing a root stay two rows.
+ */
+export class ChannelsStore {
+    now;
+    db;
+    path;
+    constructor(dir, now = Date.now) {
+        this.now = now;
+        const { DatabaseSync } = createRequire(import.meta.url)('node:sqlite');
+        mkdirSync(dir, { recursive: true, mode: 0o700 });
+        chmodSync(dir, 0o700);
+        this.path = join(dir, CHANNELS_DB);
+        this.db = new DatabaseSync(this.path);
+        chmodSync(this.path, 0o600);
+        this.db.exec(`PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000;
+      CREATE TABLE IF NOT EXISTS sources(cid TEXT PRIMARY KEY,name TEXT NOT NULL,kind TEXT NOT NULL,role_id TEXT,ended INTEGER NOT NULL DEFAULT 0,stale INTEGER NOT NULL DEFAULT 1,observed_at INTEGER);
+      CREATE TABLE IF NOT EXISTS edges(source_cid TEXT NOT NULL,contact_cid TEXT NOT NULL,contact_name TEXT NOT NULL,last_activity TEXT NOT NULL,root_cid TEXT,root_name TEXT,role_id TEXT,PRIMARY KEY(source_cid,contact_cid));
+      CREATE INDEX IF NOT EXISTS edges_contact ON edges(contact_cid);
+      CREATE TABLE IF NOT EXISTS channels(cid TEXT PRIMARY KEY,name TEXT NOT NULL,last_activity TEXT NOT NULL,root_cid TEXT,root_name TEXT,conflicting INTEGER NOT NULL,perspectives INTEGER NOT NULL,owner_connected INTEGER NOT NULL,live_perspectives INTEGER NOT NULL);
+      CREATE INDEX IF NOT EXISTS channels_recent ON channels(last_activity DESC,cid);
+      CREATE INDEX IF NOT EXISTS channels_root ON channels(root_cid,last_activity DESC,cid);`);
+        // The daemon source lifetime each source was last observed at (pins later history reads).
+        const columns = new Set(this.db.prepare('PRAGMA table_info(sources)').all().map(c => c.name));
+        if (!columns.has('generation'))
+            this.db.exec('ALTER TABLE sources ADD COLUMN generation TEXT');
+        if (!columns.has('position'))
+            this.db.exec('ALTER TABLE sources ADD COLUMN position INTEGER');
+    }
+    close() { this.db.close(); }
+    transaction(run) {
+        this.db.exec('BEGIN IMMEDIATE');
+        try {
+            const result = run();
+            this.db.exec('COMMIT');
+            return result;
+        }
+        catch (error) {
+            this.db.exec('ROLLBACK');
+            throw error;
+        }
+    }
+    /** Reconcile the source set: unknown sources and their edges are removed, ended ones keep metadata. */
+    setSources(sources) {
+        this.transaction(() => {
+            const keep = new Set(sources.map(s => s.cid));
+            const touched = new Set();
+            for (const row of this.db.prepare('SELECT cid FROM sources').all()) {
+                if (keep.has(row.cid))
+                    continue;
+                for (const edge of this.db.prepare('SELECT contact_cid FROM edges WHERE source_cid=?').all(row.cid))
+                    touched.add(edge.contact_cid);
+                this.db.prepare('DELETE FROM edges WHERE source_cid=?').run(row.cid);
+                this.db.prepare('DELETE FROM sources WHERE cid=?').run(row.cid);
+            }
+            for (const s of sources) {
+                this.db.prepare(`INSERT INTO sources(cid,name,kind,role_id,ended) VALUES(?,?,?,?,?)
+          ON CONFLICT(cid) DO UPDATE SET name=excluded.name,kind=excluded.kind,role_id=excluded.role_id,ended=excluded.ended`)
+                    .run(s.cid, s.name, s.kind, s.roleId ?? null, s.ended ? 1 : 0);
+                for (const edge of this.db.prepare('SELECT contact_cid FROM edges WHERE source_cid=?').all(s.cid))
+                    touched.add(edge.contact_cid);
+            }
+            for (const cid of touched)
+                this.recompute(cid);
+        });
+    }
+    /** Replace one source's edges from a fresh observation at the given daemon source position. */
+    replaceEdges(sourceCid, edges, observed) {
+        this.transaction(() => {
+            const touched = new Set(edges.map(e => e.contactCid));
+            for (const row of this.db.prepare('SELECT contact_cid FROM edges WHERE source_cid=?').all(sourceCid))
+                touched.add(row.contact_cid);
+            this.db.prepare('DELETE FROM edges WHERE source_cid=?').run(sourceCid);
+            const insert = this.db.prepare('INSERT INTO edges(source_cid,contact_cid,contact_name,last_activity,root_cid,root_name,role_id) VALUES(?,?,?,?,?,?,?)');
+            for (const e of edges)
+                insert.run(sourceCid, e.contactCid, e.contactName, e.lastActivity, e.rootCid ?? null, e.rootName ?? null, e.roleId ?? null);
+            this.db.prepare('UPDATE sources SET stale=0,observed_at=?,generation=?,position=? WHERE cid=?')
+                .run(this.now(), observed?.producerGeneration ?? null, observed?.position ?? null, sourceCid);
+            for (const cid of touched)
+                this.recompute(cid);
+        });
+    }
+    /**
+     * Drop every edge to a now-internal identity, from every source including ended ones,
+     * whose cached edges are never re-observed. Local SQL only.
+     */
+    excludeContacts(internal) {
+        if (!internal.size)
+            return;
+        this.transaction(() => {
+            const cids = [...internal];
+            const marks = cids.map(() => '?').join(',');
+            const touched = this.db.prepare(`SELECT DISTINCT contact_cid FROM edges WHERE contact_cid IN (${marks})`).all(...cids).map(r => r.contact_cid);
+            if (!touched.length)
+                return;
+            this.db.prepare(`DELETE FROM edges WHERE contact_cid IN (${marks})`).run(...cids);
+            for (const cid of touched)
+                this.recompute(cid);
+        });
+    }
+    markStale(sourceCid) {
+        this.db.prepare('UPDATE sources SET stale=1 WHERE cid=?').run(sourceCid);
+    }
+    recompute(contactCid) {
+        const edges = this.db.prepare(`SELECT e.*,s.kind,s.ended FROM edges e JOIN sources s ON s.cid=e.source_cid WHERE e.contact_cid=?`)
+            .all(contactCid);
+        if (!edges.length) {
+            this.db.prepare('DELETE FROM channels WHERE cid=?').run(contactCid);
+            return;
+        }
+        const newest = edges.reduce((a, b) => (b.last_activity > a.last_activity ? b : a));
+        const claims = new Map();
+        for (const e of edges)
+            if (e.root_cid)
+                claims.set(e.root_cid, e.root_name ?? '');
+        const single = claims.size === 1 ? [...claims.entries()][0] : undefined;
+        this.db.prepare(`INSERT INTO channels(cid,name,last_activity,root_cid,root_name,conflicting,perspectives,owner_connected,live_perspectives) VALUES(?,?,?,?,?,?,?,?,?)
+      ON CONFLICT(cid) DO UPDATE SET name=excluded.name,last_activity=excluded.last_activity,root_cid=excluded.root_cid,root_name=excluded.root_name,
+      conflicting=excluded.conflicting,perspectives=excluded.perspectives,owner_connected=excluded.owner_connected,live_perspectives=excluded.live_perspectives`)
+            .run(contactCid, newest.contact_name, newest.last_activity, single?.[0] ?? null, single?.[1] ?? null, claims.size > 1 ? 1 : 0, edges.length, edges.some(e => e.kind === 'owner' && !e.ended) ? 1 : 0, edges.filter(e => !e.ended).length);
+    }
+    /**
+     * Keyset-paginated channel rows, newest activity first. `root` narrows to rows
+     * claiming that root; `q` matches contact name, root name or CID prefix.
+     */
+    list(options = {}) {
+        const limit = Math.min(Math.max(Math.trunc(options.limit ?? 50), 1), 200);
+        const where = ['(live_perspectives>0 OR last_activity>=?)'];
+        const args = [new Date(this.now() - ENDED_RETENTION_MS).toISOString()];
+        if (options.root) {
+            where.push('root_cid=?');
+            args.push(options.root.toUpperCase());
+        }
+        if (options.q) {
+            const q = options.q.trim().toLowerCase();
+            where.push(`(instr(lower(name),?)>0 OR instr(lower(coalesce(root_name,'')),?)>0 OR cid LIKE ?)`);
+            args.push(q, q, `${q.toUpperCase().replace(/[%_]/g, '')}%`);
+        }
+        if (options.cursor) {
+            const [at, cid] = decodeCursor(options.cursor);
+            where.push('(last_activity<? OR (last_activity=? AND cid>?))');
+            args.push(at, at, cid);
+        }
+        const rows = this.db.prepare(`SELECT * FROM channels WHERE ${where.join(' AND ')} ORDER BY last_activity DESC,cid ASC LIMIT ?`)
+            .all(...args, limit + 1);
+        const more = rows.length > limit;
+        if (more)
+            rows.pop();
+        const last = rows.at(-1);
+        return { channels: rows.map(toRow), nextCursor: more && last ? encodeCursor(last.last_activity, last.cid) : null };
+    }
+    /** One channel with every perspective; null when unknown. */
+    get(cid) {
+        const row = this.db.prepare('SELECT * FROM channels WHERE cid=?').get(cid.toUpperCase());
+        if (!row)
+            return null;
+        const edges = this.db.prepare(`SELECT e.*,s.name AS source_name,s.kind,s.role_id AS source_role,s.ended,s.stale FROM edges e JOIN sources s ON s.cid=e.source_cid
+      WHERE e.contact_cid=? ORDER BY e.last_activity DESC,s.kind DESC`).all(row.cid);
+        return {
+            channel: toRow(row),
+            perspectives: edges.map(e => ({
+                sourceCid: e.source_cid, sourceName: e.source_name, kind: e.kind, ...(e.source_role ? { roleId: e.source_role } : {}),
+                ended: !!e.ended, stale: !!e.stale, contactName: e.contact_name, lastActivity: e.last_activity,
+                ...(e.root_cid ? { claimedRoot: { rootCid: e.root_cid, rootName: e.root_name ?? '', roleId: e.role_id ?? '' } } : {}),
+            })),
+        };
+    }
+    /** Whether `sourceCid` is a recorded perspective of `contactCid`. */
+    hasPerspective(contactCid, sourceCid) {
+        const row = this.db.prepare(`SELECT s.name,s.kind,s.role_id,s.ended,s.generation FROM edges e JOIN sources s ON s.cid=e.source_cid WHERE e.contact_cid=? AND e.source_cid=?`)
+            .get(contactCid.toUpperCase(), sourceCid.toUpperCase());
+        return row ? { name: row.name, kind: row.kind, ...(row.role_id ? { roleId: row.role_id } : {}), ended: !!row.ended, ...(row.generation ? { generation: row.generation } : {}) } : null;
+    }
+    sourcesSummary() {
+        return this.db.prepare('SELECT cid,name,kind,ended,stale FROM sources ORDER BY kind DESC,name').all()
+            .map(s => ({ cid: s.cid, name: s.name, kind: s.kind, ended: !!s.ended, stale: !!s.stale }));
+    }
+}
+function toRow(row) {
+    return {
+        cid: row.cid, name: row.name, lastActivity: row.last_activity,
+        ...(row.root_cid ? { claimedRoot: { rootCid: row.root_cid, rootName: row.root_name ?? '' } } : {}),
+        conflictingRootClaims: !!row.conflicting, perspectives: Number(row.perspectives), ownerConnected: !!row.owner_connected,
+    };
+}
+const encodeCursor = (at, cid) => Buffer.from(JSON.stringify([at, cid])).toString('base64url');
+function decodeCursor(cursor) {
+    try {
+        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        if (Array.isArray(value) && value.length === 2 && value.every(v => typeof v === 'string'))
+            return value;
+    }
+    catch { /* fall through */ }
+    throw new Error('invalid channels cursor');
+}

package/dist/rooms-tasks/task-state.js

@@ -179,7 +179,7 @@ function writeTask(record, options = {}) {
             const next = status(record), before = previous ? status(previous) : undefined;
             pending.push({ eventId: `task:${record.task_id}:${randomUUID()}`, taskId: record.task_id,
                 title: `Task ${!previous ? 'created' : 'updated'}: ${taskLabel(record)}`.slice(0, 160),
-                body: `Task ${record.task_id}: ${before ? `${before} → ` : 'created in '}${next}.`,
+                body: taskSentence(record, `${before ? `${before} → ` : 'created in '}${next}.`),
                 target: { kind: 'task', taskId: record.task_id }, delivery: 'push-only' });
         }
         pending.push(...contributionEvents(previous, record));
@@ -196,6 +196,11 @@ function writeTask(record, options = {}) {
 }
 /** Human label for notification titles: the mission key, when issued, precedes the title. */
 const taskLabel = (record) => record.key ? `${record.key} · ${record.title}` : record.title;
+/**
+ * Notification body naming the task by its mission key. The opaque task ID stays in routing and
+ * event fields only; a task without a key relies on its title, which the notification title shows.
+ */
+const taskSentence = (record, text) => record.key ? `Task ${record.key}: ${text}` : text[0].toUpperCase() + text.slice(1);
 /** Packages written before revisions existed count as revision 1; their next change becomes 2. No package is 0. */
 export const reviewRevision = (review) => review ? review.revision ?? 1 : 0;
 const contributionsChanged = (previous, record) => (record.progress ?? []).some(entry => !(previous.progress ?? []).some(old => old.id === entry.id))
@@ -214,7 +219,7 @@ function contributionEvents(previous, record) {
     const revision = reviewRevision(record.review);
     if (revision > reviewRevision(previous.review))
         events.push({ eventId: `task:${id}:review:${revision}`, taskId: id, title: `To review updated: ${taskLabel(record)}`.slice(0, 160),
-            body: `Task ${id}: the review package changed.`, target: { kind: 'task', taskId: id }, delivery: 'push-only' });
+            body: taskSentence(record, 'the review package changed.'), target: { kind: 'task', taskId: id }, delivery: 'push-only' });
     return events;
 }
 /** Item-based Progress unread and revision-based To review unread. An absent read state means nothing is unread. */

package/dist/web/fleet-config-service.d.ts

@@ -50,6 +50,14 @@ export declare class FleetConfigService {
     private validationInputs;
     /** Cached during canonical reads; observer filtering must never parse YAML. */
     resourceValidationInputs(): readonly string[];
+    /**
+     * Record the manifest's external file references before a projection that loads
+     * the configuration, so a reference anywhere (including a task workspace) fences
+     * that capture even before the configuration itself has been read. A manifest that
+     * cannot be read keeps the last recorded inputs; the projection reports its error.
+     */
+    observeValidationInputs(): void;
+    private recordValidationInputs;
     constructor(options?: FleetConfigServiceOptions);
     read(includeDefinitions?: boolean): ConfigReadResult;
     preview(baseRevision: string, input: unknown): Promise<ConfigPreviewResult>;

package/dist/web/fleet-config-service.js

@@ -21,6 +21,28 @@ export class FleetConfigService {
     validationInputs = [];
     /** Cached during canonical reads; observer filtering must never parse YAML. */
     resourceValidationInputs() { return this.validationInputs; }
+    /**
+     * Record the manifest's external file references before a projection that loads
+     * the configuration, so a reference anywhere (including a task workspace) fences
+     * that capture even before the configuration itself has been read. A manifest that
+     * cannot be read keeps the last recorded inputs; the projection reports its error.
+     */
+    observeValidationInputs() {
+        try {
+            this.recordValidationInputs(parse(trustedFile(this.path), { prettyErrors: false }));
+        }
+        catch { /* unchanged */ }
+    }
+    recordValidationInputs(parsed) {
+        const record = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
+        const manifest = record(parsed);
+        const vars = record(manifest.vars);
+        const expand = (value) => value.replace(/\$\{(\w+)\}/g, (match, key) => key in vars ? String(vars[key]) : match);
+        const invite = record(record(manifest.rooms).owner).public_invite_file;
+        const prompts = Object.values(record(manifest.watchdogs)).map(value => record(value).prompt_file);
+        this.validationInputs = [...(typeof invite === 'string' ? [expand(expand(invite))] : []),
+            ...prompts.filter((value) => typeof value === 'string').map(expand)].map(value => resolve(value));
+    }
     constructor(options = {}) {
         this.path = options.configPath ?? defaultConfigPath();
         this.preflight = options.preflight ?? (async () => emptyReport());
@@ -30,16 +52,9 @@ export class FleetConfigService {
         const sources = readSources(this.path);
         let raw;
         try {
-            const manifest = parse(sources.documents.get(basename(sources.manifest)), { prettyErrors: false });
-            const record = (value) => value && typeof value === 'object' && !Array.isArray(value) ? value : {};
-            const vars = record(manifest.vars);
-            const expand = (value) => value.replace(/\$\{(\w+)\}/g, (match, key) => key in vars ? String(vars[key]) : match);
-            const invite = record(record(manifest.rooms).owner).public_invite_file;
-            const prompts = Object.values(record(manifest.watchdogs)).map(value => record(value).prompt_file);
             // Record even invalid/missing references before validation, so repairing an
             // already observed dependency can never retain a certified stale capture.
-            this.validationInputs = [...(typeof invite === 'string' ? [expand(expand(invite))] : []),
-                ...prompts.filter((value) => typeof value === 'string').map(expand)].map(value => resolve(value));
+            this.recordValidationInputs(parse(sources.documents.get(basename(sources.manifest)), { prettyErrors: false }));
             loadConfig(this.path, { yamlMode: 'strict' });
             raw = modelFrom(sources, includeDefinitions);
         }

package/dist/web/resource-views.d.ts

@@ -80,7 +80,7 @@ export declare class ResourceOutput {
 }
 export interface ResourceDescriptor {
     viewId: string;
-    resource: 'directory' | 'roles' | 'tasks' | 'task-lists' | 'configuration' | 'previews' | 'task-layout' | 'creation-action' | 'action' | 'member-addition' | 'login' | 'onboarding-health' | 'subscriptions';
+    resource: 'directory' | 'roles' | 'tasks' | 'task-lists' | 'configuration' | 'previews' | 'task-layout' | 'creation-action' | 'action' | 'member-addition' | 'login' | 'onboarding-health' | 'subscriptions' | 'channels';
     entityId?: string;
     receiptId?: string;
     provider?: 'claude' | 'codex';
@@ -135,6 +135,8 @@ export declare class FleetResourceViews {
     private coverage;
     /** Certify each view's last projected source; never a position its capture did not read. */
     private cover;
+    /** Whether `path` is, contains or lies within the manifest, its split definitions or another configuration input. */
+    private configurationDependency;
     private affects;
     private schedule;
     private refresh;