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

package/dist/authority/observation.js

@@ -1,33 +1,21 @@
-import { createHash } from 'node:crypto';
-import { defineDoc, GenerationTask, hook, LiveDoc } from '@earendil-works/pi-durable';
-import { open, plain } from "./state.js";
-export const ObservationDoc = defineDoc({ kind: 'ptb.observation', version: 1, scope: 'session', initial: () => ({ pages: {}, proofs: {}, acknowledged: 0 }), checkpointWhen: (_v, _o, i) => i.deltasSinceBase >= 31 });
-export const digest = (value) => createHash('sha256').update(typeof value === 'string' ? value : JSON.stringify(value)).digest('hex');
-export const observations = async (tx) => await tx.doc(ObservationDoc);
-export function reservationHead(o, epoch, run) {
-    return Math.max(o.epoch === epoch ? o.acknowledged : 0, ...Object.values(o.pages).filter(p => p.epoch === epoch && p.run === run && (p.state === 'reserved' || p.state === 'presented')).map(p => p.through));
-}
-export function reserve(o, input, result) {
-    if (o.epoch !== input.epoch) {
-        o.epoch = input.epoch;
-        o.acknowledged = 0;
-        o.paused = false;
-    }
-    if (o.pages[input.id])
-        return o.pages[input.id];
-    const body = JSON.stringify(result), page = { ...input, body, digest: digest(body), state: 'reserved' };
-    o.pages[input.id] = page;
-    return page;
-}
+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;
-    return messages.some(message => 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));
+    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, {
@@ -37,20 +25,28 @@ export function observationExtension(resolvePort) {
                     if (run === undefined)
                         return;
                     await port.commit(async (tx) => {
-                        const o = await observations(tx), ids = [];
-                        for (const p of Object.values(o.pages)) {
-                            if (p.lead !== api.conversationId || (p.run !== run && p.run !== 0) || !['reserved', 'presented'].includes(p.state))
+                        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)) {
-                                p.run = run;
                                 ids.push(p.id);
-                                p.state = 'presented';
+                                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)
+                            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.
-                        o.proofs[String(api.taskId)] = { generation: api.taskId, lead: api.conversationId, run, requestDigest: digest(request.messages), pages: ids };
+                        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) => {
@@ -60,66 +56,88 @@ export function observationExtension(resolvePort) {
 }
 export async function recordResponse(port, api, message, context) {
     await port.commit(async (tx) => {
-        const o = await observations(tx), proof = o.proofs[String(api.taskId)];
-        if (proof && ['stop', 'length', 'toolUse'].includes(message.stopReason))
-            proof.responseDigest = digest(message);
+        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);
 }
-/** Later observer: native response persistence and run settlement are both required. */
+/** 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) => plain(await observations(tx)), context);
-    const proofs = Object.values(snapshot.proofs);
+    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();
-    // Generation checkpoints/results name their persisted assistant entry. No transcript scan.
-    for (const proof of proofs) {
-        if (!proof.responseDigest || !proof.pages.length)
+    for (const p of snapshot.proofs) {
+        if (!p.responseDigest || !p.pages.length)
             continue;
-        const native = await harness.getTask(proof.generation, context), state = native?.state;
+        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 === proof.generation && entry.kind === 'pi.assistant' && entry.model?.some(m => digest(m) === proof.responseDigest))
-            for (const id of proof.pages)
+        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 page of Object.values(snapshot.pages)) {
-        if (!['reserved', 'presented'].includes(page.state) || runs.has(page.run))
-            continue;
-        const submission = await harness.submission(page.run, context), record = await submission?.status(context);
-        runs.set(page.run, record?.status === 'done' ? 'success' : record?.status === 'unanswered' ? 'failure' : 'live');
+    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 observations(tx), s = await open(tx);
-        for (const p of Object.values(o.pages)) {
-            if (!['reserved', 'presented'].includes(p.state))
-                continue;
-            // Only unchanged persisted evidence may settle this reservation.
-            if (JSON.stringify(p) !== JSON.stringify(snapshot.pages[p.id]))
+        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 === 'live')
+            if (outcome !== 'success' && outcome !== 'failure')
                 continue;
-            const stableProof = Object.values(o.proofs).some(proof => proof.pages.includes(p.id) && JSON.stringify(proof) === JSON.stringify(snapshot.proofs[String(proof.generation)]));
-            if (outcome === 'success' && witnessed.has(p.id) && stableProof) {
+            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 if (outcome === 'failure' || outcome === 'success') {
+            else {
                 p.state = 'released';
                 if (outcome === 'failure')
-                    o.paused = true;
+                    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));
         }
-        for (let advanced = true; advanced;) {
-            advanced = false;
-            for (const p of Object.values(o.pages))
-                if (p.epoch === o.epoch && p.state === 'acknowledged' && p.from <= o.acknowledged && p.through > o.acknowledged) {
-                    o.acknowledged = p.through;
-                    advanced = true;
+        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);
         }
-        if (s.team.current?.epoch === o.epoch)
-            s.journal.acknowledged = o.acknowledged;
     }, 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

@@ -1,4 +1,5 @@
-import { type State, type Result, type ModelRole } from './state.ts';
-/** Alert IDs carry their Team epoch; consumers do not parse that identity. */
-export declare function currentAlerts(s: State): import("./state.ts").Alert[];
-export declare function snapshotResult(s: State, modelRoles: ModelRole[], defaultModelRole?: string): Result;
+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

@@ -1,15 +1,15 @@
-import { GraphTaskController } from "./graph-control.js";
-import { projectGraphTaskCards } from "./graph-card.js";
-import { plain } from "./state.js";
-/** Alert IDs carry their Team epoch; consumers do not parse that identity. */
-export function currentAlerts(s) {
+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;
-    return epoch === undefined ? [] : Object.values(s.outbox.alerts).filter(a => a.id.startsWith(`${epoch}:`));
+    if (epoch === undefined)
+        return [];
+    return (await Promise.all(ids.map(id => alertRecord(s, id)))).filter((a) => !!a && a.id.startsWith(`${epoch}:`));
 }
-export function snapshotResult(s, modelRoles, defaultModelRole) {
-    const team = s.team.current, graph = GraphTaskController.recover(plain(s.graph.snapshot));
-    const received = currentAlerts(s).filter(a => a.recipients.some(r => r.name === 'team-lead' && r.conversationId === team.lead)).reverse();
+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: graph.readTasks().filter(t => t.assignee === w.name && !['goal_achieved', 'goal_failed', 'cancelled'].includes(t.state.kind)).map(t => t.id) })),
-        tasks: projectGraphTaskCards(graph), 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, received.length - 10) };
+        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) };
 }

package/dist/authority/rc7-contract.json

@@ -7,7 +7,9 @@
       "src/model-tool-contract/catalog.ts": "99b45ac334660047f573707aa7ba1de064212f847449c5019c05b32674c385a2",
       "src/model-tool-contract/result-projection.ts": "e5df0bc33d8617a5f749975b59f66d3b3c2b44aa0401b5b4d6a87b05452ce9cc",
       "src/model-tool-contract/worker-parameters.ts": "46e727fdbe3c1ea22e59e8b27cd0f349a80648a8bb1656b891cc05bfe0ddc4a8",
-      "src/task-authority/graph-control-schemas.ts": "0de45ef0eaa6774289c961bfd9f661a7a92078432c0e4b2167a503d840e1e709"
+      "src/task-authority/graph-control-schemas.ts": "0de45ef0eaa6774289c961bfd9f661a7a92078432c0e4b2167a503d840e1e709",
+      "src/model-tool-contract/pi-registration.ts": "487320f04f9480e8c661d61c5c54de4ed801e83d99545107a95ce0f009223aac",
+      "extensions/index.ts": "a5e233c6d011903b664261d3b5a31ebac2f0acf5af7f26497e373442312cb36f"
     }
   },
   "lead": {
@@ -9330,5 +9332,59 @@
         }
       ]
     }
+  },
+  "presentation": {
+    "lead": {
+      "team_create": {
+        "label": "Create Team",
+        "description": "Create and bind one active Team for this leader Session. Does not create Workers or Tasks."
+      },
+      "team_sync": {
+        "label": "Sync Team",
+        "description": "Return a whole-Team snapshot or incremental coordination updates. Use task_read for selected complete Task cards. Snapshots also list recent received Alerts; recent is not unresolved."
+      },
+      "ensure_worker": {
+        "label": "Ensure Worker",
+        "description": "Create or reuse a Worker for a standing area. Assign work with task_graph_apply."
+      },
+      "task_graph_apply": {
+        "label": "Apply Task Graph",
+        "description": "Atomically apply the complete assigned Task graph revision. Task authority then derives readiness and bounded failure routing."
+      },
+      "task_read": {
+        "label": "Read Tasks",
+        "description": "Read complete current cards for selected Tasks. Use team_sync for whole-Team observation."
+      },
+      "task_update": {
+        "label": "Update Tasks",
+        "description": "Apply one exact-version Task transition or context update. Waiting and ready remain derived."
+      },
+      "worker_stop": {
+        "label": "Stop Worker",
+        "description": "Stop one Worker after its nonterminal assigned Tasks resolve. Does not change Tasks."
+      },
+      "team_shutdown": {
+        "label": "Shutdown Team",
+        "description": "Stop remaining Workers and close the Team. A partial failure leaves it active for retry."
+      },
+      "alert_send": {
+        "label": "Send Alert",
+        "description": "Send exceptional Alerts to a Worker or announce to *. Accepted means stored, not presented or processed. Task state stays unchanged."
+      }
+    },
+    "worker": {
+      "task_read": {
+        "label": "Read Task",
+        "description": "Read current Task cards by ID from the active Team."
+      },
+      "task_update": {
+        "label": "Update Task",
+        "description": "Apply one explicit graph-native Task transition with an exact Task version. dependency_waiting and ready are derived."
+      },
+      "alert_send": {
+        "label": "Send Alert",
+        "description": "Send exceptional clarification or attention to team-lead. Accepted means stored, not presented or processed."
+      }
+    }
   }
 }

package/dist/authority/runtime.d.ts

@@ -29,8 +29,44 @@ export interface RuntimeOptions extends Pick<CoreOptions, 'modelRoles' | 'defaul
 }
 export declare function createTeamRuntime(options: RuntimeOptions): {
     core: {
-        lead: import("@earendil-works/pi-durable").ToolRegistration<import("typebox").TSchema, import("@earendil-works/chord").JsonValue>[];
-        worker: import("@earendil-works/pi-durable").ToolRegistration<import("typebox").TSchema, import("@earendil-works/chord").JsonValue>[];
+        lead: {
+            label: string;
+            name: string;
+            description: string;
+            parameters: import("typebox").TSchema;
+            constrainedSampling?: false | import("@earendil-works/pi-ai").ConstrainedSamplingConfig;
+            replay?: "safe" | "unsafe";
+            executionMode?: import("@earendil-works/pi-durable").ToolExecutionMode;
+            prepareArguments?(args: unknown): unknown;
+            structuredOutputSchema?: import("typebox").TSchema;
+            callers?: readonly ("model" | "tools")[];
+            deferred?: true;
+            outputLimits?: {
+                readonly maxBytes?: number;
+                readonly maxLines?: number;
+                readonly retain?: "head" | "tail";
+            };
+            execute(args: unknown, api: import("@earendil-works/pi-durable").ToolExecutionApi<import("@earendil-works/chord").JsonValue>, context: Context): Promise<import("@earendil-works/pi-durable").ToolExecutionResult<import("@earendil-works/chord").JsonValue>>;
+        }[];
+        worker: {
+            label: string;
+            name: string;
+            description: string;
+            parameters: import("typebox").TSchema;
+            constrainedSampling?: false | import("@earendil-works/pi-ai").ConstrainedSamplingConfig;
+            replay?: "safe" | "unsafe";
+            executionMode?: import("@earendil-works/pi-durable").ToolExecutionMode;
+            prepareArguments?(args: unknown): unknown;
+            structuredOutputSchema?: import("typebox").TSchema;
+            callers?: readonly ("model" | "tools")[];
+            deferred?: true;
+            outputLimits?: {
+                readonly maxBytes?: number;
+                readonly maxLines?: number;
+                readonly retain?: "head" | "tail";
+            };
+            execute(args: unknown, api: import("@earendil-works/pi-durable").ToolExecutionApi<import("@earendil-works/chord").JsonValue>, context: Context): Promise<import("@earendil-works/pi-durable").ToolExecutionResult<import("@earendil-works/chord").JsonValue>>;
+        }[];
         execute: (name: import("./contracts.ts").ToolName, role: import("./contracts.ts").Role, input: unknown, api: CoreApi, context: Context) => Promise<import("./state.ts").Result>;
         contract: import("./contracts.ts").Contract;
     };

package/dist/authority/runtime.js

@@ -3,9 +3,10 @@ import { catalogOf, createAuthorityTools } from "./tools.js";
 import { createAnchoredConversation, WorkerAnchor } from "./anchor.js";
 import { createDeliver, scheduleDeliveries } from "./delivery.js";
 import { createNotifier } from "./notifier.js";
-import { observations, observationExtension } from "./observation.js";
+import { openObservations, startObservationEpoch, observationExtension } from "./observation.js";
 import { sync } from "./sync.js";
-import { open, event } from "./state.js";
+import { event } from "./state.js";
+import { openAuthority as open, flushAuthority, allObligations, setObligationState } from "./store.js";
 export const stopPlan = (id, intent) => ({ id, conversations: intent.conversations.map(String), tasks: intent.tasks.map(String) });
 export async function pendingStops(harness, context) {
     return harness.commit(async (tx) => Object.entries((await open(tx)).team.stops).filter(([, i]) => !i.confirmed).map(([id, i]) => stopPlan(id, i)), context);
@@ -42,19 +43,19 @@ export async function confirmStop(harness, id, outcome, context, now = Date.now)
         }
     }, context);
 }
-function addMechanicStops(s, shutdown) {
-    const team = s.team.current;
+async function addMechanicStops(s, shutdown) {
+    const team = s.team.current, obligations = await allObligations(s);
     for (const intent of Object.values(s.team.stops)) {
         if (intent.epoch !== team.epoch || intent.confirmed)
             continue;
-        for (const o of Object.values(s.outbox.obligations))
+        for (const o of obligations)
             if (o.epoch === team.epoch && o.recipient === intent.worker && o.deliveryTaskId && !intent.tasks.includes(o.deliveryTaskId))
                 intent.tasks.push(o.deliveryTaskId);
     }
     if (!shutdown)
         return;
     const key = `${team.epoch}:shutdown-mechanics`;
-    const tasks = Object.values(s.outbox.obligations).filter(o => o.epoch === team.epoch && o.deliveryTaskId).map(o => o.deliveryTaskId);
+    const tasks = obligations.filter(o => o.epoch === team.epoch && o.deliveryTaskId).map(o => o.deliveryTaskId);
     if (team.notifierId)
         tasks.push(team.notifierId);
     s.team.stops[key] ??= { epoch: team.epoch, tasks, conversations: [], confirmed: false };
@@ -73,10 +74,11 @@ export async function closing(harness, conversationId, context) {
                 w.state = 'stopping';
                 s.team.stops[key] ??= { epoch: team.epoch, worker: w.name, generation: w.generation, binding: { conversationId: w.conversationId, anchorId: w.anchorId }, tasks: [w.anchorId], conversations: [w.conversationId], confirmed: false };
             }
-        for (const o of Object.values(s.outbox.obligations))
+        for (const o of await allObligations(s))
             if (o.epoch === team.epoch)
-                o.state = 'retired';
-        addMechanicStops(s, true);
+                await setObligationState(s, o, 'retired');
+        await addMechanicStops(s, true);
+        flushAuthority(s);
         return Object.entries(s.team.stops).filter(([, i]) => i.epoch === team.epoch && !i.confirmed).map(([id, i]) => stopPlan(id, i));
     }, context);
 }
@@ -96,15 +98,12 @@ export function createTeamRuntime(options) {
             if (!team || team.lifecycle !== 'active')
                 return;
             if (name === 'team_create') {
-                const o = await observations(tx);
-                o.epoch = team.epoch;
-                o.acknowledged = 0;
-                o.paused = false;
+                startObservationEpoch(await openObservations(tx), team.epoch);
             }
             if (!team.notifierId && !team.shutdownPending)
                 team.notifierId = await tx.createTask(Notify, { epoch: team.epoch }, { conversationId: team.lead, ownership: { kind: 'conversation' }, background: true, abandonOnRestart: false });
             await scheduleDeliveries(tx, s, Deliver);
-            const extra = addMechanicStops(s, name === 'team_shutdown');
+            const extra = name === 'worker_stop' || name === 'team_shutdown' ? await addMechanicStops(s, name === 'team_shutdown') : undefined;
             if (extra && Array.isArray(result.stops) && !result.stops.includes(extra))
                 result.stops.push(extra);
         }, });