@hypercarrier/pi-team-durable 0.0.0-stage → 0.1.0-rc.2

package/dist/authority/observation.js

@@ -0,0 +1,143 @@
+import { GenerationTask, hook, LiveDoc } from '@earendil-works/pi-durable';
+import { openAuthority as open, flushAuthority } from "./store.js";
+import { openObservations, pages, savePage, openProofs, proof, saveProof, retireProof, retireBody, advanceAcknowledged, digest } from "./observation-store.js";
+export { ObservationDoc, ObservationHeadDoc, PageDoc, PageBodyDoc, ProofDoc, observations, observationStats, openObservations, reservationHead, reserve, startObservationEpoch, digest } from "./observation-store.js";
+function texts(message) {
+    const content = message.content;
+    return typeof content === 'string' ? [content] : Array.isArray(content) ? content.filter(c => c.type === 'text').map(c => c.text) : [];
+}
+function visible(page, messages) {
+    const carrier = page.carrier;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const message = messages[i];
+        if (carrier.kind === 'tool'
+            ? message.role === 'toolResult' && message.toolCallId === carrier.callId && texts(message).some(text => text === page.body)
+            : message.role === 'user' && texts(message).some(text => text === carrier.text))
+            return true;
+    }
+    return false;
+}
+export function observationExtension(resolvePort) {
+    return { name: 'ptb.observation', hooks: [hook(GenerationTask, {
+                beforeRequest: async (request, api, context) => {
+                    const port = await resolvePort(api, context);
+                    const live = await api.snapshot(LiveDoc, api.conversationId, context), run = live?.run?.inputs[0];
+                    if (run === undefined)
+                        return;
+                    await port.commit(async (tx) => {
+                        const o = await openObservations(tx), ids = [];
+                        for (const p of await pages(o, 'openPages', true)) {
+                            if (p.lead !== api.conversationId || (p.run !== run && p.run !== 0))
+                                continue;
+                            if (visible(p, request.messages)) {
+                                ids.push(p.id);
+                                if (p.run !== run || p.state !== 'presented') {
+                                    p.run = run;
+                                    p.state = 'presented';
+                                    await savePage(o, p);
+                                }
+                            }
+                            else if (p.state === 'reserved' && p.run === run) {
+                                p.state = 'released';
+                                await savePage(o, p);
+                            }
+                        }
+                        // Replace on every attempt. An earlier response cannot attest a later request.
+                        if (ids.length)
+                            await saveProof(o, { generation: api.taskId, lead: api.conversationId, run, pages: ids });
+                        else
+                            await retireProof(o, String(api.taskId));
+                    }, context);
+                },
+                afterResponse: async (message, api, context) => {
+                    await recordResponse(await resolvePort(api, context), api, message, context);
+                },
+            })] };
+}
+export async function recordResponse(port, api, message, context) {
+    await port.commit(async (tx) => {
+        const o = await openObservations(tx), p = await proof(o, String(api.taskId));
+        if (p && ['stop', 'length', 'toolUse'].includes(message.stopReason)) {
+            p.responseDigest = digest(message);
+            await saveProof(o, p);
+        }
+    }, context);
+}
+/** Native persistence and settled runs permit ACK. Proofs never scan transcript history. */
+export async function observe(harness, context) {
+    const snapshot = await harness.commit(async (tx) => {
+        const o = await openObservations(tx);
+        return { pages: await pages(o, 'openPages'), proofs: await openProofs(o) };
+    }, context);
+    const byPage = new Map(snapshot.pages.map(p => [p.id, p])), byProof = new Map(snapshot.proofs.map(p => [String(p.generation), p]));
+    const witnessed = new Set();
+    for (const p of snapshot.proofs) {
+        if (!p.responseDigest || !p.pages.length)
+            continue;
+        const native = await harness.getTask(p.generation, context), state = native?.state;
+        const entryId = state?.checkpoint?.assistant ?? (state?.outcome?.status === 'completed' ? state.outcome.result?.entryId : undefined);
+        if (entryId === undefined)
+            continue;
+        const entry = await harness.commit(tx => tx.entry(entryId), context);
+        if (entry?.byTaskId === p.generation && entry.kind === 'pi.assistant' && entry.model?.some(m => digest(m) === p.responseDigest))
+            for (const id of p.pages)
+                witnessed.add(id);
+    }
+    const runs = new Map();
+    for (const run of new Set([...snapshot.pages.map(p => p.run), ...snapshot.proofs.map(p => p.run)])) {
+        const submission = await harness.submission(run, context), record = await submission?.status(context);
+        runs.set(run, record?.status === 'done' ? 'success' : record?.status === 'unanswered' ? 'failure' : 'live');
+    }
+    await harness.commit(async (tx) => {
+        const o = await openObservations(tx), currentProofs = await openProofs(o);
+        for (const p of await pages(o, 'openPages')) {
+            if (JSON.stringify(p) !== JSON.stringify(byPage.get(p.id)))
+                continue;
+            const outcome = runs.get(p.run);
+            if (outcome !== 'success' && outcome !== 'failure')
+                continue;
+            const stableProof = currentProofs.some(candidate => candidate.pages.includes(p.id) && JSON.stringify(candidate) === JSON.stringify(byProof.get(String(candidate.generation))));
+            if (outcome === 'success' && witnessed.has(p.id) && stableProof)
+                p.state = 'acknowledged';
+            else {
+                p.state = 'released';
+                if (outcome === 'failure')
+                    o.head.paused = true;
+            }
+            await savePage(o, p);
+        }
+        await advanceAcknowledged(o);
+        // A settled, processed proof cannot attest a later request. Drop its body and index.
+        for (const p of currentProofs) {
+            const outcome = runs.get(p.run);
+            if ((outcome === 'success' || outcome === 'failure') && JSON.stringify(p) === JSON.stringify(byProof.get(String(p.generation))))
+                await retireProof(o, String(p.generation));
+        }
+        const pinned = new Set(currentProofs.filter(p => !runs.has(p.run) || runs.get(p.run) === 'live').flatMap(p => p.pages));
+        for (const p of await pages(o, 'prunePages')) {
+            if (p.through > (o.head.ackByEpoch[p.epoch] ?? 0) || pinned.has(p.id))
+                continue;
+            if (p.carrier.kind === 'input') {
+                // Admission replay still needs the exact input until its notifier leaves settle.
+                // Unknown legacy ownership cannot prove that the body is unused.
+                if (p.notifierId === undefined)
+                    continue;
+                const native = await tx.task(p.notifierId), checkpoint = native?.state?.checkpoint;
+                if (!native || native.kind !== 'ptb.notify' || native.input?.epoch !== p.epoch)
+                    continue;
+                if (native.state.status !== 'terminal') {
+                    if (!checkpoint || !['tick', 'submit', 'settle'].includes(checkpoint.phase))
+                        continue;
+                    if (['submit', 'settle'].includes(checkpoint.phase) && checkpoint.pageId === p.id)
+                        continue;
+                }
+            }
+            await retireBody(o, p);
+        }
+        const s = await open(tx);
+        if (s.team.current?.epoch === o.head.epoch) {
+            s.journal.acknowledged = o.head.acknowledged;
+            flushAuthority(s);
+        }
+    }, context);
+}

package/dist/authority/panel.d.ts

@@ -0,0 +1,121 @@
+import type { Tx } from '@earendil-works/pi-durable';
+export declare function readTeamSummary(tx: Tx): Promise<{
+    team: import("./state.ts").TeamState;
+    attention: Record<string, "blocked" | "failed">;
+    taskCount: number;
+}>;
+export declare function readTeamPanel(tx: Tx, storeId: string): Promise<{
+    team: null;
+    messages?: undefined;
+    leadThreadId?: undefined;
+    graphVersion?: undefined;
+    tasks?: undefined;
+    workers?: undefined;
+    events?: undefined;
+    alerts?: undefined;
+    deliveries?: undefined;
+} | {
+    messages: {
+        availability: "available";
+        source: string;
+        epoch: string;
+        limits: {
+            alerts: number;
+            deliveries: number;
+            events: number;
+        };
+        records: ({
+            status: string;
+            task?: string | undefined;
+            kind: "alert";
+            id: string;
+            at: number | null;
+            from: string;
+            to: string[];
+            alertKind: string;
+            text: string;
+        } | {
+            outcome?: string | undefined;
+            submissionId?: string | undefined;
+            settledAt?: number | undefined;
+            submittedAt?: number | undefined;
+            acceptedAt?: number | undefined;
+            kind: "delivery";
+            id: string;
+            at: number | null;
+            from: string | null;
+            to: string[];
+            deliveryKind: "task" | "stop" | "alert";
+            ref: string;
+            status: string;
+            conversationId: string;
+            generation: number;
+        } | {
+            status: string;
+            worker?: string | undefined;
+            tasks?: string[] | undefined;
+            task?: string | undefined;
+            text?: string | undefined;
+            kind: "lead-update";
+            id: string;
+            at: number | null;
+            from: string;
+            to: string[];
+            eventKind: string;
+        })[];
+    };
+    team: {
+        name: string;
+        purpose: string;
+        status: "active" | "stopped";
+        createdAt: number | undefined;
+        leadConversationId: string;
+    };
+    leadThreadId: string;
+    graphVersion: string;
+    tasks: import("./store.ts").OperatorTask[];
+    workers: {
+        name: string;
+        scope: string;
+        modelRole: string;
+        createdAt: number | undefined;
+        threadId: string;
+        membership: {
+            deactivationReason?: "stopping" | "stopped" | undefined;
+            id: string;
+            generation: number;
+            conversationId: string;
+            active: boolean;
+        };
+    }[];
+    events: {
+        detail?: string | undefined;
+        worker?: string | undefined;
+        task?: string | undefined;
+        actor: string;
+        kind: string;
+        ts?: number | undefined;
+        seq: number;
+    }[];
+    alerts: {
+        task_id?: string | undefined;
+        id: string;
+        ts: number;
+        from: string;
+        to: string;
+        kind: string;
+        text: string;
+    }[];
+    deliveries: {
+        settled?: string | undefined;
+        settledAt?: number | undefined;
+        submissionId?: string | undefined;
+        submittedAt?: number | undefined;
+        id: string;
+        kind: string;
+        ref: string;
+        to: string;
+        toConversationId: string;
+        acceptedAt: number | undefined;
+    }[];
+}>;

package/dist/authority/panel.js

@@ -0,0 +1,44 @@
+import { plain } from "./state.js";
+import { openAuthority, taskRecord, taskIds, recentEvents, obligation } from "./store.js";
+import { currentAlerts } from "./projection.js";
+export async function readTeamSummary(tx) {
+    const s = await openAuthority(tx);
+    return { team: plain(s.team), attention: plain(s.head.attention), taskCount: s.head.taskCount };
+}
+export async function readTeamPanel(tx, storeId) {
+    const s = await openAuthority(tx), team = s.team.current;
+    if (!team)
+        return { team: null };
+    const tasks = (await Promise.all((await taskIds(s)).map(async (id) => (await taskRecord(s, id)).operator)))
+        .map(plain).sort((a, b) => a.key.localeCompare(b.key));
+    const alerts = await currentAlerts(s, s.head.recentAlerts);
+    const deliveries = (await Promise.all(s.head.recentObligations.map(key => obligation(s, key)))).filter((o) => !!o && o.epoch === team.epoch);
+    const alertById = new Map(alerts.map(a => [a.id, a]));
+    const missing = [...new Set(deliveries.filter(o => o.kind === 'alert' && o.alertId && !alertById.has(o.alertId)).map(o => o.alertId))];
+    for (const a of await currentAlerts(s, missing))
+        alertById.set(a.id, a);
+    const journal = (await recentEvents(s)).filter(e => e.epoch === team.epoch).slice(-80);
+    const records = [
+        ...alerts.map((a) => ({ kind: 'alert', id: a.id, at: Number.isFinite(Date.parse(a.receivedAt)) ? Date.parse(a.receivedAt) : null, from: a.from, to: a.recipients.map(r => r.name), alertKind: a.kind, text: a.text, ...(a.task_id ? { task: a.task_id } : {}), status: 'accepted' })),
+        ...deliveries.map((o) => ({ kind: 'delivery', id: o.key, at: o.settledAt ?? o.submittedAt ?? o.acceptedAt ?? null,
+            from: o.kind === 'alert' ? (alertById.get(o.alertId ?? '')?.from ?? null) : 'authority', to: [o.recipient],
+            deliveryKind: o.kind, ref: o.alertId ?? o.taskId ?? '', status: o.state === 'retired' ? 'retired' : o.state === 'settled' ? 'settled' : o.submissionId !== undefined || o.submittedAt !== undefined ? 'submitted' : 'accepted',
+            conversationId: String(o.conversationId), generation: o.generation,
+            ...(o.acceptedAt !== undefined ? { acceptedAt: o.acceptedAt } : {}), ...(o.submittedAt !== undefined ? { submittedAt: o.submittedAt } : {}),
+            ...(o.settledAt !== undefined ? { settledAt: o.settledAt } : {}), ...(o.submissionId !== undefined ? { submissionId: String(o.submissionId) } : {}), ...(o.outcome ? { outcome: o.outcome } : {}) })),
+        ...journal.filter(e => ['team_created', 'team_stopped', 'worker_created', 'worker_stopped', 'graph_applied', 'task_transitioned'].includes(e.kind)).map((e) => ({
+            kind: 'lead-update', id: String(e.seq), at: e.at ? Date.parse(e.at) : null, from: e.actor, to: ['team-lead'], eventKind: e.kind,
+            ...(e.text ? { text: e.text } : {}), ...(e.taskId ? { task: e.taskId } : {}), ...(e.taskIds ? { tasks: e.taskIds } : {}), ...(e.worker ? { worker: e.worker } : {}), status: 'recorded'
+        })),
+    ];
+    const messages = { availability: 'available', source: `durable:${storeId}`, epoch: team.epoch, limits: { alerts: 30, deliveries: 60, events: 80 }, records };
+    return {
+        messages,
+        team: { name: team.name, purpose: team.purpose, status: team.lifecycle, createdAt: team.createdAt, leadConversationId: String(team.lead) },
+        leadThreadId: `${storeId}.${team.lead}`, graphVersion: s.head.graph?.revision?.version ?? '', tasks,
+        workers: Object.values(team.workers).map(w => ({ name: w.name, scope: w.scope, modelRole: w.role.name, createdAt: w.createdAt, threadId: `${storeId}.${w.conversationId}`, membership: { id: `${team.epoch}:${w.name}:g${w.generation}`, generation: w.generation, conversationId: String(w.conversationId), active: w.state === 'active', ...(w.state !== 'active' ? { deactivationReason: w.state } : {}) } })),
+        events: journal.map(e => ({ seq: e.seq, ...(e.at ? { ts: Date.parse(e.at) } : {}), actor: e.actor, kind: e.kind, ...(e.taskId ? { task: e.taskId } : {}), ...(e.worker ? { worker: e.worker } : {}), ...(e.text ? { detail: e.text } : {}) })),
+        alerts: alerts.map(a => ({ id: a.id, ts: Date.parse(a.receivedAt), from: a.from, to: a.recipients.map(r => r.name).join(', '), kind: a.kind, text: a.text, ...(a.task_id ? { task_id: a.task_id } : {}) })),
+        deliveries: deliveries.map(o => ({ id: o.key, kind: o.kind === 'stop' ? 'update' : o.kind, ref: o.taskId ?? o.alertId ?? '', to: o.recipient, toConversationId: String(o.conversationId), acceptedAt: o.acceptedAt, ...(o.submittedAt !== undefined ? { submittedAt: o.submittedAt } : {}), ...(o.submissionId !== undefined ? { submissionId: String(o.submissionId) } : {}), ...(o.settledAt !== undefined ? { settledAt: o.settledAt } : {}), ...(o.outcome ? { settled: o.outcome } : o.state === 'retired' && o.submissionId === undefined ? { settled: 'retired' } : {}) })),
+    };
+}

package/dist/authority/projection.d.ts

@@ -0,0 +1,5 @@
+import { type Result, type ModelRole, type Alert } from './state.ts';
+import { type Authority as State } from './store.ts';
+/** Read only the requested Alert records in the current Team epoch. */
+export declare function currentAlerts(s: State, ids: readonly string[]): Promise<Alert[]>;
+export declare function snapshotResult(s: State, modelRoles: ModelRole[], defaultModelRole?: string): Promise<Result>;

package/dist/authority/projection.js

@@ -0,0 +1,15 @@
+import { taskCards, alertRecord } from "./store.js";
+/** Read only the requested Alert records in the current Team epoch. */
+export async function currentAlerts(s, ids) {
+    const epoch = s.team.current?.epoch;
+    if (epoch === undefined)
+        return [];
+    return (await Promise.all(ids.map(id => alertRecord(s, id)))).filter((a) => !!a && a.id.startsWith(`${epoch}:`));
+}
+export async function snapshotResult(s, modelRoles, defaultModelRole) {
+    const team = s.team.current, cards = await taskCards(s);
+    const received = await currentAlerts(s, [...s.head.leadAlerts].reverse());
+    return { kind: 'snapshot', team: { name: team.name, purpose: team.purpose, lifecycle: 'active' }, model_roles: modelRoles.map(r => ({ name: r.name, use: r.use })), ...(defaultModelRole ? { default_model_role: defaultModelRole } : {}),
+        workers: Object.values(team.workers).map(w => ({ name: w.name, scope: w.scope, carrier: w.state === 'active' ? 'connected' : 'absent', model_role: w.role.name, nonterminal_task_ids: cards.filter(t => t.assignee === w.name && !['goal_achieved', 'goal_failed', 'cancelled'].includes(t.status)).map(t => t.id) })),
+        tasks: cards, alerts: received.slice(0, 10).map(a => { const chars = Array.from(a.text); return { alert_id: a.id, from: a.from, kind: a.kind, ...(a.task_id ? { task_id: a.task_id } : {}), ...(a.task_version ? { task_version: a.task_version } : {}), received_at: a.receivedAt, text: chars.slice(0, 2000).join(''), ...(chars.length > 2000 ? { truncated: true, text_length: chars.length } : {}) }; }), alerts_omitted: Math.max(0, s.head.leadAlertCount - 10) };
+}