@ours.network/fleet 0.12.0 → 0.13.0

package/dist/owner-channel/notices.d.ts

@@ -0,0 +1,21 @@
+import type { SessionSnapshot, TurnOutcome } from '../session/types.js';
+import type { OwnerTaskPhase } from './tasks.js';
+export type OwnerUpdatePhase = 'working' | 'approval' | 'blocked';
+export type OwnerProgressPhase = 'starting request' | 'waiting behind earlier requests' | 'working on request' | 'planning next step' | 'using tools' | 'reviewing tool results' | 'drafting response' | 'waiting for approval' | 'resuming after permission decision' | 'recovering from session error';
+export declare const ownerNotices: {
+    receivedStarted: () => string;
+    receivedQueued: (queuedBehind: number) => string;
+    receivedInterrupting: () => string;
+    status: (role: string, snapshot: SessionSnapshot) => string;
+    interrupted: (role: string) => string;
+    interruptFailed: (role: string) => string;
+    attachmentRejected: (reason: string) => string;
+    attachmentFailed: () => string;
+    deliveryFailed: (role: string) => string;
+    progress: (elapsedMs: number, phase: OwnerProgressPhase, started: number, completed: number, activityUpdates?: number) => string;
+    authoredUpdate: (phase: OwnerUpdatePhase, message: string) => string;
+    taskReport: (phase: OwnerTaskPhase, message: string) => string;
+    completedWithoutText: () => string;
+    terminal: (outcome: TurnOutcome) => "✅ Request completed." | "🛑 Request was cancelled before completion." | "⚠️ The agent declined this request." | "⚠️ Request failed before completion." | "⚠️ Request ended without a confirmed completion.";
+    chunk: (part: number, total: number) => string;
+};

package/dist/owner-channel/notices.js

@@ -0,0 +1,66 @@
+const duration = (elapsedMs) => {
+    const seconds = Math.max(0, Math.floor(elapsedMs / 1_000));
+    const hours = Math.floor(seconds / 3_600);
+    const minutes = Math.floor((seconds % 3_600) / 60);
+    const remainder = seconds % 60;
+    return [hours ? `${hours}h` : '', minutes ? `${minutes}m` : '', remainder ? `${remainder}s` : '']
+        .filter(Boolean).join(' ') || '0s';
+};
+const count = (value, singular, plural = `${singular}s`) => `${value} ${value === 1 ? singular : plural}`;
+const joinCounts = (parts) => parts.length < 2
+    ? parts[0] ?? ''
+    : `${parts.slice(0, -1).join(', ')} and ${parts.at(-1)}`;
+export const ownerNotices = {
+    receivedStarted: () => 'ℹ️ Message received. The agent has started working on this request now. '
+        + 'The response will arrive in this channel when ready.',
+    receivedQueued: (queuedBehind) => `ℹ️ Message received. The agent is finishing ${queuedBehind} earlier request(s) first; `
+        + 'this request will start as soon as they complete. '
+        + 'The response will arrive in this channel when ready.',
+    receivedInterrupting: () => "ℹ️ Message received. The agent's previous task was interrupted to prioritize "
+        + 'this request, and it is now working on a response. '
+        + 'The response will arrive in this channel when ready.',
+    status: (role, snapshot) => `📊 ${role} status: ${snapshot.readiness}; session is ${snapshot.alive ? 'online' : 'offline'}.`,
+    interrupted: (role) => `🛑 Interrupt sent to ${role}'s active turn.`,
+    interruptFailed: (role) => `⚠️ Could not interrupt ${role}'s active turn.`,
+    attachmentRejected: (reason) => `⚠️ Attachment rejected: ${reason}.`,
+    attachmentFailed: () => '⚠️ Could not securely retrieve or admit this attachment request.',
+    deliveryFailed: (role) => `⚠️ Could not deliver this request to ${role}.`,
+    progress: (elapsedMs, phase, started, completed, activityUpdates = 0) => {
+        const counts = [];
+        if (started)
+            counts.push(`${count(started, 'tool action')} started`);
+        if (completed)
+            counts.push(`${count(completed, 'tool action')} completed`);
+        if (activityUpdates)
+            counts.push(`${count(activityUpdates, counts.length ? 'additional activity update' : 'activity update')} observed`);
+        const activity = counts.length
+            ? `${joinCounts(counts)} since the last update.`
+            : 'no new reportable activity since the last update.';
+        return `⏳ Working for ${duration(elapsedMs)} · ${phase} · ${activity}`;
+    },
+    authoredUpdate: (phase, message) => {
+        switch (phase) {
+            case 'working': return `🔄 Update: ${message}`;
+            case 'approval': return `🔐 Approval needed: ${message}`;
+            case 'blocked': return `🚧 Blocked: ${message}`;
+        }
+    },
+    taskReport: (phase, message) => {
+        switch (phase) {
+            case 'progress': return `🔄 Follow-up: ${message}`;
+            case 'done': return `✅ Follow-up complete: ${message}`;
+            case 'blocked': return `🚧 Follow-up blocked: ${message}`;
+        }
+    },
+    completedWithoutText: () => '✅ Request completed, but the agent returned no text.',
+    terminal: (outcome) => {
+        switch (outcome) {
+            case 'completed': return '✅ Request completed.';
+            case 'cancelled': return '🛑 Request was cancelled before completion.';
+            case 'refused': return '⚠️ The agent declined this request.';
+            case 'failed': return '⚠️ Request failed before completion.';
+            case 'inconclusive': return '⚠️ Request ended without a confirmed completion.';
+        }
+    },
+    chunk: (part, total) => `ℹ️ Response part ${part} of ${total}:\n`,
+};

package/dist/owner-channel/state.d.ts

@@ -8,3 +8,37 @@ export declare class OwnerChannelState {
     has(wireId: string): boolean;
     remember(wireId: string): void;
 }
+export type OwnerSource = 'baseline' | 'dynamic';
+export interface OwnerEntry {
+    cid: string;
+    source: OwnerSource;
+    effective: boolean;
+}
+/**
+ * Configured owners remain the declared baseline. This durable overlay adds
+ * owners or revokes either source without rewriting fleet.yaml. A corrupt
+ * overlay authorizes nobody and refuses mutation until the operator repairs or
+ * removes the bad file; silently falling back could resurrect a revoked owner.
+ */
+export declare class OwnerAuthorizationState {
+    private readonly path;
+    private readonly baseline;
+    private added;
+    private revoked;
+    private audit;
+    private corruptReason?;
+    constructor(path: string, baseline: string[]);
+    integrity(): {
+        ok: boolean;
+        error?: string;
+    };
+    effective(): Set<string>;
+    entries(): OwnerEntry[];
+    authorize(cid: string): OwnerEntry;
+    revoke(cid: string): OwnerEntry;
+    private assertHealthy;
+    private record;
+    private snapshot;
+    private restore;
+    private persist;
+}

package/dist/owner-channel/state.js

@@ -1,5 +1,6 @@
-import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { chmodSync, existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
 import { dirname } from 'node:path';
+import { replaceFileAtomically } from '../atomic-file.js';
 /** Durable bounded dedupe containing wire IDs only — never message or reply plaintext. */
 export class OwnerChannelState {
     path;
@@ -35,3 +36,149 @@ export class OwnerChannelState {
         renameSync(tmp, this.path);
     }
 }
+const MAX_OVERLAY_CIDS = 1_000;
+const MAX_AUDIT_ENTRIES = 500;
+/**
+ * Configured owners remain the declared baseline. This durable overlay adds
+ * owners or revokes either source without rewriting fleet.yaml. A corrupt
+ * overlay authorizes nobody and refuses mutation until the operator repairs or
+ * removes the bad file; silently falling back could resurrect a revoked owner.
+ */
+export class OwnerAuthorizationState {
+    path;
+    baseline;
+    added = new Set();
+    revoked = new Set();
+    audit = [];
+    corruptReason;
+    constructor(path, baseline) {
+        this.path = path;
+        this.baseline = new Set(baseline);
+        if (!existsSync(path))
+            return;
+        try {
+            const raw = JSON.parse(readFileSync(path, 'utf8'));
+            if (raw.version !== 1 || !Array.isArray(raw.added) || !Array.isArray(raw.revoked)
+                || !Array.isArray(raw.audit))
+                throw new Error('unsupported or incomplete state');
+            const validCid = (cid) => typeof cid === 'string' && /^[A-Fa-f0-9]{64}$/.test(cid);
+            if (!raw.added.every(validCid) || !raw.revoked.every(validCid)
+                || raw.added.length + raw.revoked.length > MAX_OVERLAY_CIDS
+                || raw.audit.length > MAX_AUDIT_ENTRIES
+                || raw.audit.some(entry => !entry || typeof entry !== 'object'
+                    || !validCid(entry.cid)
+                    || !['authorize', 'revoke'].includes(entry.action)
+                    || typeof entry.at !== 'string'))
+                throw new Error('invalid or unbounded state');
+            this.added = new Set(raw.added);
+            this.revoked = new Set(raw.revoked);
+            this.audit = raw.audit;
+            if (this.added.size !== raw.added.length || this.revoked.size !== raw.revoked.length)
+                throw new Error('duplicate overlay CID');
+            if ([...this.added].some(cid => this.revoked.has(cid)))
+                throw new Error('CID appears in both added and revoked overlays');
+            chmodSync(path, 0o600);
+        }
+        catch {
+            this.corruptReason = 'invalid persisted authorization overlay';
+            this.added.clear();
+            this.revoked.clear();
+            this.audit = [];
+            try {
+                chmodSync(path, 0o600);
+            }
+            catch { /* still fail closed */ }
+        }
+    }
+    integrity() {
+        return this.corruptReason ? { ok: false, error: this.corruptReason } : { ok: true };
+    }
+    effective() {
+        if (this.corruptReason)
+            return new Set();
+        const effective = new Set([...this.baseline, ...this.added]);
+        for (const cid of this.revoked)
+            effective.delete(cid);
+        return effective;
+    }
+    entries() {
+        const effective = this.effective();
+        return [...new Set([...this.baseline, ...this.added, ...this.revoked])]
+            .sort().map(cid => ({
+            cid,
+            source: this.baseline.has(cid) ? 'baseline' : 'dynamic',
+            effective: effective.has(cid),
+        }));
+    }
+    authorize(cid) {
+        this.assertHealthy();
+        if (this.effective().has(cid))
+            throw new Error(`owner '${cid}' is already authorized`);
+        const rollback = this.snapshot();
+        if (this.baseline.has(cid))
+            this.revoked.delete(cid);
+        else {
+            if (this.added.size + this.revoked.size >= MAX_OVERLAY_CIDS)
+                throw new Error(`owner authorization overlay is limited to ${MAX_OVERLAY_CIDS} CIDs`);
+            this.added.add(cid);
+            this.revoked.delete(cid);
+        }
+        this.record('authorize', cid);
+        try {
+            this.persist();
+        }
+        catch (error) {
+            this.restore(rollback);
+            throw error;
+        }
+        return { cid, source: this.baseline.has(cid) ? 'baseline' : 'dynamic', effective: true };
+    }
+    revoke(cid) {
+        this.assertHealthy();
+        const effective = this.effective();
+        if (!effective.has(cid))
+            throw new Error(`owner '${cid}' is not authorized`);
+        if (effective.size === 1)
+            throw new Error('refusing to revoke the last effective owner');
+        const rollback = this.snapshot();
+        if (this.baseline.has(cid))
+            this.revoked.add(cid);
+        else
+            this.added.delete(cid);
+        this.record('revoke', cid);
+        try {
+            this.persist();
+        }
+        catch (error) {
+            this.restore(rollback);
+            throw error;
+        }
+        return { cid, source: this.baseline.has(cid) ? 'baseline' : 'dynamic', effective: false };
+    }
+    assertHealthy() {
+        if (this.corruptReason)
+            throw new Error(`owner authorization state is corrupt; refusing mutation: ${this.corruptReason}`);
+    }
+    record(action, cid) {
+        this.audit.push({ at: new Date().toISOString(), action, cid });
+        this.audit = this.audit.slice(-MAX_AUDIT_ENTRIES);
+    }
+    snapshot() {
+        return { added: new Set(this.added), revoked: new Set(this.revoked), audit: [...this.audit] };
+    }
+    restore(snapshot) {
+        this.added = snapshot.added;
+        this.revoked = snapshot.revoked;
+        this.audit = snapshot.audit;
+    }
+    persist() {
+        const state = {
+            version: 1,
+            added: [...this.added].sort(),
+            revoked: [...this.revoked].sort(),
+            audit: this.audit,
+        };
+        replaceFileAtomically(this.path, JSON.stringify(state) + '\n', 0o600);
+        chmodSync(this.path, 0o600);
+    }
+}

package/dist/owner-channel/tasks.d.ts

@@ -0,0 +1,62 @@
+export type OwnerTaskPhase = 'progress' | 'done' | 'blocked';
+export type OwnerTaskTerminalState = 'closed' | 'expired' | 'revoked';
+export interface OwnerTaskRoute {
+    requestId: string;
+    contact: string;
+    wireId: string;
+}
+interface PendingReport {
+    digest: string;
+    phase: OwnerTaskPhase;
+    chars: number;
+    bytes: number;
+}
+export interface OwnerTaskRecord extends OwnerTaskRoute {
+    id: string;
+    createdAt: number;
+    expiresAt: number;
+    status: 'open' | 'sending' | 'uncertain';
+    sequence: number;
+    reportCount: number;
+    lastReportAt?: number;
+    digests: string[];
+    pending?: PendingReport;
+}
+export declare const OWNER_TASK_TTL_MS: number;
+export declare const OWNER_TASK_MAX_OPEN = 32;
+export declare const OWNER_TASK_MAX_PER_OWNER = 8;
+export declare const OWNER_TASK_MAX_REPORTS = 20;
+export declare const OWNER_TASK_REPORT_MIN_INTERVAL_MS = 5000;
+/**
+ * Durable proactive-task routing. It deliberately stores no report body: only
+ * the authenticated route, bounded hashes/counters, and delivery state.
+ */
+export declare class OwnerTaskState {
+    private readonly path;
+    private tasks;
+    private tombstones;
+    private corruptReason?;
+    constructor(path: string);
+    integrity(): {
+        ok: boolean;
+        error?: string;
+    };
+    open(route: OwnerTaskRoute, now?: number): OwnerTaskRecord;
+    route(taskId: string, now?: number): OwnerTaskRecord;
+    beginReport(taskId: string, phase: OwnerTaskPhase, digest: string, chars: number, bytes: number, now?: number): OwnerTaskRecord;
+    delivered(taskId: string, digest: string, terminal: boolean, now?: number): number;
+    uncertain(taskId: string, digest: string): void;
+    revoke(contact: string, now?: number): number;
+    cleanup(now?: number, effectiveOwners?: Set<string>): number;
+    private findOpen;
+    private remove;
+    private mutate;
+    private persist;
+    private assertHealthy;
+    private validTask;
+    private validPending;
+    private validTombstone;
+}
+export declare const ownerTaskDigest: (phase: OwnerTaskPhase, message: string) => string;
+export declare const ownerTaskAuditId: (value: string) => string;
+export {};

package/dist/owner-channel/tasks.js

@@ -0,0 +1,246 @@
+import { createHash, randomBytes } from 'node:crypto';
+import { chmodSync, existsSync, readFileSync } from 'node:fs';
+import { replaceFileAtomically } from '../atomic-file.js';
+export const OWNER_TASK_TTL_MS = 7 * 24 * 60 * 60 * 1_000;
+export const OWNER_TASK_MAX_OPEN = 32;
+export const OWNER_TASK_MAX_PER_OWNER = 8;
+export const OWNER_TASK_MAX_REPORTS = 20;
+export const OWNER_TASK_REPORT_MIN_INTERVAL_MS = 5_000;
+const MAX_TOMBSTONES = 256;
+const TOMBSTONE_TTL_MS = 30 * 24 * 60 * 60 * 1_000;
+const HEX_64 = /^[a-f0-9]{64}$/;
+const CID = /^[A-Fa-f0-9]{64}$/;
+/**
+ * Durable proactive-task routing. It deliberately stores no report body: only
+ * the authenticated route, bounded hashes/counters, and delivery state.
+ */
+export class OwnerTaskState {
+    path;
+    tasks = [];
+    tombstones = [];
+    corruptReason;
+    constructor(path) {
+        this.path = path;
+        if (!existsSync(path))
+            return;
+        try {
+            const raw = JSON.parse(readFileSync(path, 'utf8'));
+            if (raw.version !== 1 || !Array.isArray(raw.tasks) || !Array.isArray(raw.tombstones)
+                || raw.tasks.length > OWNER_TASK_MAX_OPEN || raw.tombstones.length > MAX_TOMBSTONES
+                || !raw.tasks.every(task => this.validTask(task))
+                || !raw.tombstones.every(tombstone => this.validTombstone(tombstone)))
+                throw new Error('invalid or unbounded task state');
+            const ids = [...raw.tasks.map(task => task.id), ...raw.tombstones.map(item => item.id)];
+            if (new Set(ids).size !== ids.length)
+                throw new Error('duplicate task ID');
+            this.tasks = raw.tasks.map(task => ({ ...task, digests: [...task.digests] }));
+            this.tombstones = raw.tombstones.map(item => ({ ...item }));
+            // A crash or lost response after the durable pre-send marker makes the
+            // result unknowable. Never resend it automatically and risk duplication.
+            let recovered = false;
+            for (const task of this.tasks) {
+                if (task.status === 'sending') {
+                    task.status = 'uncertain';
+                    recovered = true;
+                }
+            }
+            chmodSync(path, 0o600);
+            if (recovered)
+                this.persist();
+        }
+        catch {
+            this.tasks = [];
+            this.tombstones = [];
+            this.corruptReason = 'invalid persisted owner task state';
+            try {
+                chmodSync(path, 0o600);
+            }
+            catch { /* remain fail-closed */ }
+        }
+    }
+    integrity() {
+        return this.corruptReason ? { ok: false, error: this.corruptReason } : { ok: true };
+    }
+    open(route, now = Date.now()) {
+        this.assertHealthy();
+        if (!HEX_64.test(route.requestId) || !CID.test(route.contact)
+            || typeof route.wireId !== 'string' || route.wireId.length < 1 || route.wireId.length > 1_024)
+            throw new Error('owner task route is invalid or exceeds its bounds');
+        this.cleanup(now);
+        if (this.tasks.length >= OWNER_TASK_MAX_OPEN)
+            throw new Error(`owner channel is limited to ${OWNER_TASK_MAX_OPEN} open tasks`);
+        if (this.tasks.filter(task => task.contact === route.contact).length >= OWNER_TASK_MAX_PER_OWNER)
+            throw new Error(`an owner is limited to ${OWNER_TASK_MAX_PER_OWNER} open tasks per role`);
+        let id;
+        do {
+            id = randomBytes(32).toString('hex');
+        } while (this.tasks.some(task => task.id === id) || this.tombstones.some(item => item.id === id));
+        const task = {
+            id, ...route, createdAt: now, expiresAt: now + OWNER_TASK_TTL_MS,
+            status: 'open', sequence: 0, reportCount: 0, digests: [],
+        };
+        this.mutate(() => { this.tasks.push(task); });
+        return { ...task, digests: [] };
+    }
+    route(taskId, now = Date.now()) {
+        this.assertHealthy();
+        this.cleanup(now);
+        const task = this.findOpen(taskId);
+        return {
+            ...task, digests: [...task.digests],
+            ...(task.pending ? { pending: { ...task.pending } } : {}),
+        };
+    }
+    beginReport(taskId, phase, digest, chars, bytes, now = Date.now()) {
+        this.assertHealthy();
+        this.cleanup(now);
+        const task = this.findOpen(taskId);
+        if (task.status === 'uncertain')
+            throw new Error('task report delivery outcome is uncertain; refusing to resend or reorder reports');
+        if (task.status !== 'open')
+            throw new Error('task report is already being delivered');
+        if (task.digests.includes(digest))
+            throw new Error('duplicate task report refused');
+        if (task.reportCount >= OWNER_TASK_MAX_REPORTS)
+            throw new Error(`owner task is limited to ${OWNER_TASK_MAX_REPORTS} reports`);
+        if (task.lastReportAt !== undefined && now - task.lastReportAt < OWNER_TASK_REPORT_MIN_INTERVAL_MS)
+            throw new Error(`owner task reports are rate-limited to one every ${OWNER_TASK_REPORT_MIN_INTERVAL_MS}ms`);
+        this.mutate(() => {
+            task.status = 'sending';
+            task.pending = { digest, phase, chars, bytes };
+        });
+        return { ...task, digests: [...task.digests], pending: { ...task.pending } };
+    }
+    delivered(taskId, digest, terminal, now = Date.now()) {
+        this.assertHealthy();
+        const task = this.tasks.find(item => item.id === taskId);
+        if (!task || task.status !== 'sending' || task.pending?.digest !== digest)
+            throw new Error('task report delivery state changed unexpectedly');
+        const sequence = task.sequence + 1;
+        this.mutate(() => {
+            task.sequence = sequence;
+            task.reportCount++;
+            task.lastReportAt = now;
+            task.digests.push(digest);
+            task.pending = undefined;
+            if (terminal)
+                this.remove(task, 'closed', now);
+            else
+                task.status = 'open';
+        });
+        return sequence;
+    }
+    uncertain(taskId, digest) {
+        this.assertHealthy();
+        const task = this.tasks.find(item => item.id === taskId);
+        if (!task || task.pending?.digest !== digest)
+            return;
+        this.mutate(() => { task.status = 'uncertain'; });
+    }
+    revoke(contact, now = Date.now()) {
+        this.assertHealthy();
+        const revoked = this.tasks.filter(task => task.contact === contact);
+        if (!revoked.length)
+            return 0;
+        this.mutate(() => { for (const task of revoked)
+            this.remove(task, 'revoked', now); });
+        return revoked.length;
+    }
+    cleanup(now = Date.now(), effectiveOwners) {
+        this.assertHealthy();
+        const expired = this.tasks.filter(task => task.expiresAt <= now);
+        const revoked = effectiveOwners
+            ? this.tasks.filter(task => !effectiveOwners.has(task.contact) && !expired.includes(task)) : [];
+        const oldTombstones = this.tombstones.filter(item => now - item.at > TOMBSTONE_TTL_MS);
+        if (!expired.length && !revoked.length && !oldTombstones.length)
+            return 0;
+        this.mutate(() => {
+            for (const task of expired)
+                this.remove(task, 'expired', now);
+            for (const task of revoked)
+                this.remove(task, 'revoked', now);
+            this.tombstones = this.tombstones
+                .filter(item => now - item.at <= TOMBSTONE_TTL_MS).slice(-MAX_TOMBSTONES);
+        });
+        return expired.length + revoked.length;
+    }
+    findOpen(taskId) {
+        if (!HEX_64.test(taskId))
+            throw new Error('owner task ID must be exactly 64 lowercase hexadecimal characters');
+        const task = this.tasks.find(item => item.id === taskId);
+        if (task)
+            return task;
+        const tombstone = this.tombstones.find(item => item.id === taskId);
+        if (tombstone)
+            throw new Error(`owner task is ${tombstone.state}`);
+        throw new Error('unknown owner task ID');
+    }
+    remove(task, state, now) {
+        this.tasks = this.tasks.filter(item => item !== task);
+        this.tombstones.push({ id: task.id, state, at: now });
+        this.tombstones = this.tombstones.slice(-MAX_TOMBSTONES);
+    }
+    mutate(change) {
+        const snapshot = JSON.stringify({ tasks: this.tasks, tombstones: this.tombstones });
+        change();
+        try {
+            this.persist();
+        }
+        catch (error) {
+            const old = JSON.parse(snapshot);
+            this.tasks = old.tasks;
+            this.tombstones = old.tombstones;
+            throw error;
+        }
+    }
+    persist() {
+        replaceFileAtomically(this.path, JSON.stringify({
+            version: 1, tasks: this.tasks, tombstones: this.tombstones,
+        }) + '\n', 0o600);
+        chmodSync(this.path, 0o600);
+    }
+    assertHealthy() {
+        if (this.corruptReason)
+            throw new Error(`owner task state is corrupt; refusing operation: ${this.corruptReason}`);
+    }
+    validTask(value) {
+        if (!value || typeof value !== 'object')
+            return false;
+        const task = value;
+        return HEX_64.test(task.id) && HEX_64.test(task.requestId) && CID.test(task.contact)
+            && typeof task.wireId === 'string' && task.wireId.length > 0 && task.wireId.length <= 1_024
+            && Number.isSafeInteger(task.createdAt) && task.createdAt >= 0
+            && Number.isSafeInteger(task.expiresAt) && task.expiresAt - task.createdAt === OWNER_TASK_TTL_MS
+            && ['open', 'sending', 'uncertain'].includes(task.status)
+            && Number.isSafeInteger(task.sequence) && task.sequence >= 0
+            && Number.isSafeInteger(task.reportCount) && task.reportCount >= 0
+            && task.reportCount <= OWNER_TASK_MAX_REPORTS
+            && Array.isArray(task.digests) && task.digests.length <= OWNER_TASK_MAX_REPORTS
+            && task.digests.every(digest => HEX_64.test(digest))
+            && new Set(task.digests).size === task.digests.length
+            && task.sequence === task.reportCount && task.reportCount === task.digests.length
+            && (task.reportCount === 0
+                ? task.lastReportAt === undefined
+                : Number.isSafeInteger(task.lastReportAt) && task.lastReportAt >= task.createdAt)
+            && (task.pending === undefined || this.validPending(task.pending))
+            && (task.pending === undefined || !task.digests.includes(task.pending.digest))
+            && (task.status === 'open' ? task.pending === undefined : task.pending !== undefined);
+    }
+    validPending(value) {
+        if (!value || typeof value !== 'object')
+            return false;
+        const pending = value;
+        return HEX_64.test(pending.digest) && ['progress', 'done', 'blocked'].includes(pending.phase)
+            && Number.isSafeInteger(pending.chars) && pending.chars >= 1 && pending.chars <= 280
+            && Number.isSafeInteger(pending.bytes) && pending.bytes >= 1 && pending.bytes <= 1_024;
+    }
+    validTombstone(value) {
+        if (!value || typeof value !== 'object')
+            return false;
+        const item = value;
+        return HEX_64.test(item.id) && ['closed', 'expired', 'revoked'].includes(item.state)
+            && Number.isSafeInteger(item.at);
+    }
+}
+export const ownerTaskDigest = (phase, message) => createHash('sha256').update(`${phase}\0${message}`).digest('hex');
+export const ownerTaskAuditId = (value) => createHash('sha256').update(value).digest('hex').slice(0, 12);

package/dist/resolved-plan.js

@@ -20,6 +20,12 @@ export function resolvedPlan(cfg) {
         startStaggerMs: cfg.startStaggerMs,
         diagnostics: cfg.diagnostics.map(diagnostic => ({ ...diagnostic })),
         roles: cfg.roles.map(resolvedRolePlan),
+        loops: cfg.loops.map(loop => sortedObject({
+            name: loop.name, selectors: [...loop.selectors], roles: [...loop.roleNames],
+            intervalMs: loop.intervalMs, initialDelayMs: loop.initialDelayMs, jitterMs: loop.jitterMs,
+            enabled: loop.enabled, sourceFile: loop.sourceFile,
+            prompt: { bytes: loop.promptBytes, sha256: loop.promptHash },
+        })),
         watchdogs: cfg.watchdogs.map(w => sortedObject({
             name: w.name, sourceFile: w.sourceFile, enabled: w.enabled,
             intervalMs: w.intervalMs, coordinator: w.coordinator, watch: [...w.watch],
@@ -61,6 +67,11 @@ export function resolvedRolePlan(role) {
         },
         monitor: role.monitor,
         ownerChannel: role.owner_channel ?? null,
+        loops: (role.loops ?? []).map(loop => ({
+            name: loop.name, enabled: loop.enabled, intervalMs: loop.intervalMs,
+            initialDelayMs: loop.initialDelayMs, jitterMs: loop.jitterMs,
+            definitionHash: loop.definitionHash, prompt: { bytes: loop.promptBytes, sha256: loop.promptHash },
+        })),
         isolation: role.isolation ?? null,
         worklog: role.worklog ?? null,
         authProxy: role.auth_proxy ?? null,