attention-manifest-protocol 0.4.2 → 0.4.3

package/lib/assignment/assign.js

@@ -0,0 +1,556 @@
+import { digestOf } from "../semantic/canonical.js";
+import { AssignmentError } from "./errors.js";
+import { authorityWithin, budgetWithin, BudgetDimensions, dutyConflict, windowWithin, windowsOverlap } from "./guards.js";
+const fail = (code, problems) => {
+    throw new AssignmentError(code, problems);
+};
+const clone = (value) => structuredClone(value);
+const seal = (assignment) => {
+    const body = { ...assignment };
+    delete body.digest;
+    delete body.signatures;
+    assignment.digest = digestOf(body);
+    return assignment;
+};
+const normalizeAcceptance = (input) => {
+    if (input === (void 0)) {
+        return { required: true, state: "pending" };
+    }
+    return {
+        required: input.required,
+        state: input.state,
+        ...(input.by === (void 0) ? {} : { by: input.by }),
+        ...(input.at === (void 0) ? {} : { at: input.at }),
+        ...(input.digest === (void 0) ? {} : { digest: input.digest }),
+        ...(input.note === (void 0) ? {} : { note: input.note }),
+    };
+};
+const validateDuties = (duties) => {
+    if (duties.length === 0) {
+        fail("assignment_invalid", ["at least one duty is required"]);
+    }
+    const seen = new Set();
+    for (let index = 0; index < duties.length; index += 1) {
+        const duty = duties[index];
+        if (duty.id.length === 0) {
+            fail("assignment_invalid", ["a duty id must not be empty"]);
+        }
+        if (seen.has(duty.id)) {
+            fail("assignment_invalid", [`duplicate duty ${duty.id}`]);
+        }
+        seen.add(duty.id);
+        if (duty.statement.trim().length === 0) {
+            fail("assignment_invalid", [`duty ${duty.id} has an empty statement`]);
+        }
+        if (duty.acceptance.length === 0) {
+            fail("assignment_invalid", [`duty ${duty.id} needs at least one acceptance criterion`]);
+        }
+        if ((duty.conflicts_with ?? []).includes(duty.id)) {
+            fail("assignment_invalid", [`duty ${duty.id} conflicts with itself`]);
+        }
+    }
+};
+const validateAuthority = (authority) => {
+    const seen = new Set();
+    for (let index = 0; index < authority.length; index += 1) {
+        const action = authority[index];
+        if (action.length === 0) {
+            fail("assignment_invalid", ["authority actions must not be empty"]);
+        }
+        if (seen.has(action)) {
+            fail("assignment_invalid", [`duplicate authority ${action}`]);
+        }
+        seen.add(action);
+    }
+};
+const validateBudget = (budget) => {
+    for (let index = 0; index < BudgetDimensions.length; index += 1) {
+        const dimension = BudgetDimensions[index];
+        const value = budget[dimension];
+        if (value !== (void 0) && (!Number.isFinite(value) || value < 0)) {
+            fail("assignment_invalid", [`budget ${dimension} must be a finite non-negative number`]);
+        }
+    }
+};
+const validateWindow = (window) => {
+    const from = Date.parse(window.from);
+    const to = Date.parse(window.to);
+    if (!Number.isFinite(from) || !Number.isFinite(to) || from >= to) {
+        fail("assignment_invalid", ["window must be a valid interval with from < to"]);
+    }
+};
+const validateRaci = (input, independent) => {
+    const raci = input.raci;
+    if (raci === (void 0)) {
+        return;
+    }
+    const accountable = raci.accountable;
+    if (accountable !== input.assigner && accountable !== input.assignee) {
+        fail("accountable_not_party", [`${accountable} is neither the assigner nor the assignee`]);
+    }
+    if (raci.responsible.length === 0) {
+        fail("assignment_invalid", ["raci.responsible must not be empty"]);
+    }
+    const requiresIndependence = input.duties.some((duty) => independent.includes(duty.id));
+    if (requiresIndependence) {
+        if (input.assigner === input.assignee) {
+            fail("self_approval", ["an independent duty cannot be self-assigned"]);
+        }
+        if (accountable === input.assigner) {
+            fail("self_approval", ["the assigner cannot be the accountable party of an independent duty"]);
+        }
+    }
+};
+export class AssignmentLedger {
+    assignments = new Map();
+    eventLog = [];
+    now;
+    onRevoke;
+    constructor(options) {
+        if (typeof (options.now) !== "function") {
+            throw new TypeError("AssignmentLedger requires a clock");
+        }
+        this.now = options.now;
+        this.onRevoke = options.onRevoke;
+    }
+    create(input, policy = {}) {
+        if (input.id.length === 0) {
+            fail("assignment_invalid", ["an assignment id must not be empty"]);
+        }
+        if (this.assignments.has(input.id)) {
+            fail("assignment_invalid", [`assignment ${input.id} already exists`]);
+        }
+        if (input.assigner.length === 0 || input.assignee.length === 0) {
+            fail("assignment_invalid", ["assigner and assignee must not be empty"]);
+        }
+        if (input.why.trim().length === 0) {
+            fail("assignment_invalid", ["why must not be empty"]);
+        }
+        validateDuties(input.duties);
+        validateAuthority(input.authority);
+        validateBudget(input.budget);
+        validateWindow(input.window);
+        validateRaci(input, policy.independentDuties ?? []);
+        let depth = input.depth ?? 0;
+        if (depth < 0 || depth > 2) {
+            fail("depth_exceeded", [`depth ${depth} exceeds 2`]);
+        }
+        if (input.parent !== (void 0)) {
+            const parent = this.assignments.get(input.parent);
+            if (parent === (void 0)) {
+                throw new AssignmentError("parent_unavailable", [`unknown parent ${input.parent}`]);
+            }
+            if (!parent.delegable) {
+                fail("depth_exceeded", [`${parent.id} is not delegable`]);
+            }
+            if (parent.status !== "active" && parent.status !== "accepted") {
+                fail("parent_unavailable", [`parent ${parent.id} is ${parent.status}`]);
+            }
+            depth = parent.depth + 1;
+            if (depth > 2) {
+                fail("depth_exceeded", [`depth ${depth} exceeds 2`]);
+            }
+            if (!authorityWithin(input.authority, parent.authority)) {
+                fail("authority_widened", [`authority exceeds ${parent.id}`]);
+            }
+            if (!budgetWithin(input.budget, parent.budget)) {
+                fail("budget_widened", [`budget exceeds ${parent.id}`]);
+            }
+            if (!windowWithin(input.window, parent.window)) {
+                fail("window_widened", [`window exceeds ${parent.id}`]);
+            }
+        }
+        if (policy.authority !== (void 0) && !authorityWithin(input.authority, policy.authority)) {
+            fail("authority_widened", ["authority exceeds the assigner policy"]);
+        }
+        if (policy.budget !== (void 0) && !budgetWithin(input.budget, policy.budget)) {
+            fail("budget_widened", ["budget exceeds the assigner policy"]);
+        }
+        if (policy.window !== (void 0) && !windowWithin(input.window, policy.window)) {
+            fail("window_widened", ["window exceeds the assigner policy"]);
+        }
+        if (policy.maxDepth !== (void 0) && depth > policy.maxDepth) {
+            fail("depth_exceeded", [`depth ${depth} exceeds policy ${policy.maxDepth}`]);
+        }
+        const created = input.created ?? this.now();
+        const dutyEvidence = [];
+        for (let index = 0; index < input.duties.length; index += 1) {
+            const required = input.duties[index].evidence_required ?? [];
+            for (let requiredIndex = 0; requiredIndex < required.length; requiredIndex += 1) {
+                if (!dutyEvidence.includes(required[requiredIndex])) {
+                    dutyEvidence.push(required[requiredIndex]);
+                }
+            }
+        }
+        const evidenceRequired = [...new Set([...(input.evidence?.required ?? []), ...dutyEvidence])];
+        const evidenceProduced = (input.evidence?.produced ?? []).map((ref) => ({ ...ref }));
+        const acceptance = normalizeAcceptance(input.acceptance);
+        if (acceptance.state === "accepted" && acceptance.by !== input.assignee) {
+            fail("acceptance_missing", ["acceptance must name the assignee"]);
+        }
+        const assignment = {
+            amp: "0.1",
+            kind: "responsibility-assignment",
+            id: input.id,
+            version: 1,
+            ...(input.parent === (void 0) ? {} : { parent: input.parent }),
+            assigner: input.assigner,
+            assignee: input.assignee,
+            ...(input.role === (void 0) ? {} : { role: input.role }),
+            duties: input.duties.map((duty) => ({
+                id: duty.id,
+                statement: duty.statement,
+                scope: [...duty.scope],
+                acceptance: duty.acceptance.map((criterion) => ({ ...criterion })),
+                ...(duty.evidence_required === (void 0) ? {} : { evidence_required: [...duty.evidence_required] }),
+                ...(duty.conflicts_with === (void 0) ? {} : { conflicts_with: [...duty.conflicts_with] }),
+                ...(duty.delegable === (void 0) ? {} : { delegable: duty.delegable }),
+            })),
+            ...(input.raci === (void 0)
+                ? {}
+                : {
+                    raci: {
+                        accountable: input.raci.accountable,
+                        responsible: [...input.raci.responsible],
+                        ...(input.raci.consulted === (void 0) ? {} : { consulted: [...input.raci.consulted] }),
+                        ...(input.raci.informed === (void 0) ? {} : { informed: [...input.raci.informed] }),
+                    },
+                }),
+            authority: [...input.authority],
+            budget: { ...input.budget },
+            window: { ...input.window },
+            acceptance,
+            evidence: { required: evidenceRequired, produced: evidenceProduced },
+            ...(input.out_of_scope === (void 0) ? {} : { out_of_scope: [...input.out_of_scope] }),
+            delegable: input.delegable ?? false,
+            depth,
+            status: "proposed",
+            why: input.why,
+            created,
+            ...(input.signatures === (void 0) ? {} : { signatures: input.signatures.map((signature) => ({ ...signature })) }),
+        };
+        this.assertSingleAccountable(assignment);
+        this.assertNoDutyConflict(assignment);
+        this.assignments.set(assignment.id, seal(assignment));
+        this.record("assignment.proposed", assignment, input.assigner, created, input.why);
+        return clone(assignment);
+    }
+    accept(id, by, at, digest) {
+        const assignment = this.require(id);
+        this.requireStatus(assignment, ["proposed"], "accept");
+        if (by !== assignment.assignee) {
+            fail("assignment_invalid", [`${by} is not the assignee of ${id}`]);
+        }
+        this.assertSingleAccountable(assignment);
+        this.assertNoDutyConflict(assignment);
+        assignment.acceptance = {
+            ...(assignment.acceptance ?? { required: true }),
+            state: "accepted",
+            by,
+            at,
+            ...(digest === (void 0) ? {} : { digest }),
+        };
+        assignment.status = "accepted";
+        seal(assignment);
+        this.record("assignment.accepted", assignment, by, at);
+        return clone(assignment);
+    }
+    decline(id, by, at, reason) {
+        const assignment = this.require(id);
+        this.requireStatus(assignment, ["proposed"], "decline");
+        if (by !== assignment.assignee) {
+            fail("assignment_invalid", [`${by} is not the assignee of ${id}`]);
+        }
+        if (reason.trim().length === 0) {
+            fail("assignment_invalid", ["a decline needs a reason"]);
+        }
+        assignment.acceptance = {
+            ...(assignment.acceptance ?? { required: true }),
+            state: "declined",
+            by,
+            at,
+            note: reason,
+        };
+        assignment.status = "declined";
+        seal(assignment);
+        this.record("assignment.declined", assignment, by, at, reason);
+        return clone(assignment);
+    }
+    activate(id, at) {
+        const assignment = this.require(id);
+        this.requireStatus(assignment, ["proposed", "accepted"], "activate");
+        if (assignment.acceptance !== (void 0) && assignment.acceptance.state === "declined") {
+            fail("acceptance_denied", [`${id} was declined`]);
+        }
+        if (assignment.acceptance !== (void 0) && assignment.acceptance.state === "accepted" && assignment.acceptance.by !== assignment.assignee) {
+            fail("acceptance_missing", [`${id} was not accepted by its assignee`]);
+        }
+        if (assignment.acceptance !== (void 0) && assignment.acceptance.required && assignment.acceptance.state !== "accepted") {
+            fail("acceptance_missing", [`${id} has not been accepted`]);
+        }
+        if (Date.parse(at) < Date.parse(assignment.window.from)) {
+            fail("window_not_started", [`${id} starts at ${assignment.window.from}`]);
+        }
+        if (assignment.parent !== (void 0)) {
+            const parent = this.assignments.get(assignment.parent);
+            if (parent === (void 0) || parent.status !== "active") {
+                fail("parent_unavailable", [`parent ${assignment.parent} is not active`]);
+            }
+        }
+        this.assertSingleAccountable(assignment);
+        this.assertNoDutyConflict(assignment);
+        assignment.status = "active";
+        seal(assignment);
+        this.record("assignment.activated", assignment, assignment.assigner, at);
+        return clone(assignment);
+    }
+    block(id, by, at, reason) {
+        const assignment = this.require(id);
+        this.requireStatus(assignment, ["active"], "block");
+        if (by !== assignment.assigner && by !== assignment.assignee) {
+            fail("assignment_invalid", [`${by} is not a party of ${id}`]);
+        }
+        if (reason.trim().length === 0) {
+            fail("assignment_invalid", ["a block needs a reason"]);
+        }
+        assignment.status = "blocked";
+        seal(assignment);
+        this.record("assignment.blocked", assignment, by, at, reason);
+        return clone(assignment);
+    }
+    resume(id, by, at) {
+        const assignment = this.require(id);
+        this.requireStatus(assignment, ["blocked"], "resume");
+        if (by !== assignment.assigner) {
+            fail("assignment_invalid", [`${by} cannot resume ${id}`]);
+        }
+        assignment.status = "active";
+        seal(assignment);
+        this.record("assignment.resumed", assignment, by, at);
+        return clone(assignment);
+    }
+    discharge(id, by, at, produced) {
+        const assignment = this.require(id);
+        this.requireStatus(assignment, ["active"], "discharge");
+        if (by !== assignment.assigner && by !== assignment.assignee) {
+            fail("assignment_invalid", [`${by} is not a party of ${id}`]);
+        }
+        const required = assignment.evidence?.required ?? [];
+        const evidence = produced.map((ref) => ({ ...ref }));
+        const missing = required.filter((kind) => !evidence.some((ref) => ref.kind === kind || ref.label === kind));
+        if (missing.length > 0) {
+            fail("evidence_missing", [`missing evidence: ${missing.join(", ")}`]);
+        }
+        assignment.evidence = {
+            required: [...required],
+            produced: [...(assignment.evidence?.produced ?? []), ...evidence],
+        };
+        assignment.status = "discharged";
+        seal(assignment);
+        this.record("assignment.discharged", assignment, by, at);
+        return clone(assignment);
+    }
+    breach(id, by, at, reason) {
+        const assignment = this.require(id);
+        this.requireStatus(assignment, ["active", "blocked"], "breach");
+        if (reason.trim().length === 0) {
+            fail("assignment_invalid", ["a breach needs a reason"]);
+        }
+        assignment.status = "breached";
+        seal(assignment);
+        this.record("assignment.breached", assignment, by, at, reason);
+        return clone(assignment);
+    }
+    revoke(id, by, at, reason) {
+        const root = this.require(id);
+        if (root.status === "revoked" || root.status === "discharged" || root.status === "expired" || root.status === "declined") {
+            fail("status_transition", [`${id} is ${root.status} and cannot be revoked`]);
+        }
+        if (reason.trim().length === 0) {
+            fail("assignment_invalid", ["a revoke needs a reason"]);
+        }
+        const stack = [id];
+        while (stack.length > 0) {
+            const current = stack.pop();
+            if (current === (void 0)) {
+                continue;
+            }
+            const assignment = this.assignments.get(current);
+            if (assignment === (void 0)) {
+                continue;
+            }
+            if (assignment.status === "revoked" || assignment.status === "discharged" || assignment.status === "expired" || assignment.status === "declined") {
+                continue;
+            }
+            assignment.status = "revoked";
+            seal(assignment);
+            this.record("assignment.revoked", assignment, by, at, reason);
+            this.onRevoke?.(clone(assignment));
+            for (const child of this.assignments.values()) {
+                if (child.parent === current) {
+                    stack.push(child.id);
+                }
+            }
+        }
+        return clone(this.require(id));
+    }
+    expire(id, at) {
+        const assignment = this.require(id);
+        if (Date.parse(at) <= Date.parse(assignment.window.to)) {
+            fail("status_transition", [`${id} is not past its window`]);
+        }
+        this.requireStatus(assignment, ["proposed", "accepted", "active", "blocked"], "expire");
+        assignment.status = "expired";
+        seal(assignment);
+        this.record("assignment.expired", assignment, "system", at);
+        return clone(assignment);
+    }
+    /**
+     * Expire every non-terminal assignment whose window has elapsed. Returns
+     * snapshots so a host can emit one audit record per expiry.
+     */
+    sweep(at) {
+        const expired = [];
+        for (const assignment of this.assignments.values()) {
+            if (assignment.status !== "proposed" &&
+                assignment.status !== "accepted" &&
+                assignment.status !== "active" &&
+                assignment.status !== "blocked") {
+                continue;
+            }
+            if (Date.parse(at) <= Date.parse(assignment.window.to)) {
+                continue;
+            }
+            assignment.status = "expired";
+            seal(assignment);
+            this.record("assignment.expired", assignment, "system", at);
+            expired.push(clone(assignment));
+        }
+        return expired;
+    }
+    get(id) {
+        return clone(this.require(id));
+    }
+    find(id) {
+        const assignment = this.assignments.get(id);
+        return assignment === (void 0) ? undefined : clone(assignment);
+    }
+    list() {
+        return [...this.assignments.values()].map((assignment) => clone(assignment));
+    }
+    children(id) {
+        return [...this.assignments.values()]
+            .filter((assignment) => assignment.parent === id)
+            .map((assignment) => clone(assignment));
+    }
+    events() {
+        return this.eventLog.map((event) => clone(event));
+    }
+    coverage(dutyIds) {
+        const covered = new Set();
+        for (const assignment of this.assignments.values()) {
+            if (assignment.status !== "active") {
+                continue;
+            }
+            for (const duty of assignment.duties) {
+                covered.add(duty.id);
+            }
+        }
+        return {
+            assigned: dutyIds.filter((id) => covered.has(id)),
+            unassigned: dutyIds.filter((id) => !covered.has(id)),
+        };
+    }
+    conflicts() {
+        const active = [...this.assignments.values()].filter((assignment) => assignment.status === "active");
+        const found = [];
+        for (let leftIndex = 0; leftIndex < active.length; leftIndex += 1) {
+            for (let rightIndex = leftIndex + 1; rightIndex < active.length; rightIndex += 1) {
+                const left = active[leftIndex];
+                const right = active[rightIndex];
+                if (left.assignee !== right.assignee || !windowsOverlap(left.window, right.window)) {
+                    continue;
+                }
+                for (const leftDuty of left.duties) {
+                    for (const rightDuty of right.duties) {
+                        if (dutyConflict(leftDuty, rightDuty)) {
+                            found.push({ left: left.id, right: right.id, duty: leftDuty.id, other: rightDuty.id, assignee: left.assignee });
+                        }
+                    }
+                }
+            }
+        }
+        return found;
+    }
+    assertNoConflicts() {
+        const found = this.conflicts();
+        if (found.length > 0) {
+            fail("duty_conflict", found.map((record) => `${record.assignee}: ${record.duty} conflicts with ${record.other}`));
+        }
+    }
+    /**
+     * A duty has one accountable owner. An accepted assignment already reserves
+     * the duty, so a second one is rejected before activation.
+     */
+    assertSingleAccountable(candidate) {
+        const candidateDuties = new Set(candidate.duties.map((duty) => duty.id));
+        for (const existing of this.assignments.values()) {
+            if (existing.id === candidate.id) {
+                continue;
+            }
+            if (existing.status !== "active" && existing.status !== "accepted") {
+                continue;
+            }
+            for (const duty of existing.duties) {
+                if (candidateDuties.has(duty.id)) {
+                    fail("multiple_accountable", [`duty ${duty.id} is already held by ${existing.id}`]);
+                }
+            }
+        }
+    }
+    assertNoDutyConflict(candidate) {
+        for (const existing of this.assignments.values()) {
+            if (existing.id === candidate.id) {
+                continue;
+            }
+            if (existing.assignee !== candidate.assignee) {
+                continue;
+            }
+            if (existing.status !== "active" && existing.status !== "accepted") {
+                continue;
+            }
+            if (!windowsOverlap(candidate.window, existing.window)) {
+                continue;
+            }
+            for (const left of candidate.duties) {
+                for (const right of existing.duties) {
+                    if (dutyConflict(left, right)) {
+                        fail("duty_conflict", [`${left.id} conflicts with ${right.id} for ${candidate.assignee}`]);
+                    }
+                }
+            }
+        }
+    }
+    require(id) {
+        const assignment = this.assignments.get(id);
+        if (assignment === (void 0)) {
+            throw new AssignmentError("assignment_invalid", [`unknown assignment ${id}`]);
+        }
+        return assignment;
+    }
+    requireStatus(assignment, allowed, action) {
+        if (!allowed.includes(assignment.status)) {
+            fail("status_transition", [`${assignment.id} is ${assignment.status}; cannot ${action}`]);
+        }
+    }
+    record(type, assignment, by, at, reason) {
+        this.eventLog.push({
+            type,
+            assignment: assignment.id,
+            at,
+            by,
+            ...(reason === (void 0) ? {} : { reason }),
+            ...(assignment.digest === (void 0) ? {} : { digest: assignment.digest }),
+        });
+    }
+}

package/lib/assignment/binding.d.ts

@@ -0,0 +1,103 @@
+/**
+ * Interaction binding ledger.
+ *
+ * A binding is the conversation contract between parties: who may talk to whom,
+ * under which protocol and mode mix, at what cadence, with what budget, and
+ * where a timeout or authority breach escalates. Messages are legal only while
+ * their binding is active.
+ */
+import type { Budget, Id, Ref, Signature, Timestamp } from "../types/common.js";
+import type { InteractionKind } from "../interaction/interaction.js";
+import type { BindingDirection, BindingEvent, BindingMessageRecord, InteractionBinding, InteractionCadence, InteractionChannel, InteractionEscalation, InteractionExpectations, InteractionHandoff, InteractionProtocol, Performative, ResponsibilityAssignment } from "./types.js";
+export interface BindingLedgerOptions {
+    now: () => Timestamp;
+}
+export interface BindingPolicy {
+    /**
+     * Required when the binding cites an assignment: the ledger never trusts a
+     * peer-supplied budget or assignee.
+     */
+    assignment?: ResponsibilityAssignment;
+    /**
+     * Principals outside `parties` that may receive an escalation, for example
+     * a human owner. Self-escalation to the initiator is always rejected.
+     */
+    allowedEscalationTargets?: Id[];
+}
+export interface CreateBindingInput {
+    id: Id;
+    assignment?: Id;
+    parties: Id[];
+    purpose: Ref;
+    channel: InteractionChannel;
+    protocol: InteractionProtocol;
+    mode_mix: Partial<Record<InteractionKind, number>>;
+    direction: BindingDirection;
+    cadence: InteractionCadence;
+    expectations?: InteractionExpectations;
+    escalation?: InteractionEscalation[];
+    handoff?: InteractionHandoff;
+    budget?: Budget;
+    why: string;
+    created?: Timestamp;
+    signatures?: Signature[];
+}
+export interface BindingMessageInput {
+    binding: Id;
+    from: Id;
+    to: Id;
+    performative: Performative;
+    at: Timestamp;
+    usage?: Budget;
+}
+export interface BindingMessageResult {
+    binding: InteractionBinding;
+    message: BindingMessageRecord;
+    messages: number;
+    turns: number;
+}
+export interface BindingSweep {
+    binding: InteractionBinding;
+    action: "escalate" | "breach";
+    to?: Id;
+}
+export declare class BindingLedger {
+    private readonly bindings;
+    private readonly eventLog;
+    private readonly acknowledgements;
+    private readonly messages;
+    private readonly usage;
+    private readonly lastActivity;
+    private readonly now;
+    constructor(options: BindingLedgerOptions);
+    create(input: CreateBindingInput, policy?: BindingPolicy): InteractionBinding;
+    ack(id: Id, party: Id, at: Timestamp): InteractionBinding;
+    activate(id: Id, at: Timestamp): InteractionBinding;
+    suspend(id: Id, by: Id, at: Timestamp, reason: string): InteractionBinding;
+    resume(id: Id, by: Id, at: Timestamp): InteractionBinding;
+    recordMessage(input: BindingMessageInput): BindingMessageResult;
+    handoff(id: Id, by: Id, at: Timestamp, state: readonly Ref[], ack: boolean, receipt?: Ref): InteractionBinding;
+    close(id: Id, by: Id, at: Timestamp): InteractionBinding;
+    revoke(id: Id, by: Id, at: Timestamp, reason: string): InteractionBinding;
+    /**
+     * Revoke every non-terminal binding that cites an assignment. Hosts call
+     * this from `AssignmentLedger`'s `onRevoke` callback so the two ledgers
+     * agree on cascade semantics without importing each other.
+     */
+    revokeForAssignment(assignment: Id, by: Id, at: Timestamp, reason: string): InteractionBinding[];
+    /**
+     * Detect overdue bindings. A timeout escalation rule defers the breach;
+     * without one the binding is marked breached.
+     */
+    sweep(at: Timestamp): BindingSweep[];
+    get(id: Id): InteractionBinding;
+    find(id: Id): InteractionBinding | undefined;
+    list(): InteractionBinding[];
+    messagesFor(id: Id): BindingMessageRecord[];
+    usageFor(id: Id): Budget;
+    events(): BindingEvent[];
+    private require;
+    private assertNoDuplicate;
+    private requireStatus;
+    private record;
+}